循环队列实验报告
循环队列操作实验报告
实验目的：通过本次实验，掌握循环队列的基本概念和操作方法，了解其在实际应用中的优势，并能够熟练运用循环队列解决实际问题。
实验环境：操作系统：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、掌握队列的链接存储结构及实现及操作二. 实验内容1、建立一个空顺序存储结构队列；对已建立的队列进行插入、删除、取队头元素等基本操作。
2、建立一个空链式存储结构队列；对已建立的队列进行插入、删除、取队头元素等基本操作。
三、详细设计：1、顺序队列的实现：#include<iostream>using namespace std;const int Size=100;typedef char DataType;class CirQueue{public:CirQueue(){front=rear=0;//构造队列，初始化一个空的循环队列，front和rear指向}~CirQueue(){}void EnQueue(DataType x){if((rear+1)%Size==front){cout<<"队列已经满了"<<endl;return;}rear=(rear+1)%Size;//队尾指针在循环的意义下加data[rear]=x;cout<<x<<"已入队"<<endl;return;}DataType GetQueue()//取队头{if(isEmpty()){cout<<"队列为空"<<endl;return 0;}int i;i=(front+1)%Size;return data[i];}DataType DeQueue(){if(isEmpty()){cout<<"队列为空"<<endl;return 0;}front=(front+1)%Size;//队头指针在循环的意义下加return data[front];}int isEmpty()//是否为空{if(front==rear){return 1;}else{return 0;}}private:DataType data[Size];int front,rear;};int main(){CirQueue a;int index;DataType temp;do{cout<<"**********************************"<<endl;cout<<"1、入队操作"<<endl;cout<<"2、取队头操作"<<endl;cout<<"3、出队操作"<<endl;cout<<"4、判断队列是否为空"<<endl;cout<<"5、退出"<<endl;cout<<"**********************************"<<endl;cin>>index;if(index==5){return 0;}switch(index){case 1:cout<<"请输入要入队的元素"<<endl;cin>>temp;a.EnQueue(temp);break;case 2:temp=a.GetQueue();if(temp!=0){cout<<"队头的元素为"<<temp<<" "<<endl;}break;case 3:temp=a.DeQueue();if(temp!=0){cout<<"出队的元素为"<<temp<<" "<<endl;}break;case 4:bool temp;temp=a.isEmpty();if(temp){cout<<"空队"<<endl;}else{cout<<"非空队"<<endl;}break;}}while(index);return 0;}2、链队列的实现：#include<iostream>using namespace std;const int Size=100;typedef char DataType;struct Node{DataType data;Node *next;};class LinkQueue{public:LinkQueue(){auto head=new Node;head->next=NULL;front=rear=head;}~LinkQueue(){}void EnQueue(DataType x){auto s=new Node;s->data=x;s->next=NULL;//申Θ?请?一?个?数簓据Y域 ?为aX的?结á点?srear->next=s;rear=s;}DataType GetQueue()//取?队ó头 ?{if(isEmpty()){cout<<"队ó列 为a空?"<<endl;return 0;}return front->next->data;}DataType DeQueue(){if(isEmpty()){cout<<"队ó列 为a空?"<<endl;return 0;}auto p=new Node;//用?于 ?暂Y存?队ó头 ?元a素?DataType x;//用?于 ?暂Y存?队ó头 ?数簓据Yp=front->next;x=p->data;front->next=p->next;if (p->next==NULL){rear=front;}delete p;return x;}int isEmpty()//是?否?为a空?{if(front==rear){return 1;}else{return 0;}}private:Node*front,*rear;//队ó头 ?和í队ó尾2指?针?};int main(){LinkQueue a;int index;DataType temp;do{cout<<"**********************************"<<endl;cout<<"1、￠入?队ó操ù作痢?<<endl;cout<<"2、￠取?队ó头 ?操ù作痢?<<endl;cout<<"3、￠出?队ó操ù作痢?<<endl;cout<<"4、￠判D断?队ó列 是?否?为a空?"<<endl;cout<<"5、￠退?出?"<<endl;cout<<"**********************************"<<endl;cin>>index;if(index==5){return 0;}switch(index){case 1:cout<<"请?输?入?要癮入?队ó的?元a素?"<<endl;cin>>temp;a.EnQueue(temp);break;case 2:temp=a.GetQueue();if(temp!=0){cout<<"队ó头 ?的?元a素?为a"<<temp<<" "<<endl;}break;case 3:temp=a.DeQueue();if(temp!=0){cout<<"出?队ó的?元a素?为a"<<temp<<" "<<endl;}break;case 4:bool temp;temp=a.isEmpty();if(temp){cout<<"空?队ó"<<endl;}else{cout<<"非?空?队ó"<<endl;}break;}}while(index);return 0;}四、调试分析：1、顺序队列：主界面入队操作取队头操作出队操作判空操作。
队列实验报告
队列实验报告⼀.实验项⽬名称循环队列与链式队列的创建⼆、实验⽬的1、掌握队列的特点(先进先出FIFO)及基本操作,如⼊队、出队等,2、队列顺序存储结构、链式存储结构与循环队列的实现,以便在实际问题背景下灵活应⽤。
三、实验内容1.链式队列的实现与运算2.循环队列的实现与运算四、主要仪器设备及耗材VC++6、0运⾏环境实现其操作五.程序算法(1) 循环队列操作的算法1>进队列V oid 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>出队列V oid dlqueue(seqqueue &q ){if (q、rear= =q、front) cout<<”underflow”;elseq、front =(q、front+1)%maxsize;}3>取对头元素elemtype gethead(seqqueue q )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就是结构体变量,⽤、s、rear=p; //头尾指针都指向头结点}2>、⼊队列void push(linkqueue &s, elemtype x){link *p; //p就是结构体指针类型,⽤->p=new link;p->data=x;p->next=s、rear->next; //s就是结构体变量,⽤、s、rear->next=p; s、rear=p; //插⼊最后}3>判队空int empty( linkqueue s ){ if (s、front= =s、rear) return 1;else return 0;}4>、取队头元素{if (s、front= =s、rear) return NULL;else retuen s、front->next->data;}5>、出队列void pop(linkqueue &s){ link *p;p=s、front->next;if (p->next= =NULL)//链队列中只有⼀个元素,需要修改rear指针{ s、front->next=NULL; s、rear=s、front;}elses、front->next =p->next;//rear不⽤变delete (p);}六、程序源代码a.循环队列源代码#include#define MAXN 20struct seq{char queue[MAXN];int front , rear;};void iniq(seq &q){q、front=q、rear=MAXN-1;}void enq(seq &q,char x){if((q、rear+1)%MAXN==q、front)cout<<"overflow";else {q、rear=(q、rear+1)%MAXN;q、queue[q、rear]=x;}void dlq(seq &q){if (q、rear == q、front)cout<<"underflow";elseq、front=(q、front+1)%MAXN;}int gethead(seq &q) //取队头元素{if (q、rear == q、front) //判断就是否队列为空cout<<"underflow"; elsereturn q、queue[(q、front+1)%MAXN];}main(){seq q;int i,y;iniq(q);cout<<"输⼊元素⼊队0为⽌"<cin>>i;while(i){enq( q,i);cin>>i;}y=gethead( q);cout<<"队头为="<dlq( q);y=gethead( q);cout<<"执⾏⼀次删除队头后,队头为="<}b.链队列的源代码#includetypedef struct QNodeQNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;InitQueue(LinkQueue &Q){Q、front=Q、rear=new QNode; Q、front->next=NULL;return 0;}EnQueue(LinkQueue &Q,char e){QueuePtr p;p=new QNode;p->data=e;p->next=NULL;Q、rear->next=p;Q、rear=p;return 0;}void disp(LinkQueue &Q) //打印队列{QueuePtr p;p=Q、front->next;while(p!=NULL){cout<data<<"->";p=p->next;}}{QueuePtr p;if(Q、front==Q、rear)return 1;p=Q、front->next;e=p->data;Q、front->next=p->next;if(Q、rear==p)Q、rear=Q、front;delete p;return 0;}void main(){LinkQueue Q;char e,e1;InitQueue(Q);cout<<"输⼊队列元素,0时结束:"< cin>>e;while(e!='0'){EnQueue(Q,e);cin>>e;}cout<<"队列为:"<disp(Q);DeQueue(Q,e1);cout<cout<<"队列为:"<disp(Q);cout<}六、程序输⼊数据及实验结果a、循环队列实验结果c.链队列实验结果七、思考讨论题或体会或对改进实验的建议(1)体会a.C++语⾔知识不懂,需要好好学习;b.对单链表不够熟悉,要多练习创建单链表及其基本操作。
循环队列基本操作的实现
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. 掌握C语言中循环结构的实现方法。
3. 通过实际编程，加深对循环顺序结构的理解和应用。
二、实验环境1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 编程语言：C语言三、实验内容本次实验主要涉及C语言中的循环顺序结构，包括for循环、while循环和do-while循环。
1. for循环（1）实验目的：理解for循环的语法结构，掌握for循环的使用方法。
（2）实验步骤：① 创建一个名为“for循环实验.c”的C语言源文件。
② 编写以下代码：```c#include <stdio.h>int main() {int i;for(i = 1; i <= 10; i++) {printf("i的值为：%d\n", i);}return 0;}```③ 编译并运行程序，观察输出结果。
（3）实验结果：程序输出1到10的整数。
2. while循环（1）实验目的：理解while循环的语法结构，掌握while循环的使用方法。
（2）实验步骤：① 创建一个名为“while循环实验.c”的C语言源文件。
② 编写以下代码：```c#include <stdio.h>int main() {int i = 1;while(i <= 10) {printf("i的值为：%d\n", i);i++;}return 0;}```③ 编译并运行程序，观察输出结果。
（3）实验结果：程序输出1到10的整数。
3. do-while循环（1）实验目的：理解do-while循环的语法结构，掌握do-while循环的使用方法。
（2）实验步骤：① 创建一个名为“do-while循环实验.c”的C语言源文件。
② 编写以下代码：```c#include <stdio.h>int main() {int i = 1;do {printf("i的值为：%d\n", i);i++;} while(i <= 10);return 0;}```③ 编译并运行程序，观察输出结果。
实验08 队列(循环队列)的表示和实现
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验八队列（循环队列）的表示和实现学生姓名专业班级学号实验成绩指导老师（签名）日期一.实验目的和要求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服务器上自己的文件夹下。
三.函数的功能说明及算法思路struct Queue{ElemType *queue;int front,rear,len;int MaxSize;};/*初始化队列*/void InitQueue(Queue &Q)/*向队列插入元素，若队列已满需要重新分配更大的存储空间*/ void EnQueue(Queue &Q,ElemType item)/*从队列中删除元素并返回*/ElemType OutQueue(Queue &Q)/*读取队首元素，不改变队列形态*/ElemType PeekQueue(Queue &Q)/*检查一个队列是否为空，若是则返回true，否则返回false*/ bool EmptyQueue(Queue &Q)/*清除一个队列为空，并释放动态存储空间*/void ClearQueue(Queue &Q)/*舞伴配对*/void partner();四. 实验结果与分析五. 心得体会【附录----源程序】test3_2.cpp#include<iostream.h>#include<stdlib.h>typedef char ElemType;#include"SeqQueue.h"void partner(Queue F,Queue M);struct Dancer{char name;char sex;};void main(){Queue F,M;InitQueue(F);InitQueue(M);partner(F,M);ClearQueue(F);ClearQueue(M);}void partner(Queue F,Queue M){Dancer D;cout<<"请输入跳舞者的姓名和性别:"<<endl;cin>>>>D.sex;while(!='#'&&D.sex!='#'){if(D.sex=='F'||D.sex=='f')EnQueue(F,);else if(D.sex=='M'||D.sex=='m')EnQueue(M,);cin>>>>D.sex;}cout<<"配对的舞伴是:"<<endl;while(!EmptyQueue(F)&&!EmptyQueue(M))cout<<OutQueue(F)<<' '<<OutQueue(M)<<endl;if(!EmptyQueue(F)){cout<<"女队还有人等待下一轮舞曲。
循环队列
南京信息工程大学循环队列实验(实习)报告实验(实习)名称循环队列实验(实习)日期得分指导老师系理学系专业实验班班级 2 姓名孙浩宇学号201423210371、需求分析要求：编写一个头文件SqQueue.h，实现顺序循环队列的各种运算，并在此基础上设计一个主程序完成如下功能：（1）初始化队列q（1）判断队列q是否非空（2）依次进队列元素a,b,c（3）出队一个元素，输出该元素（4）输出队列q的元素个数（5）依次进队列元素d,e,f（6）输出队列q的元素个数（7）输出出队序列（8）释放队列2、设计#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define NULL 0typedef int Status;typedef char QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;Status InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,QElemType e){QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);p->data=e; p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}Status OutQueue(LinkQueue &Q){QueuePtr p;if(Q.front==Q.rear) return ERROR; //空队列，返回error p=Q.front->next; //p指向队首元素Q.front->next =p->next;printf("%c\n",p->data);if(Q.rear == p) Q.rear =Q.front ; //如果p是最后一个元素free (p);return OK;}Status DestroyQueue(LinkQueue &Q){while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}int QueueLength(LinkQueue &Q){QueuePtr p;int i=0;for(p=Q.front->next ;p!=NULL;p=p->next)i++;return i;}Status QueueTraverse(LinkQueue &Q){QueuePtr p;for(p=Q.front->next ;p!=NULL;p=p->next){printf("%c",p->data);}return OK;}/*文件名:exp3-2.cpp*/#include<stdio.h>#include"SqQueue.h"void main(){LinkQueue Q;printf("(1)初始化队列q\n");InitQueue(Q);printf("队列长度：%d\n",QueueLength(Q));printf("(2)依次进入对列a,b,c元素\n");EnQueue(Q,'a');EnQueue(Q,'b');EnQueue(Q,'c');printf("(3)队列Q元素个数=%d\n",QueueLength(Q));printf("(4)出队：");OutQueue(Q);printf("(5)队列Q元素个数=%d\n",QueueLength(Q));printf("(6)依次进入对列d,e,f元素\n");EnQueue(Q,'d');EnQueue(Q,'e');EnQueue(Q,'f');printf("(7)队列Q元素个数=%d\n",QueueLength(Q));printf("(8)输出队列");QueueTraverse(Q);printf("(9)释放对列\n");DestroyQueue(Q);}3、调试分析还是对指针运用不熟悉，经常在指针的指向问题上出错，导致程序不能运行，出现error。
数据结构实验三(循环队列基本操作)题目和源程序
实验三:循环队列基本操作一、实验目的1．熟悉并能实现循环队列的定义和基本操作。
2．了解用队列解决实际应用问题。
二、实验要求1．进行队列的基本操作时要注意队列“先进先出”的特性。
2．复习关于队列操作的基础知识。
3．编写完整程序完成下面的实验内容并上机运行。
4．整理并上交实验报告。
三、实验内容1．任意输入队列长度和队列中的元素值，构造一个顺序循环队列，对其进行清空、插入新元素、返回队头元素以及删除队头元素操作。
2．约瑟夫环的实现：设有n个人围坐在圆桌周围，现从某个位置i 上的人开始报数，数到m 的人就站出来。
下一个人，即原来的第m+1个位置上的人，又从1开始报数，再是数到m的人站出来。
依次重复下去，直到全部的人都站出来，按出列的先后又可得到一个新的序列。
由于该问题是由古罗马著名的史学家Josephus提出的问题演变而来，所以通常称为Josephus 问题。
例如：当n=8,m=4,i=1时，得到的新序列为：4，8，5，2，1，3，7，6编写程序选择循环队列作为存储结构模拟整个过程，并依次输出出列的各人的编号。
/*----------------------------------------* 03_循环队列.cpp -- 循环队列基本操作* 对循环队列的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds03.cpp : 定义控制台应用程序的入口点。
//#include "stdafx.h"#include<iostream>#include<cstdlib>#include<iomanip>#include<ctime>#define MAXQSIZE 100 //最大队列长度using namespace std;typedef struct {int *base; //初始化的动态分配存储空间int front; //头指针，若队列不空，指向队列头元素int rear; //尾指针，若队列不空，指向队列尾元素的下一个位置}SqQueue;//构造一个空队列void InitQueue(SqQueue &Q){Q.base = (int *)malloc(MAXQSIZE * sizeof(int));if(!Q.base) cout << "存储分配失败。
队列,表达式实验报告
学号：2009142202 班级：20091422 姓名：徐继晨课题名称：队列，表达式1循环队列●循环队列的C语言描述●基本运算的算法——置空队、判队空、进队、出队、读队头元素、输出循环队列2链队列●链队列的C语言描述●基本运算的算法——置空队、判队空、进队、出队、读队头元素循环队列源代码：#include<iostream>using namespace std;#include<malloc.h>#include<stdlib.h>#define MAXSIZE 100#define TRUE 1#define FALSE 0typedef int DataType;typedef struct{DataType data[MAXSIZE]; int front;int rear;}SeqQueue;void InitQueue(SeqQueue *Q) {Q->front=Q->rear=0;}void IsEmpty_full(SeqQueue *Q){if(Q->front==Q->rear)cout<<"该队列为空"<<endl;else if((Q->rear+1)%MAXSIZE==Q->front) cout<<"该队列为满"<<endl;elsecout<<"该队列既不为空也不为满"<<endl; }int EnterQueue(SeqQueue *Q,DataType x){if((Q->rear+1)%MAXSIZE==Q->front) return(FALSE);Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%MAXSIZE;return(TRUE);}int DeleteQueue(SeqQueue *Q,DataType *x) {if(Q->front==Q->rear)return(FALSE);*x=Q->data[Q->front];Q->front=(Q->front+1)%MAXSIZE;return(TRUE);}void ClearQueue_Sq(SeqQueue &Q) {Q.front=Q.rear=0;}void CreateQueue_Sq(SeqQueue &Q){DataType temp;cout<<"输入数据元素（按-1结束）"<<endl;cin>>temp;while(temp!=-1){if((Q.rear+1)%MAXSIZE == Q.front) cout<<"队列已经满了";else{Q.data[Q.rear]=temp;Q.rear=(Q.rear+1)%MAXSIZE;cin>>temp;}}}int QueueLength_Sq(SeqQueue Q){return (Q.rear-Q.front+MAXSIZE) % MAXSIZE; }void OutputQueue_Sq(SeqQueue Q){if(Q.front==Q.rear) cout<<"空队列，没有元素"<<endl;else{cout<<"该循环队列各元素依次为：";for(int k=0; k<=QueueLength_Sq(Q)-1; k++)cout<<Q.data[(Q.front+k)%MAXSIZE]<<" ";cout<<endl;}int main(){int flag=1,select;cout<<" 循环队列的基本操作"<<endl;cout<<" 1.请输入循环队列元素："<<endl;cout<<" 2.判断队列是否为空或是否为满"<<endl;cout<<" 3.当前队头元素出队并将其输出循环队列的各元素"<<endl;cout<<" 4.将x入队并输出循环队列的各元素"<<endl;cout<<" 5.当前循环队列的长度"<<endl;cout<<" 6.清空队列"<<endl;cout<<" 7.退出"<<endl;while(flag){cout<<"请选择: ";cin>>select;SeqQueue Q;int x,a,e;switch(select){case 1:InitQueue(&Q);CreateQueue_Sq(Q);OutputQueue_Sq(Q);break;cout<<"请选择: "; case 2:IsEmpty_full(&Q);break;cout<<"请选择: "; case 3:DeleteQueue(&Q,&a);OutputQueue_Sq(Q);break;cout<<"请选择: ";case 4:cout<<"请输入入队的元素x：";cin>>x;EnterQueue(&Q,x);OutputQueue_Sq(Q);break;cout<<"请选择: ";case 5:cout<<"当前循环队列的长度是："<<(Q.rear-Q.front+MAXSIZE) % MAXSIZE<<endl;break;cout<<"请选择: ";case 6:ClearQueue_Sq(Q);cout<<"该循环队列已清空, ";break;case 7:flag=0;break;}}}链队列源代码：#include <stdlib.h>#include<iostream> using namespace std;#define TRUE 1#define FALSE 0typedef int QElemType; typedef struct LNode{QElemType data;struct LNode *next;}LNode , *LinkList; typedef LinkList QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;void InitQueue_L(LinkQueue &Q) {//初始化队列Q.front=Q.rear=new LNode; Q.front->next=NULL;}int IsEmpty(LinkQueue *Q) {if(Q->front==Q->rear){return(TRUE);}else{return(FALSE);}//队列是否为空或为满void queueexist(LinkQueue *Q){if(Q->front==Q->rear)cout<<"该队列为空"<<endl;else if(Q->rear->next!=NULL)cout<<"该队列为满"<<endl;elsecout<<"该队列既不为空也不为满"<<endl; }//构造队列，数据元素由键盘输入void CreateQueue_L(LinkQueue &Q){QElemType temp;LNode *p;cout<<"输入要插入的队列值（输入-1结束）"<<endl;cin>>temp;while(temp != -1){p=new LNode;p->data=temp;Q.rear->next=p;p->next=NULL;Q.rear=p;cin>>temp;}}//入队操作int EnterQueue(LinkQueue *Q,QElemType x) {//将数据元素x插入到队列Q中LNode *NewNode=new LNode;if(NewNode!=NULL){NewNode->data=x;NewNode->next=NULL;Q->rear->next=NewNode;Q->rear=NewNode;return(TRUE);}else return(FALSE); //溢出}//出队操作int DeleteQueue(LinkQueue *Q,QElemType *x){//将队列Q的队头元素出队，并存放到x所指的存储空间中LNode *p;if(Q->front==Q->rear)return(FALSE);p=Q->front->next;Q->front->next=p->next; //队头元素p出队if(Q->rear==p) //如果队中只有一个元素p，则p出队后成为空队Q->rear=Q->front;*x=p->data;free(p); //释放存储空间return(TRUE);}//队列长度void QueueLength_L(LinkQueue Q) {int length=0;if(IsEmpty(&Q));else{LNode *p=new LNode;p=Q.front->next;while(p){length++;p=p->next;}}cout<<"该链队列的长度为："<<length<<endl; }//由头到尾依次输出队列的数据元素void OutputQueue_L(LinkQueue Q){LNode *p=new LNode;if(Q.front==Q.rear) cout<<"空对列"<<endl;else{p=Q.front->next;cout<<"队列的元素依次为：";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;}}//销毁队列void DestroyQueue_L(LinkQueue &Q) {while(Q.front){Q.rear=Q.front->next;delete Q.front;Q.front=Q.rear;}}{int flag=1,select;cout<<" 链队的基本操作"<<endl;cout<<" 1.请输入链队列元素："<<endl;cout<<" 2.判断链队列是否为空或为满"<<endl;cout<<" 3.当前队头元素出队并将其输出链队列各元素"<<endl;cout<<" 4.将x入队并输出链队列各元素"<<endl;cout<<" 5.当前链队列的长度"<<endl;cout<<" 6.销毁队列"<<endl;cout<<" 7.退出"<<endl;{cout<<"请选择：";cin>>select;LinkQueue Q;int x;switch(select){case 1:InitQueue_L(Q);CreateQueue_L(Q);OutputQueue_L(Q);break;cout<<"请选择："; case 2:queueexist(&Q);break;cout<<"请选择："; case 3:DeleteQueue(&Q,&x);OutputQueue_L(Q);break;cout<<"请选择："; case 4:cout<<"输入要入队的元素x：";cin>>x;EnterQueue(&Q,x);OutputQueue_L(Q);break;cout<<"请选择：";case 5:QueueLength_L(Q);break;cout<<"请选择：";case 6:DestroyQueue_L(Q);cout<<"销毁成功!可以再重新建立"<<endl;break;case 7:flag=0;break;}}}（1）表达式求值问题①问题描述表达式是数据运算的基本形式。
循环队列 实验报告
循环队列#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．指导教师评语及成绩：指导教师依据学生的实际报告内容，给出本次实验报告的评价。