循环队列实验报告
实验三队列实验报告
计算机科学与技术系实验报告专业名称计算机科学与技术课程名称数据结构与算法项目名称实验三队列实验班级学号 1姓名同组人员无实验日期实验三队列实验实验题目:建立含有若干个元素的循环队列和链队列,并分别实现循环队列和链队列的入队和出对操作。
(1)先实现循环队列的入队和出队操作1.问题分析本程序要求实现建立含有若干个元素的循环队列,并实现循环队列的入队和出队操作。
完成该实验需要以下4个子任务:○1定义一个循环队列的存储结构,定义队列的基本算法。
○2定义一个display()函数实现队列元素的输出看入队是否成功○3通过队列的基本算法实现队列的出队操作○4在主函数中完成操作测试数据设计如下:1 2 3 4 562.概要设计为了实现上述程序功能,需要:○1声明一个循环队列○2定义出队列的基本算法,○3通过键盘输入5个整数,入队,出队○4在主函数中先往队列里输入5个元素,然后入队,输出,看入队是否成功,然后出队,再调用display()函数看是否出队。
1)本程序包含7个函数:1主函数main()2.置空队:InitQueue()3.判对空: QueueEmpty()4.判队满:QueueFull()5.入队:Add()6.出队:Delete()7.display()各函数关系如下:I nitQueue()QueueEmpty() Main () QueueFull()Add()MainDelete()display()3、详细设计实现概要设计中定义的所有的数据类型,对每个操作给出了算法和代码,主程序和模块都需要代码。
(1)循环队列#define maxlen 10typedef struct{int data [maxlen];int front;int rear;}SeqQueue;(2)队列基本算法SeqQueue *InitQueue(SeqQueue *q) //建立一个空循环队列{q=(SeqQueue *)malloc(sizeof (SeqQueue));q->front=0;q->rear=0;return q;}int QueueFull (SeqQueue *q){ //判断队列是否为满if (q->front==(q->rear+1)%maxlen)return 1;* * else return 0;}int QueueEmpty(SeqQueue *q){ //判断队列是否为空if (q->rear==q->front)return 1;else return 0;}void Add (SeqQueue *q,int x) //入队{if(!QueueFull(q)){q->rear=(q->rear+1)%maxlen;q->data[q->rear]=x;}else printf ("queue full");}void Delete(SeqQueue *q){ //出队if (!QueueEmpty(q))q->front=(q->front+1)%maxlen;else printf ("queue Empty");}* *(3)用display()函数输出循环队列元素void display(SeqQueue *q) //输出循环队列q的元素{int i;if(q->front!=q->rear) //循环队列非空,输出队列元素{printf("输出循环队列元素:");i=q->front;do{i=(i+1)%maxlen;printf("%d",q->data[i]);}while(i!=q->rear);}elseprintf("队列为空!");}(4)在主函数中先往队列里输入5个元素,输出,看入队是否成功,然后出队,再调用display()函数看是否出队。
循环队列操作实验报告
实验目的:通过本次实验,掌握循环队列的基本概念和操作方法,了解其在实际应用中的优势,并能够熟练运用循环队列解决实际问题。
实验环境:操作系统:Windows 10编程语言:C语言开发环境:Visual Studio实验内容:1. 循环队列的定义及初始化2. 循环队列的入队操作3. 循环队列的出队操作4. 循环队列的判空操作5. 循环队列的判满操作6. 循环队列的遍历操作7. 循环队列的应用实例实验步骤:一、循环队列的定义及初始化1. 定义循环队列的数据结构:```c#define MAX_SIZE 100 // 定义队列的最大容量typedef struct {int data[MAX_SIZE]; // 存储队列元素的数组int front; // 队头指针int rear; // 队尾指针} CircleQueue;```2. 初始化循环队列:```cvoid InitQueue(CircleQueue q) {q->front = q->rear = 0; // 初始化队头和队尾指针}```二、循环队列的入队操作1. 判断队列是否已满:```cint IsFull(CircleQueue q) {return (q->rear + 1) % MAX_SIZE == q->front;}```2. 入队操作:```cint EnQueue(CircleQueue q, int e) {if (IsFull(q)) {return 0; // 队列已满,无法入队}q->data[q->rear] = e; // 将元素e入队q->rear = (q->rear + 1) % MAX_SIZE; // 更新队尾指针return 1; // 入队成功}```三、循环队列的出队操作1. 判断队列是否为空:```cint IsEmpty(CircleQueue q) {return q->front == q->rear;}```2. 出队操作:```cint DeQueue(CircleQueue q, int e) {if (IsEmpty(q)) {return 0; // 队列为空,无法出队}e = q->data[q->front]; // 将队头元素出队q->front = (q->front + 1) % MAX_SIZE; // 更新队头指针 return 1; // 出队成功}```四、循环队列的判空操作1. 判断队列是否为空:```cint IsEmpty(CircleQueue q) {return q->front == q->rear;}```五、循环队列的判满操作1. 判断队列是否已满:```cint IsFull(CircleQueue q) {return (q->rear + 1) % MAX_SIZE == q->front; }```六、循环队列的遍历操作1. 遍历循环队列:```cvoid TraverseQueue(CircleQueue q) {if (IsEmpty(q)) {printf("队列为空,无法遍历。
实验5 循环队列的实现
实验五循环队列的实现一.实验目的掌握队列的基本操作:初始化队列、判队空、入队、出队等运算及程序实现方法。
二.实验内容(1)定义队列的顺序存取结构—循环队列。
(2)分别定义循环队列的基本操作(初始化队列、判队空、入队、出队等)。
(3)设计一个测试主函数进行测试。
三.实验要求(1)根据实验内容编写程序,上机调试并获得运行结果(2)撰写实验报告四.准备工作本次实验将会建立下图所示循环队列,并会根据此循环队列进行新增,删除等操作五.关键操作思路与算法(1).循环队列的类型定义语句如下;1.typedef struct2.{3.int front,rear;4. datatype data[MAXNUM];5.}SeqQueue;(2)置空队1.//置空队2.SeqQueue * SQueueCreate()3.{4. SeqQueue * sq=(SeqQueue*)malloc(sizeof(SeqQueue));5.if(sq==NULL)6. {7. printf("溢出!\n");8. }9.else10. {11. sq->front=sq->rear=0;12. }13.return sq;14.}(3)入队1.//进队2.void SQueueEnQueue(SeqQueue *sq,datatype x)3.{4.if((sq->rear+1)%MAXNUM==sq->front)5. {6. printf("队列满!\n");7. }8.else9. {10. sq->rear = (sq->rear+1)%MAXNUM;11. sq->data[sq->rear] = x ;12. }13.14.}(4)出队1.//出队2.int SQueueDeQueue(SeqQueue *sq,datatype *e)3.{4.if (sq->front==sq->rear)5. {6. printf("栈空!\n");7.return ERROR;8. }9.else10. {11. sq->front = (sq->front+1)%MAXNUM;12. *e = sq->data[sq->front];13.return OK;14. }15.}(5)判断队空1.//判断空函数2.int SQueueIsEmpty(SeqQueue *sq)3.{4.if (sq->front==sq->rear)5. {6.return TRUE;7. }8.else9. {10.return FALSE;11. }12.}六.源代码1.#include<string.h>2.#include<malloc.h>3.#include<limits.h>4.#include<stdio.h>5.#include<stdlib.h>6.#include<io.h>7.#include<math.h>8.#include<process.h>9.#define TRUE 110.#define FALSE 011.#define OK 112.#define ERROR -113.#define INFEASIBLE -114.#define MAXNUM 10015.typedef int datatype;16.17.typedef struct18.{19.int front,rear;20. datatype data[MAXNUM];21.}SeqQueue;22.//置空队23.SeqQueue * SQueueCreate()24.{25. SeqQueue * sq=(SeqQueue*)malloc(sizeof(SeqQueue));26.if(sq==NULL)27. {28. printf("溢出!\n");29. }30.else31. {32. sq->front=sq->rear=0;33. }34.return sq;35.}36.//判断空函数37.int SQueueIsEmpty(SeqQueue *sq)38.{39.if (sq->front==sq->rear)40. {41.return TRUE;42. }43.else44. {45.return FALSE;46. }47.}48.//进队49.void SQueueEnQueue(SeqQueue *sq,datatype x)50.{51.if((sq->rear+1)%MAXNUM==sq->front)52. {53. printf("队列满!\n");54. }55.else56. {57. sq->rear = (sq->rear+1)%MAXNUM;58. sq->data[sq->rear] = x ;59. }60.61.}62.//出队63.int SQueueDeQueue(SeqQueue *sq,datatype *e)64.{65.if (sq->front==sq->rear)66. {67. printf("栈空!\n");68.return ERROR;69. }70.else71. {72. sq->front = (sq->front+1)%MAXNUM;73. *e = sq->data[sq->front];74.return OK;75. }76.}77.//读对头元素78.datatype SQueueFront (SeqQueue *sq)79.{80.if (sq->front == sq->rear)81. {82. printf("队空下溢\n");83.return ERROR;84. }85.else86. {87.return(sq->data[(sq->front+1)%MAXNUM]);88. }89.}90.//输出循环序列91.void SQueueprint(SeqQueue *sq)92.{93.int i =(sq->front +1)%MAXNUM;94.while (i!=sq->rear+1)95. {96. printf("\t%d",sq->data[i]);97. i = (i+1)%MAXNUM;98. }99.// for(int i = (sq->front + 1)%MAXNUM;i != sq->rear + 1;i = (i + 1) % MAXNUM)100.// printf("\t%d",sq->data[i]);101.}102.103.int main()104.{105. SeqQueue *q;106. datatype x;107.int read;108.do109. {110. puts(" 关于循环队列的操作\n");111. puts(" ===========================\n"); 112. puts(" 1------置空队");113. puts(" 2------入队");114. puts(" 3------出队");115. puts(" 4------判断空队");116. puts(" 5------输出");117. puts(" 6------读队头元素");118. puts(" 0------退出");119. printf(" 请选择代号(0-6):");120. scanf("%d",&read);121. printf("\n");122.switch(read)123. {124.case 1:125. q=SQueueCreate();126.break;127.case 2:128. printf("请输入需要入队的元素:");129. scanf("%d",&x);130. SQueueEnQueue(q,x);131.break;132.case 3:133. SQueueDeQueue(q,&x);134. printf("出队数据元素是: %d\n",x);135.break;136.case 4:137.if (SQueueIsEmpty(q))138. {139. printf("队列已空!\n");140. }141.else142. {143. printf("队列不空!\n");144. }145.break;146.case 5:147. printf("\n 现在队列中的元素依次为:\n");148. SQueueprint(q);149. printf("\n");150.break;151.case 6:152. x = SQueueFront(q);153. printf("%d",x);154.break;155.case 0:156. read = 0;157.break;158.default:;159. }160. }while(read != 0);161.}七.程序图七.实验总结本届实验学习了队列这种操作受限的线性表,它只允许在一端插入,并在另一端进行删除在表中只允许进行插入的那一端称为队尾,只允许进行删除的那一段称为队头队头元素总是最先进队列的,同时也是最后出队列的,而对尾元素最后进队列的,同时也是最先出队列的,因此,队列也被称为”先进先出”的线性表,队列采用顺序存储结构时,为了解决假溢出问题,常常会设计成循环链表(首尾相连)来存储。
数据结构实验报告(C语言)(强力推荐)
数据结构实验实验内容和目的:掌握几种基本的数据结构:集合、线性结构、树形结构等在求解实际问题中的应用,以及培养书写规范文档的技巧。
学习基本的查找和排序技术。
让我们在实际上机中具有编制相当规模的程序的能力。
养成一种良好的程序设计风格。
实验教材:数据结构题集(C语言版)清华大学出版社2007年实验项目:实验一、栈和循环队列㈠、实验内容:①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等,栈的顺序存储结构和链式存储结构,以便在实际问题背景下灵活应用。
本程序采用的是链栈结构,具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。
②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,学会循环队列的实现,以便在实际问题背景下灵活运用。
本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。
㈡、实验代码①栈程序代码:#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果:②循环队列程序代码:#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为:\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为:\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果:实验二、数组㈠、实验内容:数组一般不做插入或删除操作,也就是说,一旦建立了数组,则结构中的数据元素个数和元素之间的关系就不再发生变动。
循环队列的实验报告
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;
}
void out_Q(SqQueue Q){
char ch;
if (Q.front == Q.rear ) printf("队列为空。");
else {printf("\n%d",*Q.base );
Q.ቤተ መጻሕፍቲ ባይዱase++;}
printf("\n打回车键,继续。");
ch=getchar();
printf("\n======================================");
printf("\n请输入您的选择(1,2,3)");
scanf("%d",&k);
switch(k){
case 1:{
printf("\n进队e=?");
scanf("%d",&e);
EnQueue(Q,e);
printf("\n再见!");
printf("\n打回车键,返回。");
ch=getchar();
}
实验程序执行结果:(实验结果可以手写,也可以截屏打印出来。)
顺序循环队列实验报告
一、实验目的1. 理解顺序循环队列的概念和原理。
2. 掌握顺序循环队列的初始化、入队、出队等基本操作。
3. 通过编程实现顺序循环队列,并验证其功能。
二、实验原理顺序循环队列是一种利用一维数组实现队列的存储结构。
它将一维数组看作是首尾相连的循环结构,队列的头部和尾部在数组的两端。
顺序循环队列的特点是:队列满时,头指针和尾指针相差一个数组的长度;队列空时,头指针和尾指针相等。
顺序循环队列的基本操作如下:1. 初始化:创建一个顺序循环队列,并设置头指针和尾指针。
2. 入队:将元素插入队列尾部。
3. 出队:从队列头部删除元素。
4. 判断队列是否为空或满。
三、实验内容1. 创建顺序循环队列类。
2. 实现顺序循环队列的初始化、入队、出队等基本操作。
3. 编写测试代码,验证顺序循环队列的功能。
四、实验步骤1. 创建顺序循环队列类,定义队列长度、头指针、尾指针等属性。
2. 实现顺序循环队列的初始化方法,初始化头指针和尾指针。
3. 实现顺序循环队列的入队方法,判断队列是否已满,如果未满,将元素插入队列尾部,并更新尾指针;如果已满,则提示队列已满。
4. 实现顺序循环队列的出队方法,判断队列是否为空,如果为空,则提示队列已空;如果未空,则从队列头部删除元素,并更新头指针。
5. 编写测试代码,创建顺序循环队列实例,执行入队和出队操作,验证顺序循环队列的功能。
五、实验结果与分析1. 初始化顺序循环队列```pythonclass CircularQueue:def __init__(self, size):self.queue = [None] sizeself.head = 0self.tail = 0self.count = 0self.maxsize = size```2. 入队操作```pythondef enqueue(self, item):if self.count == self.maxsize:print("Queue is full")else:self.queue[self.tail] = itemself.tail = (self.tail + 1) % self.maxsizeself.count += 1```3. 出队操作```pythondef dequeue(self):if self.count == 0:print("Queue is empty")else:item = self.queue[self.head]self.queue[self.head] = Noneself.head = (self.head + 1) % self.maxsize self.count -= 1return item```4. 测试代码```pythondef test_circular_queue():queue = CircularQueue(5)print("Enqueue 1 to 5:")for i in range(1, 6):queue.enqueue(i)print(queue.queue)print("Dequeue 1 to 5:")for _ in range(5):print(queue.dequeue())print(queue.queue)test_circular_queue()```实验结果分析:通过测试代码,我们可以看到顺序循环队列在初始化、入队和出队操作时都能正确执行。
循环队列实验报告心得与体会
循环队列实验报告心得与体会循环队列是数据结构中一个非常经典的概念,相对于其他队列结构,循环队列可以优化存储空间的使用,减少空间的浪费。
循环队列的操作也比较高效,能够快速执行入队和出队操作。
本次实验,我们对循环队列结构进行了深入的了解与实践,更深刻地认识到了数据结构的重要性。
在实验中,我们首先对循环队列的基本概念进行了学习,通过查阅相关资料和教材,我们了解到循环队列是一种环形的特殊队列,其队尾指针在达到数组的末尾时,再从数组的第一个位置开始存储数据,如此循环下去。
这样一来,就可以充分利用数组中的元素,减少不必要的空间浪费,提高队列结构的空间利用率。
在深入了解循环队列的概念之后,我们开始实现循环队列的基本操作,包括入队、出队、判空、判满等。
通过实现这些基础操作,我们更加熟悉了循环队列的内部结构和操作流程,同时也掌握了程序设计中的一些基本思路和技巧。
在实验过程中,我们还注意到了循环队列一些常见的问题和局限性。
当队列元素数量达到数组大小时,会出现队列满的情况,此时需要进行特殊处理。
由于循环队列是基于数组实现的,所以其大小是固定的,不能动态调整,这也是循环队列的一个缺陷。
在实验结束后,我们对循环队列的性能进行了一些简单分析。
通过测试,我们发现循环队列在入队和出队操作的时间复杂度都是O(1),即不受元素数量的影响,具有较高的效率。
这进一步证明了循环队列是一种高效的数据结构。
本次实验让我们深入了解了循环队列的内部结构和基本操作,也发现了循环队列存在的问题和局限性。
通过这次实验的实践,我们进一步理解了数据结构的重要性,同时也锻炼了自己的程序设计能力和思维能力。
除了实现循环队列的基本操作,我们还对循环队列进行了扩展,添加了一些实用的操作,比如获取队列长度、获取队首和队尾元素等。
这些操作虽然不是必要的,但是在实际的应用中却非常实用,可以方便我们处理队列中的元素。
我们在实验中还掌握了一些编程技巧和调试工具,来提高程序的效率和可靠性。
实验1.2 顺序循环队列的实现
数据输入与输出要求
输入示例:
输入要入队的元素个数:
8
10
0
输出示例:
41 67 34 0 69 24 78 58
41 67 34 0 69 24 78 58
62 64 5 45 81 27 61 91 95 42
62 64 5 45 81 27 61 91 95 42
{
if(Q.count!=0)return 1;
else return 0;
}
(3)入队列
QueueAppend(SeqCQueue *Q,DataType x)
int QueueAppend(SeqCQueue *Q,DataType x) /*把数据元素值x插入顺序循环队列Q的队尾,成功返回1,失败则返回0*/
}
}
(4)出队列
QueueDelete(SeqCQueue*Q,DataType *d)
int QueueDelete(SeqCQueue*Q,DataType *d) /*删除顺序循环队列Q的队头元素并赋给d,成功返回1,失败返回0*/
{
if(Q->count==0)
{ printf(“队列已空无数据元素出队列!\n”);
{
if(Q.count==0)
{printf(“队列已空无数据元素可取!\n”);
return 0;
}
else {
*d=Q.queue[Q.front];
return 1;
}
}
调试情况
教师评阅
教师签字:日期:
实验1.2顺序循环队列的实现
实验目的
1.熟悉并能实现顺序循环队列的定义和基本操作。
实验8 队列(循环队列)的表示和实现
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验八队列(循环队列)的表示和实现实验成绩指导老师(签名)日期一.实验目的和要求1、掌握队列的存储结构及基本操作。
2、掌握循环队列的设置及循环队列的各种基本操作的实现。
3、通过具体的应用实例,进一步熟悉和掌握队列的实际应用。
二.实验内容1、建立头文件test8.h,定义顺序存储的循环队列存储结构,并编写循环队列的各种基本操作实现函数。
同时建立一个验证操作实现的主函数文件test8.cpp,编译并调试程序,直到正确运行。
说明:队列的基本操作可包括:①void InitQueue (Queue &Q); //构造一个空队列Q②int EmptyQueue (Queue Q);//判断队列Q是否为空,若空返回1,否则返回0③void EnQueue (Queue &Q, ElemType item); //元素item 进队列Q④ElemType OutQueue (Queue &Q); //队头元素出队列Q,并返回其值⑤ElemType PeekQueue (Queue Q); //返回队头元素值⑥void ClearQueue (Queue &Q); //清空队列2、应用(选做部分):编写程序,实现舞伴问题:假设在周末舞会上,男士们和女士们进入舞厅时,各自排成一队,跳舞开始时,依次从男队和女队的队头上各出一人配成舞伴,若两队初始人数不相同,则较长的那一队中未配对者等待下一轮舞曲。
现要求设计一个函数void partner(),模拟上述舞伴配对问题。
基本要求:1)由键盘输入数据,每对数据包括姓名和性别;2)输出结果包括配成舞伴的女士和男士的姓名,以及未配对者的队伍名称和队头者的姓名;3)要求利用test8.h中已实现的顺序循环队列的基本操作函数来实现。
函数void partner()添加到文件test8.cpp中,在主函数中进行调用测试。
数据结构C语言版实验五 循环队列的基本操作
Q.base[Q.rear]=e;
Q.rear=(Q.rear+1)%MAXQSIZE;
return 1;
}
int DeQueue(SqQueue &Q,QElemType &e) {
if(Q.front==Q.rear) return 0;
(1)能够熟练在Visual C++6.0环境中进行程序的编辑、编译和调试;
(2)会书写类C语言的算法,并将算法转变为程序实现。
4、程序运行框架
#include <stdio.h>
#include <malloc.h>
#define MAXQSIZE 5
typedef char QElemType;
typedef struct {
QElemType *base;
int front;
int rear;
}SqQueue;
int InitQueue(SqQueue &Q) {return 0; }
int QueueLength(SqQueue Q) {return 0; }
补充程序,在循环队列中依次将元素A、B、C、D入队,求队列长度之后出队,再将E、F入队最后显示队列元素,并观察运行结果。
实验内容可执行程序:
#include <stdio.h>
#include <malloc.h>
#define MAXQSIZE 5
typedef char QElemType;
队列的操作实验报告
队列的操作实验报告队列的操作实验报告一、实验目的本次实验旨在通过对队列的操作,加深学生对队列数据结构的理解,掌握队列的基本操作方法。
二、实验原理队列是一种先进先出(First In First Out,FIFO)的线性数据结构。
它可以用数组或链表来实现。
在队列中,新元素插入到队尾,已有元素从队头删除。
因此,队列具有以下几个特点:1. 只允许在一端插入元素,在另一端删除元素。
2. 插入和删除元素时分别称为入队和出队。
3. 入队操作在队尾进行,出队操作在对头进行。
三、实验内容本次实验主要涉及以下几个方面:1. 队列的初始化:初始化一个空的循环队列。
2. 入队操作:将一个元素插入到循环队列中。
3. 出队操作:从循环队列中删除一个元素,并返回该元素值。
4. 判断循环队列是否为空:如果循环对了为空,则返回 true;否则返回 false。
5. 判断循环对了是否已满:如果循环对了已满,则返回 true;否则返回 false。
四、实验步骤1. 队列的初始化首先需要定义一个结构体来表示循环队列,包括以下几个成员变量:```ctypedef struct {int *base; // 队列的基地址int front; // 队头指针int rear; // 队尾指针int size; // 队列长度} Queue;```然后定义一个初始化函数,用来初始化一个空的循环队列:```cvoid initQueue(Queue *queue, int size) {queue->base = (int *) malloc(sizeof(int) * size);queue->front = queue->rear = 0;queue->size = size;}```2. 入队操作入队操作比较简单,只需要将元素插入到队尾即可。
如果队列已满,则无法插入元素。
```cbool enQueue(Queue *queue, int value) {if (isFull(queue)) {return false;}queue->base[queue->rear] = value;queue->rear = (queue->rear + 1) % queue->size;return true;}```3. 出队操作出队操作也比较简单,只需要从队头删除一个元素,并返回该元素值。
(完整word版)队列实验报告
一.实验项目名称循环队列和链式队列的创建二、实验目的1、掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,2、队列顺序存储结构、链式存储结构和循环队列的实现,以便在实际问题背景下灵活应用。
三、实验内容1.链式队列的实现和运算2.循环队列的实现和运算四、主要仪器设备及耗材VC++6。
0运行环境实现其操作五.程序算法(1) 循环队列操作的算法1>进队列Void enqueue (seqqueue &q, elemtype x){if ((q.rear+1)%maxsize = = q.front)cout<<”overflow”;else {q.rear=(q。
rear+1)%maxsize;//编号加1或循环回第一个单元q.queue[q。
rear]=x;}}2>出队列Void dlqueue(seqqueue &q ){if (q。
rear= =q。
front) cout〈〈”underflow”;elseq.front =(q.front+1)%maxsize;}3>取对头元素elemtype gethead(seqqueue q ){ if (q.rear= =q。
front){cout<〈”underflow”;return NULL;}else return q.queue[(q.front+1)%maxsize];//front指向队头前一个位置}4〉判队列空否int empty(seqqueue q ){if (q。
rear= =q.front)reurn 1;else return 0;}(2)。
链队列操作的算法1>。
链队列上的初始化void INIQUEUE( linkqueue &s){ link *p;p=new link;p-〉next=NULL;//p是结构体指针类型,用—>s.front=p; //s是结构体变量,用。
循环队列基本操作的实现
break;
case 4: //输出队头元素
if(GetHead(Q,e))
cout<<"队头元素为:"<<e<<endl;
else
cout<<"当前队列为空队列,没有队头元素"<<endl;
break;
case 5: //输出队尾元素
if(GetTail(Q,e))
}
int main()
{
SqQueue Q; //定义循环队列Q
int k;
char e;
bool flag;
InitQueue(Q); //初始化循环队列Q
cout<<"循环队列Q初始化成功"<<endl;
//循环显示菜单,完成循环队列的一系列操作
do{
showmenu();
cout<<"请选择要执行的操作序号"<<endl;
bool DeQueue(SqQueue &Q,char &e)
{
if(Q.front==Q.rear)
return false;
e = Q.base[Q.front];
Q.front = (Q.front+1)%MAXSIZE;
return true;
}
//取循环队列Q的队头元素,用参数e返回取得的队头元素
bool GetHead(SqQueue Q,char &e)
{
if(Q.front!=Q.rear)
{
e=Q.base[Q.front];
实验八-队列(循环队列)的表示和实现-舞伴问题
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验八队列(循环队列)的表示和实现学生姓名*** 专业班级信管1104 学号3110****实验成绩指导老师(签名)日期一.实验目的和要求1、掌握队列的存储结构及基本操作。
2、掌握循环队列的设置及循环队列的各种基本操作的实现。
3、通过具体的应用实例,进一步熟悉和掌握队列的实际应用。
二.实验内容1、建立头文件SeqQueue.h,定义顺序存储的循环队列存储结构,并编写循环队列的各种基本操作实现函数。
同时建立一个验证操作实现的主函数文件test3_2.cpp,编译并调试程序,直到正确运行。
2、选做:编写程序,实现舞伴问题。
假设在周末舞会上,男士们和女士们进入舞厅时,各自排成一队,跳舞开始时,依次从男队和女队的队头上各出一人配成舞伴,若两队初始人数不相同,则较长的那一队中未配对者等待下一轮舞曲。
要求设计一个函数void partner(),模拟上述舞伴配对问题。
基本要求:1) 由键盘输入数据,每对数据包括姓名和性别;2) 输出结果包括配成舞伴的女士和男士的姓名,以及未配对者的队伍名称和队头者的姓名;3) 要求利用SeqQueue.h中已实现的顺序循环队列的基本操作函数来实现。
函数void partner() 添加到文件test3_2.cpp中,在主函数中进行调用测试。
3、填写实验报告,实验报告文件取名为report8.doc。
4、上传实验报告文件report8.doc、源程序文件test3_2.cpp及SeqQueue.h 到Ftp服务器上自己的文件夹下。
三. 函数的功能说明及算法思路(包括每个函数的功能说明,及一些重要函数的算法实现思路)1)InitQueue(Queue &q)实现初始化队列的功能2)EnQueue(Queue &q,ElemType item)向队列插入元素item3)OutQueue(Queue &q)队列头位元素出列,并返回该值4)PeekQueue(Queue &q)返回队头元素值5)EmptyQueue(Queue &q)判断队列Q是否为空,若空返回1,否则返回06)ClearQueue(Queue &q)清空队列7)partner()实现舞伴的配对操作。
实验三 循环队列基本操作
实验三循环队列基本操作一实验目的1.熟悉并能实现循环队列的定义和基本操作。
2.了解用队列解决实际应用问题。
二实验要求1.进行队列的基本操作时要注意队列“先进先出”的特性。
2.复习关于队列操作的基础知识。
3.编写完整程序完成下面的实验内容并上机运行。
4.整理并上交实验报告。
三实验内容1.任意输入队列长度和队列中的元素值,构造一个顺序循环队列,对其进行清空、插入新元素、返回队头元素以及删除队头元素操作。
#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define MAXQSIZE 100 //最大队列长度#define OK 1#define ERROR 0#define OVERFLOW -2typedef struct{int *base; //初始化的动态分配存储空间基址int front; //头指针,若队列不空,指向队列头元素int rear; //尾指针,若队列不空,指向队列尾元素的下一个位置}SqQueue;//-----------------循环队列的基本操作---------------------int InitQueue (SqQueue &Q){ //构造一个空队列QQ.base = (int *)malloc(MAXQSIZE * sizeof(int));if(!Q.base) exit (OVERFLOW);//存储分配失败Q.front = Q.rear = 0;return OK;}int QueueLength (SqQueue Q){//返回Q的元素个数,即队列长度return (Q.rear - Q.front + MAXQSIZE)% MAXQSIZE;}void display(SqQueue Q){//显示队列中的元素if(Q.front==Q.rear)printf("空队列,没有元素");for(int i=Q.front;i<Q.rear;i++)printf("%3d",Q.base[i]);printf("\n");}int EnQueue (SqQueue &Q, int 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;}int DeQueue (SqQueue &Q, int &e){//若队列不空,则删除Q的队头元素,用e返回其值,并返回Ok,否则,返回ERRORif(Q.front == Q.rear)return ERROR;e = Q.base[Q.front];Q.front = (Q.front+1) % MAXQSIZE;return OK;}int GetHead(SqQueue &Q){if(Q.front==Q.rear)return 0;elsereturn Q.base[Q.front];}void clear(SqQueue *q){q->rear = q->front = 0;}int main(){int m,n,e;SqQueue Q;InitQueue(Q);printf("请输入要插入的元素个数:\n");scanf("%d",&m);for(int i=1; i<=m; i++){printf("请输入要插入的元素:\n");scanf("%d",&n);EnQueue(Q,n);}printf("插入元素后,队列中的元素为:\n");display(Q);printf("队列的长度为:%d\n",QueueLength(Q));printf("队列的头元素为:%d\n",GetHead(Q));printf("\n删除队头元素后,队列中元素为:\n");DeQueue(Q,e);display(Q);printf("队列的长度为:%d\n",QueueLength(Q));printf("队列的头元素为:%d\n",GetHead(Q));printf("被删除元素为:\n");printf("%d\n",e);printf("现在开始清空\n");clear(&Q);display(Q);printf("\n");return 0;}2.约瑟夫环的实现:设有n个人围坐在圆桌周围,现从某个位置i 上的人开始报数,数到m 的人就站出来。
循环队列 实验报告
循环队列#include <iostream>using namespace std;const int QueueSize=10; template <class T>class CirQueue{private :T data[QueueSize];int front,rear;public:CirQueue();~CirQueue(){}T GetQueue();bool Empty();bool Full();int Length();void Insert(T x);T Delete();void Print();};template <class T>CirQueue<T>::CirQueue(){front=rear=0;}template <class T>T CirQueue<T>::GetQueue(){if(front==rear)throw"队列为空!";int i=(front+1)%QueueSize;return this->data[i];}template <class T>bool CirQueue<T>::Empty () {if(rear==front)return true;elsereturn false;}template <class T>bool CirQueue<T>::Full (){if((rear+1)%QueueSize==front)return true;elsereturn false;}template <class T>int CirQueue<T>::Length (){return (this->rear-this->front+QueueSize)%QueueSize; }template <class T>void CirQueue<T>::Insert(T x){if((rear+1)%QueueSize==front)throw "队列上溢!";rear=(rear+1)%QueueSize;data[rear]=x;}template <class T>T CirQueue<T>::Delete (){if(rear==front)throw"队列下溢!";front=(front+1)%QueueSize;return data[front];}template <class T>void CirQueue<T>::Print (){if(rear==front)cout<<"队列为空"<<endl;else{cout<<"***********************************"<<endl;int length=(rear-front+QueueSize)%QueueSize;int count=0;for(int i=(front+1)%QueueSize;;i=(i+1)%QueueSize){if(count>=length)break;cout<<"data["<<i<<"]="<<data[i]<<" ";count++;if(count%5==0)cout<<endl;}cout<<endl;}}void main(){cout<<"************循环队列实验************"<<endl;CirQueue <int>Cq;for(int i=1;i<=9;i++)Cq.Insert (i);Cq.Print();Cq.Delete();Cq.Delete();Cq.Delete();Cq.Insert(-1);Cq.Insert(-2);Cq.Insert(-3);Cq.Print();cout<<endl<<Cq.GetQueue()<<endl;cout<<endl<<Cq.Empty()<<endl;cout<<endl<<Cq.Full()<<endl;}。
循环队列设计实验报告
一、实验目的1. 理解循环队列的概念和原理。
2. 掌握循环队列的基本操作,包括初始化、入队、出队、判断队列满和空等。
3. 通过实验加深对队列数据结构在实际应用中的理解。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容循环队列是一种利用固定大小的数组实现队列的数据结构。
当队列满时,队列的最后一个元素之后的元素会覆盖队列的第一个元素,形成一个循环。
本实验主要实现以下功能:1. 初始化循环队列。
2. 入队操作(Enqueue)。
3. 出队操作(Dequeue)。
4. 判断队列满和空。
四、实验步骤1. 定义循环队列的结构体,包括队列的最大容量、队列的数组、头指针和尾指针。
```cppstruct LoopQueue {int maxSize; // 队列的最大容量int data; // 队列的数组int front; // 队列的头指针int rear; // 队列的尾指针};```2. 实现初始化函数,初始化队列的最大容量、头指针和尾指针。
```cppvoid initLoopQueue(LoopQueue &queue, int maxSize) {queue.maxSize = maxSize;queue.data = new int[maxSize];queue.front = 0;queue.rear = 0;}```3. 实现入队操作,当队列不满时,将元素添加到队列的尾指针位置,并更新尾指针。
```cppbool enqueue(LoopQueue &queue, int value) {if ((queue.rear + 1) % queue.maxSize == queue.front) {return false; // 队列满}queue.data[queue.rear] = value;queue.rear = (queue.rear + 1) % queue.maxSize;return true;}```4. 实现出队操作,当队列不为空时,返回队列的头指针位置的元素,并更新头指针。
循环队列实 验 报 告
数学与计算科学学院实验报告
实验项目名称
所属课程名称
实验类型
实验日期
班级
学号
姓名
成绩
附录1:源程序
附录2:实验报告填写说明
1.实验项目名称:要求与实验教学大纲一致。
2.实验目的:目的要明确,要抓住重点,符合实验教学大纲要求。
3.实验原理:简要说明本实验项目所涉及的理论知识。
4.实验环境:实验用的软、硬件环境。
5.实验方案(思路、步骤和方法等):这是实验报告极其重要的内容。
概括整个实验过程。
对于验证性实验,要写明依据何种原理、操作方法进行实验,要写明需要经过哪几个步骤来实现其操作。
对于设计性和综合性实验,在上述内容基础上还应该画出流程图、设计思路和设计方法,再配以相应的文字说明。
对于创新性实验,还应注明其创新点、特色。
6.实验过程(实验中涉及的记录、数据、分析):写明具体实验方案的具体实施步骤,包括实验过程中的记录、数据和相应的分析。
7.实验结论(结果):根据实验过程中得到的结果,做出结论。
8.实验小结:本次实验心得体会、思考和建议。
9.指导教师评语及成绩:指导教师依据学生的实际报告内容,给出本次实验报告的评价。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
int front;
int rear;
}CirQueue;
循环队列的初始化:
Status InitQueue(CirQueue &Q)
{Q.Elem=(ElemType *)malloc(MAX*sizeof(ElemType));
if(!Q.Elem)return(OVERFLOW);
教师签字
日期
}
void QueueOutput(CirQueue Q)
{for(int i=Q.front;i!=Q.rear;i=(i+1)%MAX)
printf("%5d",Q.Elem[i]);
printf("\n");}
main()
{CirQueue Q;
ElemType e;
int i,n,j,k;
InitQueue(Q);
Q.rear=(Q.rear+1)%MAX;
return OK;
}
Status DeQueue(CirQueue &Q,ElemType &e)
{ if(Q.rear==Q.front)return ERROR;
e=Q.Elem[Q.front];
Q.front=(Q.front+1)%MAX;
return OK;
判断队满条件:(rear+1) % maxSize == front
3.算法描述(可附页)
#include "stdio.h"
#include "malloc.h"
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0
Q.front=(Q.front+1)% MAX_QUEUE_SIZE ;
return OK ;
}
队头指针进1: front = (front+1) % maxSize;
队尾指针进1: rear = (rear+1) % maxSize;
队列初始化:front = rear = 0;
队空条件:front == rear;
scanf("%d",&j);
while(i<=j)
{printf("元素个数不够,重新输入出队个数\n");
scanf("%d",&j);}
for(i=1;i<=j;i++)
DeQueue(Q, e);
printf("出队后为:");
QueueOutput(Q);}
4.实验调试结果
实验小结
实验成绩
typedef int Status;
#define MAX 10
typedef int ElemType;
typedef struct
{ElemType *Elem;
int front;
int rear;
}CirQueue;
Status InitQueue(CirQueue &Q)
{Q.Elem=(ElemType *)malloc(MAX*sizeof(ElemType));
if(!Q.Elem)
return(OVERFLOW);
Q.front=Q.rear=0;
return OK;
}
Status EnQueue(CirQueue &Q,ElemType &e)
{if( (Q.rear+1)%MAX==Q.front )return ERROR;
Q.Elem[Q.rear] = e;
实验报告(二)
姓名
学号
班级
实验名称
循环队列的基本操作
实验日期
机房
实验报告
1.说明自己在实验操作过程中遇到的难点及解决方法
难点:
1.循环队列的初始化,入队,出队的操作。
解决方法:
1.根据书上以及ppt上的知识点,结合实际
2.说明实验中所涉及的知识点
队列存储结构的结构体定义:
typedef struct
Q.front=Q.rear=0;
return Oatus Insert_CirQueue(SqQueue Q , ElemType e)
{if((Q.rear+1)%MAX_QUEUE_SIZE== Q.front)
return ERROR;
Q.Queue_array[Q.rear]=e ;
Q.rear=(Q.rear+1)% MAX_QUEUE_SIZE ;
return OK; }
循环队列的出队操作:
Status Delete_CirQueue(SqQueue Q, ElemType *x )
{if (Q.front+1== Q.rear)
return ERROR ;
*x=Q.Queue_array[Q.front];
printf("请输入要入队的队列元素个数:");
scanf("%d",&n);
printf("请输入元素:");
for(i=1;i<=n;i++)
{ scanf("%d",&k);
EnQueue(Q,k);}
printf("原队列为:");
QueueOutput(Q);
printf("请输入要出队的队列元素个数:\n");