循环队列实验报告
循环队列操作实验报告
实验目的：通过本次实验，掌握循环队列的基本概念和操作方法，了解其在实际应用中的优势，并能够熟练运用循环队列解决实际问题。
实验环境：操作系统：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.对单链表不够熟悉,要多练习创建单链表及其基本操作。