队列实现杨辉三角

队列实现杨辉三角
队列实现杨辉三角

Main:

queue.h:

typedef int ElemType;

typedef struct Inode{

ElemType data;

struct Inode *next;

}Inode;

typedef struct linkque{

Inode *front;

Inode *rear;

}linkque;

int QueInit(linkque &);

int QueIn(linkque &,ElemType);

int QueOut(linkque &,ElemType &);

app.cpp:

#include

#include

#include

#include "queue.h"

void main(){

linkque q1,q2;

int i,n;

ElemType e,e1,e2,e3;

printf("请输入需要的杨辉三角长度:\n");

scanf("%d",&n);

QueInit(q1);

QueInit(q2);

for(i=1;i<=n;i++){

e3=0;

while(q1.front!=q1.rear){

QueOut(q1,e1);

e2=e3+e1;

printf("%d\t",e2);

QueIn(q2,e2);

e3=e1;

}

if(q1.front==q1.rear){

e2=1;

QueIn(q2,e2);

printf("%d",e2);

printf("\n");

}

while(q2.front!=q2.rear){

QueOut(q2,e);

QueIn(q1,e);

}

}

}

queue.cpp:

#include

#include

#include

#include "queue.h"

int QueInit(linkque &q){

q.front=(Inode *)malloc (sizeof(Inode));

q.rear=q.front;

if(!q.front){

printf("溢出");

return (0);

}

q.front->next=NULL;

return (1);

}

int QueIn(linkque &q,ElemType e){

Inode *p;

p=(Inode *)malloc (sizeof(Inode));

if(!p)

return (0);

p->data=e;

p->next=NULL;

q.rear->next=p;

q.rear=p;

return (1);

}

int QueOut(linkque &q,ElemType &e){ Inode *p;

if(q.front==q.rear)

return (0);

p=q.front->next;

e=p->data;

q.front->next=p->next;

if(q.rear==p)

q.rear=q.front;

free(p);

return(1);

}

杨辉三角队列实现

网上看了许多杨辉三角队列实现的代码,结果运行时都或多或少有点小问题,为此我提供一份自己运行正确的。 程序无误,细心做一下 注意,这是做成三个文件运行的 第一个文件命名 stdafx.h #include #include #define Max 50 struct queue { int *base; int front; int rear; }; typedef struct queue *SqQueue; SqQueue InitQueue();//队列的初始化 int EnQueue(SqQueue Q,int e);//数据进队(从队尾传值) int DeQueue(SqQueue Q);//数据出队(返回队头) void YHPrint(SqQueue Q,int n);//打印杨辉三角 void jiemian();//界面函数,方便调用(个人习惯) 第二个文件命名为 stdafx.c #include "stdafx.h"

int GetQueueFirstData(SqQueue Q) { return Q->base[Q->front]; } int isEmptyQueue(SqQueue Q) { if(Q->front=Q->rear) return 1; else return 0; } SqQueue InitQueue() { SqQueue Q; Q=(SqQueue)malloc(sizeof(struct queue)); if (Q==NULL) return NULL; Q->base=(int *)malloc(Max*sizeof(int)); if(Q->base==NULL) return NULL; Q->front=Q->rear=0; return Q; } int EnQueue(SqQueue Q,int e) { if((Q->rear+1)%Max==Q->front) return 0; Q->base[Q->rear]=e; Q->rear=(Q->rear+1)%Max; return 1; } int DeQueue(SqQueue Q) { int e; if(Q->front==Q->rear) return 0; e=Q->base[Q->front]; Q->front=(Q->front+1)%Max; return e; }

显示杨辉三角实验报告

显示杨辉三角实验报告 姓名:许严班级:计122 学号:1213023050 1.问题描述 杨辉三角如图2.4.3所示,其特点是两个腰上数值是1,其他位置上的每一个整数都是它的上一行相邻两个整数之和。问题是:对于指定的最大行数rmax,要求从第一行到第rmax逐行显示杨辉三角形的所有元素。 2.基本要求 ⑴设计输出形式,尽量反映杨辉三角的特点。 ⑵设计计算杨辉三角形各行数值的方法。 ⑶输入:rmax从键盘输入。 ⑷输出:屏幕输出杨辉三角形. 3.实现提示 ⑴存储设计 计算杨辉三角形第i行时,如果在第i-1行两侧各添加一个0,则第i行的第j个元素等于第i-1行的第j-1个元素与第j个元素的和。计算如图2.4.4所示。第i行计算完,第i-1行的数据就没有用了,依据第i行数据可计算第i+1行的数据。 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 … 图2.4.3 杨辉三角形 从上述计算中不难看出,第i行的元素从左往右依次可被求得,求解过程中也是从左往右依次使用地i-1行的数据,显然,具有先入先出的特点。所以,可借助一个队列存放计算过程中所需的数据,如图2.4.5所示。 但随着航数的增加,队列会很长。所以,可以设置一循环队列,队长不少于rmax+2,边计算边出队。 (2)算法设计 计算各行元素的算法步骤如下。 Step1:队列初始化,0、1入队。队头ftont指向0处,队尾指向1后。 Step2:i从1到rmax,循环执行下列操作,求第i行数据。 2.1 0入队。 2.2 从队首起直到队尾,每出队两元素,求和后入队。 输出时注意0不输出。

队列实验

队列实验 学号:姓名: 一、实验目的: 1.掌握队列的顺序存储结构 2.掌握队列先进先出运算原则在解决实际问题中的应用 二、实验内容: 利用循环顺序队列打印杨辉三角形。杨辉三角形的特点是两个腰上的数字都为1,其它位置上的数字是其上一行中与之相邻的两个整数之和。所以在打印过程中,第i行上的元素要由第i-1行中的元素来生成。在循环队列中依次存放第i-1行上的元素,然后逐个出队并打印,同时生成第i行中间的(n-2)个元素并入队列。打印的杨辉三角形如下所示: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 三、队列顺序存储结构的基本操作: 杨辉三角形输出的行数可以在程序中由输入控制。 队列的基本操作代码参考如下: #include #define TRUE 1 #define FALSE 0 #define MAXSIZE 50 /*队列的最大长度*/ typedef struct { int element[MAXSIZE]; /* 队列的元素空间*/ int front; /*头指针指示器*/ int rear; /*尾指针指示器*/ }SeqQueue;

/*初始化操作*/ void InitQueue(SeqQueue *Q) { /* 将*Q初始化为一个空的循环队列*/ Q->front=Q->rear=0; } /*入队操作*/ int EnterQueue(SeqQueue *Q, int x) { /*将元素x入队*/ if((Q->rear+1)%MAXSIZE==Q->front) /*队列已经满了*/ return(FALSE); Q->rear=(Q->rear+1)%MAXSIZE; /* 重新设置队尾指针*/ Q->element[Q->rear]=x; return(TRUE); /*操作成功*/ } /*出队操作*/ int DeleteQueue(SeqQueue *Q, int *x) { /*删除队列的队头元素,用x返回其值*/ if(Q->front==Q->rear) /*队列为空*/ return(FALSE); Q->front=(Q->front+1)%MAXSIZE; /*重新设置队头指针*/ *x=Q->element[Q->front]; return(TRUE); /*操作成功*/ } /*提取队列的队头元素,用x返回其值*/ int GetHead(SeqQueue *Q, int *x) { if(Q->front==Q->rear) /*队列为空*/ return(FALSE); *x=Q->element[Q->front]; return(TRUE); /*操作成功*/ } 四、打印杨辉三角的函数: void PrintTriangle (int N ) { int i,,n,x,temp; SeqQueue Q;

数据结构实验——队列(附程序)

?、实验目的 1. 了解队列的特性。 2. 掌握队列的顺序表示和实现。 3. 掌握队列的链式表示和实现。 1、实验内容 实验3. 3队列的顺序表示和实现 编写一个程序实现顺序队列的各种基本运算(采用循环队列), 主程序,完成如下功能: ⑴ 初始化队列。 ⑵ 建立顺序队列。 ⑶ 入队。 ⑷ 岀队。 (5) 判断队列是否为空。 ⑹ 取队头元素。 (7) 遍历队列。 实验3.4队列的链式表示和实现 编写一个程序实现链队列的各种基本运算,并在此基础上设计 能: (1) 初始化并建立链队列 ⑵ 入链队列。 ⑶ 岀链队列。 ⑷ 遍历链队列。 #i nclude #in clude #defi ne MAXQSIZE 100 typedef struct { int *base; int front; int rear; }SqQueue;实验三队列 并在此基础上设计一个 个主程序,完成如下功

int Ini tQueue(SqQueue &Q) { Q.base=(i nt*)malloc(MAXQSIZE*sizeof(i nt)); if(!Q.base)exit(O); Q.fro nt=Q.rear=0; return 0; }//初始化顺序队列 int QueueLe ngth(SqQueue Q) { int i; i=(Q.rear-Q.fro nt+MAXQSIZE)%MAXQSIZE; printf(“队列长度%5d\n",i); if(i)printf(" 队列非空“); else printf(" 队列为空"); return 0; }//判断队列是否为空 int En Queue(SqQueue &Q,i nt e) { if((Q.rea 叶1)%MAXQSIZE==Q.fro nt)return 0; Q.base[Q.rear]=e; Q.rear=(Q.rea r+1)%MAXQSIZE; return 0; }//将元素e入队 int DeQueue(SqQueue & Q,i nt e) { if(Q.fro nt==Q.rear)return 0; e=Q.base[Q.fro nt]; prin tf("%5d\n",e); Q.fron t=(Q.fr on t+1)%MAXQSIZE; return 0; }// 删除元素e并返回其值

数据结构第三章栈和队列3习题

第三章栈和队列试题 一、单项选择题 1.栈的插入和删除操作在()进行。 A. 栈顶 B. 栈底 C. 任意位置 D. 指定位置 2.当利用大小为n的数组顺序存储一个栈时,假定用top==n表示栈空,则向这个栈插入一个元素时, 首先应执行()语句修改top指针。 A. top++; B. top--; C. top = 0; D. top; 3.若让元素1,2,3依次进栈,则出栈次序不可能出现()种情况。 A. 3, 2, 1 B. 2, 1, 3 C. 3, 1, 2 D. 1, 3, 2 4.在一个顺序存储的循环队列中,队头指针指向队头元素的()位置。 A. 前一个 B. 后一个 C. 当前 D. 后面 5.当利用大小为n的数组顺序存储一个队列时,该队列的最大长度为()。 A. n-2 B. n-1 C. n D. n+1 6.从一个顺序存储的循环队列中删除一个元素时,需要()。 A. 队头指针加一 B. 队头指针减一 C. 取出队头指针所指的元素 D. 取出队尾指针所指的元素 7.假定一个顺序存储的循环队列的队头和队尾指针分别为front和rear,则判断队空的条件为()。 A. front+1 == rear B. rear+1 == front C. front == 0 D. front == rear 8.假定一个链式队列的队头和队尾指针分别为front和rear,则判断队空的条件为()。 A. front == rear B. front != NULL C. rear != NULL D. front == NULL 9.设链式栈中结点的结构为(data, link),且top是指向栈顶的指针。若想在链式栈的栈顶插入一 个由指针s所指的结点,则应执行操作()。 A. top->link = s; B.s->link = top->link; top->link = s; C. s->link = top; top = s; D. s->link = top; top = top->link; 10.设链式栈中结点的结构为(data, link),且top是指向栈顶的指针。若想摘除链式栈的栈顶结点, 并将被摘除结点的值保存到x中,则应执行操作()。 A. x = top->data; top = top->link; B. top = top->link; x = top->data; C. x = top; top = top->link; D. x = top->data; 11.设循环队列的结构是 #define MaxSize 100 typedef int ElemType;

队列实现杨辉三角

Main:

queue.h: typedef int ElemType; typedef struct Inode{ ElemType data; struct Inode *next; }Inode; typedef struct linkque{ Inode *front; Inode *rear; }linkque; int QueInit(linkque &); int QueIn(linkque &,ElemType); int QueOut(linkque &,ElemType &); app.cpp: #include #include #include #include "queue.h" void main(){ linkque q1,q2; int i,n; ElemType e,e1,e2,e3; printf("请输入需要的杨辉三角长度:\n"); scanf("%d",&n); QueInit(q1); QueInit(q2); for(i=1;i<=n;i++){ e3=0; while(q1.front!=q1.rear){ QueOut(q1,e1); e2=e3+e1; printf("%d\t",e2); QueIn(q2,e2); e3=e1; } if(q1.front==q1.rear){ e2=1; QueIn(q2,e2);

printf("%d",e2); printf("\n"); } while(q2.front!=q2.rear){ QueOut(q2,e); QueIn(q1,e); } } } queue.cpp: #include #include #include #include "queue.h" int QueInit(linkque &q){ q.front=(Inode *)malloc (sizeof(Inode)); q.rear=q.front; if(!q.front){ printf("溢出"); return (0); } q.front->next=NULL; return (1); } int QueIn(linkque &q,ElemType e){ Inode *p; p=(Inode *)malloc (sizeof(Inode)); if(!p) return (0); p->data=e; p->next=NULL; q.rear->next=p; q.rear=p; return (1); } int QueOut(linkque &q,ElemType &e){ Inode *p;

杨辉三角解析(队列实现)

for(i=1;i<=N;++i) { for(j=0;j<30-3*i;++j)//打印每行前面的空格 printf(" "); do { DeQueue(); GetHead(); if(e!=0) printf("%6d",e); EnQueue(); }while(e!=0); UpQueue(); puts("");//每行后回车换行 } 以n=4举例 结果为: 1 1 1 2 1 1 3 3 1 1 4 6 4 1 解析: queue_size=n+2;//队列的最大容量queue_size=6(数组空间大小) for(i=0;i

继续执行do……while语句因为e不为0 DeQueue(); 删除队首元素,并将queue[2]赋值s front=3 GetHead(); 取队首元素,e= queue[front]=queue[3]=1 if(e!=0) printf("%6d",e); e!=0 打印e 即1 EnQueue(); 在队尾添加元素s+e 此时queue[rear]=queue[0]=2 rear=1 继续执行do……while语句因为e不为0 DeQueue(); 删除队首元素,并将queue[3]赋值s front=4 GetHead(); 取队首元素,e= queue[front]=queue[4]=0 if(e!=0) printf("%6d",e); e==0 不执行printf()语句 EnQueue(); 在队尾添加元素s+e 此时queue[rear]=queue[1]=1 rear=2 此时e==0跳出do……while语句 即打印第一行完毕输出: 1 1 UpQueue(); 在队尾添加元素0 即queue[rear]=queue[2]=0 rear=3 队列为: 2 1 0 1 0 1 puts("");//每行后回车换行rear front

实验二 栈与队列操作实验题目

实验二栈与队列操作 实验目的: (1)理解栈与队列的结构特征和运算特征,以便在实际问题背景下灵活运用。 (2)了解复杂问题的递归算法设计。 本次实验中,下列实验项目选做一。 1、顺序栈的基本操作 [问题描述] 设计算法,实现顺序栈的各种基本操作 [基本要求] (1)初始化栈s。 (2)从键盘输入10个字符以$结束,建立顺序栈。 (3)从键盘输入1个元素,执行入栈操作。 (4)将栈顶元素出栈。 (5)判断栈是否为空。 (6)输出从栈顶到栈底元素。 要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。 2、链栈的基本操作 [问题描述] 设计算法,实现链栈的各种基本操作 [基本要求] (1)初始化栈s。 (2)从键盘输入10个字符以$结束,建立带头结点的链栈。 (3)从键盘输入1个元素,执行入栈操作。 (4)完成出栈操作。 (5)判断栈是否为空。 (6)输出从栈顶到栈底元素。 (7)输出链栈的长度。 要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。 3、循环队列的基本操作 [问题描述] 设计算法,实现循环顺序队列的建立、入队、出队等操作。 [基本要求] (1)从键盘输入10个字符以$结束,建立循环队列,并显示结果。 (2)从键盘输入1个元素,执行入队操作,并显示结果。 (3)将队头元素出队,并显示结果。 (4)要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。

4、只用尾指针表示的循环链表队列的综合操作 [问题描述] 假设以带头结点的的循环链表表示队列,并且只设一个指针指向队尾元素的结点(注意不设头指针),试编写队列初始化、入队、出队函数。 [基本要求及提示] (1)首先定义链表结点类型。 (2)编写带头结点的循环链表的初始化函数,只用尾指针表示。 (3)编写入队函数、出队函数。 (4)在主函数中编写菜单(1.初始化;2.入队;3.出队;4.退出),调用上述功能函数。 5、用标志域表示队空队满状态的循环队列的综合操作 [问题描述] 要求循环队列不损失一个空间全部都得到利用,设置一个标志域tag,以0和1来区分当队头与队尾指针相同时队列状态的空和满,试编写与此结构相对应的入队和出队操作。 [基本要求及提示] (1)教材中为区分当队头与队尾指针相同时队列状态的空和满,以牺牲一个空间的代价来实现的,空:Q->front==Q->rear,满:(Q->rear+1)%MAXSIZE==Q->front。 (2)本题不损失一个空间全部都得到利用,为此如下定义循环队列类型: Typedef struct { QueueElementType element[MAXSIZE]; int front; int rear; int tag; }SeqQueue; 此时,循环队列空和满的条件分别为: Q->front==Q->rear&&tag==0 和 Q->front==Q->rear&&tag==1 (3)编写入队函数、出队函数。 (4)在主函数中编写菜单(1.入队;2.出队;3.退出),调用上述功能函数。 6、利用辅助数组进行栈的逆置 [问题描述] 利用辅助栈将栈中的元素逆置。 [基本要求及提示] 在主函数中编写菜单(1.入栈;2.出栈;3.逆置;4.退出)调试运行程序。 7、利用辅助栈进行队列的逆置 [问题描述] 利用辅助栈进行队列元素逆置。 [基本要求及提示] 在主函数中编写菜单(1.入队;2.出队;3.逆置;4.退出)调试运行程序。 8、Hanoi塔问题

杨辉三角队列实现

杨辉三角显示实验报告 1.问题描述: 编写程序,根据输入的行数,屏幕显示杨辉三角。 2.基本要求: (1)行数不大于20行。 (2)基于队列的操作来实现杨辉三角的不断生成过程。(注:不要用其它的公式计算的方法或者二维数组来实现) (3)基于数组实现队列的物理数据结构 3.需求分析: 1、输入形式:输入一个整数n ,0<=n<=20 2、输出形式:打印出来前(n+1)行的杨辉三角数列 3、功能实现:输出前20层的杨辉三角序列 4、样例输入输出:(数据加强版) 输入:10 输出: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1

1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1 1 9 36 84 126 126 84 36 9 1 5、效率分析:O(n) 4.概要设计: 利用到队列先进先出的性质(First In First Out),基本的算法实现是利用已经进队的元素在其出队之前杨辉三角的下一行数列,----即利用要出队的元素来不断地构造新的进队的元素,即在第N行出队的同时,我们来构造杨辉三角的第N+1行,从而实现打印杨辉三角的目的。 5.详细设计: 算法思想已经在概要设计中提到了,现在通过基于队列基本操作的函数以及程序的模块化思想来实现杨辉三角的打印输出问题。 算法函数描述: 队列类: 队列类的数据成员: int front,rear,//ront和rear分别是指向队头和队尾的指针 maxsize;//队列中的元素数 int* listArray //存放队列中的元素 队列的基本操作: V oid Queue(int ) function://构造一个空队列

顺序队列的基本操作

#include #include #include #include #define QueueSize 50 typedef char QueueData; typedef struct queue { QueueData data[QueueSize]; int rear,front; }SeqQueue; void Menu() { printf("\n"); printf("|…………………………………………|\n"); printf("| 1、建立|\n"); printf("| |\n"); printf("| 2、显示|\n"); printf("| |\n"); printf("| 3、入队|\n"); printf("| |\n"); printf("| 4、出队|\n"); printf("| |\n"); printf("| 5、取队头元素|\n"); printf("| |\n"); printf("| 6、退出|\n"); printf("|…………………………………………|\n"); printf("\n"); printf("请选择菜单项,按回车键完成选择:"); } //模块1 建立 void Set(SeqQueue *&Q) { Q=(SeqQueue*)malloc(sizeof(SeqQueue)); if(Q==NULL) { printf("存储空间分配失败!\n"); exit(1); } else { printf("存储空间分配成功!\n"); } Q->front=Q->rear=-1; //置空队列

数据结构——队列的应用

软件学院 上机实验报告 课程名称:数据结构 实验项目:队列的应用 实验室:耘慧420 姓名:学号 专业班级:实验时间: 2016.11.17

一、实验目的及要求 (一) 目的 1.掌握栈队列特点及顺序存储结构(循环队列)下基本操作的实现。 2.掌握队列的应用,能根据问题特点选择队列结构。 (二).要求 1.定义循环队列的存储结构 2.完成入队、出队、取队头等基本操作的实现。 3.利用队列的基本操作实现n行杨辉三角的输出。 4.主函数调用杨辉三角输出函数,实现n行杨辉三角输出。 二、性质 设计性 三、实验学时 2学时 四、实验环境 C与C++程序设计学习与实验系统 五、实验内容及步骤 (一).内容 1.定义循环队列的存储结构,完成入队、出队、取队头等基本操作的实现。 2. 利用循环队列实现杨辉三角的输出 (二).步骤 1.//---------循环队列—队列的顺序存储结构 ----- #define MAXSIZE 100

typedef struct { QElemType *base; //初始化的动态分配存储空间 int front; //头指针,队列不空指向队列头元素 int rear; //尾指针,队列不空指向队列尾元素下一位置 } SqQueue; 2.杨辉三角: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 …………………… 这是一个初等数学中讨论的问题。系数表中的第 k行有 k个数,除了第一个和最后一个数为1之外,其余的数则为上一行中位其左、右的两数之和。 如果要求计算并输出杨辉三角前n行的值,则队列的最大空间应为 n+2。假设队列中已存有第 k 行的计算结果,并为了计算方便,在两行之间添加一个"0"作为行界值,则在计算第 k+1 行之前,头指针正指向第 k 行的"0",而尾元素为第 k+1 行的"0"。由此从左到右依次输出第 k 行的值,并将计算所得的第 k+1 行的值插入队列的基本操作为: void YangHui(int n) { printf("1\n"); EnQueue(&q,0); /*开始*/ EnQueue(&q,1); /*第1行*/ EnQueue(&q,1); for(j=2;j<=n;j++) { EnQueue(&q,0); do{

杨辉三角的各种算法实现

/* Name: 杨辉三角算法集锦 Copyright: 始发于goal00001111的专栏;允许自由转载,但必须注明作者和出处Author: goal00001111 Date: 27-11-08 19:04 Description: 分别使用了二维数组,一维数组,队列,二项式公式,组合公式推论和递归方法等9种算法 算法思路详见代码注释——注释很详细,呵呵 */ #include #include using namespace std; const int MAXROW = 40; void PrintBlank(int n); int Com(int n, int m); int Try(int row, int cel); void Fun_1(int row); void Fun_2(int row); void Fun_3(int row); void Fun_4(int row); void Fun_5(int row); void Fun_6(int row); void Fun_7(int row); void Fun_8(int row); void Fun_9(int row); int main() { int row; cin >> row; Fun_1(row); cout << endl; Fun_2(row); cout << endl; Fun_3(row); cout << endl; Fun_4(row); cout << endl; Fun_5(row);

cout << endl; Fun_6(row); cout << endl; Fun_7(row); cout << endl; Fun_8(row); cout << endl; Fun_9(row); system("pause"); return 0; } //输出n个空格 void PrintBlank(int n) { for (int i=0; i

数据结构-利用循环队列打印杨辉三角

//------循环队列—队列的顺序存储结构----- #include #include #include //exit的头文件 #define OK 1 #define ERROR 0 #define MAXQSIZE 100//最大队列长度 #define Status int #define N 10 #define QElemType int typedef struct{ QElemType *base;//初始化的动态分配存储空间 int front; //头指针,若队列不空,指向队列头元素 int rear; //尾指针,若队列不空,指向队列队尾元素的下一位置}SqQueue; //-----循环队列的基本操作的算法描述---- Status InitQueue(SqQueue &Q){ //构造一个空队列 Q.base=(QElemType *)malloc(MAXQSIZE * sizeof(QElemType)); if(!Q.base)exit(-1);//存储分配失败 Q.front=Q.rear=0; return OK; } int QueueLength(SqQueue Q){ //返回Q的元素个数,即队列的长度 return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE; } Status EnQueue(SqQueue &Q,QElemType e){ //插入元素e为Q的新的队尾元素 if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;//队列满 Q.base[Q.rear]=e; Q.rear=(Q.rear+1)%MAXQSIZE; return OK; } Status DeQueue(SqQueue &Q,QElemType &e){ //若队列不空,则删除Q的队头元素,用e返回其值,并返回OK; //否则返回ERROR if(Q.front==Q.rear) return ERROR; e=Q.base[Q.front]; Q.front=(Q.front+1)%MAXQSIZE; return OK; } Status GetHead(SqQueue &Q,QElemType &e){ //若队列不空,则用e返回Q的队头元素,并返回OK;

数据结构实验报告—队列

《算法与数据结构》课程

一、实验目的 掌握队列的存储结构及进队/出队等操作的实现。 二、实验内容及要求 1.实现队列的一种存储结构。 2.实现队列的相关操作。 3.利用队列的操作特点,借助进队与出队操作完成打印二项式系数的任务。 三、系统分析 (1)数据方面:该队列数据元素类型采用整型,在此基础上进行队列的一些基本操作,应用体现在打印二项式系数即打印杨辉三角形。 (2)功能方面: 1.进队操作:若队列不满,则将元素x进入队列。 2.出队操作:若队列不空,则退出队头元素x并由函数返回true,否则返 回false。 3.获取队头元素:若队列不为空,则函数返回true及队头元素的值,否则 返回false。 4.判断队列是否为空、判断队列是否满。 5.计算队列中元素个数:直接返回队列中元素个数。 6.清空队列内容:队头指针和队尾指针置0。 7.打印杨辉三角形前n行数字。 四、系统设计 (1)设计的主要思路 队列得基于数组得存储表示亦称为顺序队列,是利用一个一维数组作为队列元素的存储结构,并且设置两个指针front和rear,分别指示队列的队头和队尾位置。每当添加一个新元素时,先将新元素添加到rear所指位置,再让队尾指针

rear进1。每当退出队头元素,应当先把front所指位置元素记录下来,再让队头指针进1,指示下一队头元素位置,最后把记录下来的元素值返回。 但当队头指针front==rear,队列为空;而当rear==maxSize时,队列满,如果再加入新元素,就会产生“溢出”。但这种“溢出”可能时假溢出,因为在数组的前端可能还有空位置。为了能够充分地使用数组中的存储空间,把数组的前端和后端连接起来,形成一个环形表,即把存储队列元素的表从逻辑上看成一个环,成为循环队列。循环队列的首尾相接,当队头指针front和队尾指针rear进到maxSize-1后,再前进一个位置就自动到0.这可以利用除法取余的运算实现。(2)数据结构的设计 队列的定义是一种限定存取位置的线性表。它只允许在表的一端插入,在另一端删除。允许插入的一端叫做队尾,允许删除的一端叫做队头。最先进入队列的元素最先退出队列,队列这种特性叫做先进先出。 空队列 A进队 对头指针进1:front=(front+1)%maxSize; 队尾指针进1:rear=(rear+1)%maxSize; 队列初始化:front=rear=0; 循环队列的队头指针和队尾指针初始化时都设置为0:front=rear=0.在队尾插入新元素和删除队头元素时,两个指针都按顺时针方向进1.当它们进到maxSize-1时,并不表示表的终结,只要有需要,利用%运算可以前进到数组的0号位置。 五、编程环境与实验步骤 (1)编程环境 操作系统:Windows操作系统;编程工具软件:Visual Studio 2017 (2)实验步骤 无文件操作。 (3)编译参数

杨辉三角源代码

#include #include using namespace std; enum error_code{underflow,success,overflow}; class queue{ public: queue(); bool empty()const; bool full()const; error_code get_front(int & x)const; error_code append(const int x); error_code serve(); private: int count; int front,rear; int data[50]; }; queue::queue(){count=0;front=rear=0;} bool queue::empty()const{ if(count==0) return true; return false; } bool queue::full()const{ if(count==49) return true; return false; } error_code queue::get_front(int &x)const { if(empty())return underflow; x=data[(front+1)%50]; return success; } error_code queue::append(const int x){ if(full())return overflow; rear=(rear+1)%50; data[rear]=x; count++; return success; } error_code queue::serve(){ if(empty()) return underflow;

栈-队列的顺序-链式储存结构(数据结构试验报告)

数据结构实验报告 班级:计 学号: 姓名: 设计日期: 西安计算机学院

实验题目 1)栈的顺序存储结构 2)栈的链式存储结构 3)队列的链式存储结构 4)队列的循环存储结构 2.需求分析 本演示程序用C语言编写,完成栈和列的初始化,入栈、出栈、输出操作。 1)对于顺序栈,入栈时要先判断栈是否满了,栈满不能入栈,否则出现空间溢出;在进栈出栈和读取栈顶时先判栈是否为空,为空时不能操作。 2)在一个链队表中需设定两个指针分别指向队列的头和尾。 3)队列的存储结构:注意要判断队满和队空。 4)程序所能达到的功能:完成栈的初始化,入栈,出栈和输出操作;完成队列的初始化,入队列,出队列和输出操作。 3.概要设计 本程序包含 1、栈的顺序存储结构包含的函数: 1)主函数main() 2)入栈函数Push() 3)出栈函数Pop()

2、栈的链式存储结构包含的函数: 1)主函数main() 2)入栈函数PushStack() 3)退栈函数PopStack() 4)取栈顶元素函数Getstack top() 3、队列的链式存储结构所包含的函数:1)主函数main() 2)入队函数EnQueue() 3)出队函数DeQueue() 4 队列的循环所包含的函数: 1)主函数main() 2)初始化循环函数CircSeqQueue() 3)入队函数EnQueue() 4)出队函数DeQueue() 5)取队首元素函数GetFront() 4.详细设计 1)栈的顺序存储结构 #include #include #include #define MAXSIZE 20 typedef int datatype; typedef struct { datatype elem[MAXSIZE];

数据结构 队列实验报告

队列实验报告 小组成员:xxxxxxxx日期:xxxxxxxx 一、需求分析(xxx) 1.链队列 1)在本演示程序中,首先要链队列添加一个头结点,并判断队列是否为空,它只允许在表的一端进行插入,而在另一端删除元素,允许插入的一段叫队尾,允许删除的一端则为对头,接着访问队列中所有元素,并输出,输出是每个元素之间用空格来完成。最后销毁队列,释放空间。 2)演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“欢迎来到链队列”“元素入队”“元素出队”“销毁队列”“清空队列”之后。由用户在键盘上输入演示程序中规定的运算命令,相应的运算数据和显示结果显示在其后。 3)程序执行的命令包括: 欢迎来到链队列 1输出队列长度 2元素入队 3元素出队 4销毁队列 5清空队列 6对头元素 7退出链队列 4)测试数据 入队 1 2 3 4 5 分别执行“元素入队”“元素出队”“销毁队列”“清空队列”等操作。 2.顺序队列 1)在本演示程序中,首先要顺序队列添加一个头结点,并判断队列是否为空,它只允许在表的一端进行插入,而在另一端删除元素,允许插入的一段叫队尾,允许删除的一端则为对头,接着访问队列中所有元素,并输出,输出是每个元素之间用空格来完成。 2)演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“欢迎来到链队列”“元素入队”“元素出队”“取得头结点”“输出显示”之后。由用户在键盘上输入演示程序中规定的运算命令,相应的运算数据和显示结果显示在其后。 3)程序执行的命令包括: 欢迎来到顺序队列 1入队 2出队 3判断是否为空 4取得头结点 5输出显示 6退出顺序队列 4)测试数据 入队 1 2 3

数据结构实验报告-显示杨辉三角形

数 据 结 构 课 程 实 验 报 告 班级:计嵌141 姓名:陈志远 学号:1413052023

显示杨辉三角实验报告 1.问题描述 杨辉三角如图2.4.3所示,其特点是两个腰上数值是1,其他位置上的每一个整数都是它的上一行相邻两个整数之和。问题是:对于指定的最大行数rmax,要求从第行到第rmax逐行显示杨辉三角形的所有元素。 2.基本要求 ⑴设计输出形式,尽量反映杨辉三角的特点。 ⑵设计计算杨辉三角形各行数值的方法。 ⑶输入:rmax从键盘输入。 ⑷输出:屏幕输出杨辉三角形 3.实现提示 ⑴存储设计 计算杨辉三角形第i行时,如果在第i-1行两侧各添加一个0,则第i行的第j个元素等于i-1行的第j-1个元素与第j个元素的和。计算如图2.4.4所示。第i行计算完,第i-1行的数据就没有用了,依据第i行数据可计算第i+1行的数据。 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 … 图2.4.3 杨辉三角形从上述计算中不难看出,第i行的元素从左往右依次可被求得,求解过程中也是从左往右依次使用地i-1行的数据,显然,具有先入先出的特点。所以,可 借助一个队列存放计算过程中所需的数据,如图2.4.5所示。 但随着航数的增加,队列会很长。所以,可以设置一循环队列,队长不少于rmax+2,边计算边出队。 (2)算法设计 计算各行元素的算法步骤如下。 Step1:队列初始化,0、1入队。队头ftont指向0处,队尾指向1后。 Step2:i从1到rmax,循环执行下列操作,求第i行数据。 2.1 0入队。 2.2 从队首起直到队尾,每出队两元素,求和后入队。 输出时注意0不输出。 (3) 程序设计 #include using namespace std; #include

相关文档
最新文档