顺序循环队列表实现

合集下载

循环队列操作实验报告

循环队列操作实验报告

实验目的:通过本次实验,掌握循环队列的基本概念和操作方法,了解其在实际应用中的优势,并能够熟练运用循环队列解决实际问题。

实验环境:操作系统: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("队列为空,无法遍历。

顺序循环队列实验报告

顺序循环队列实验报告

一、实验目的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()```实验结果分析:通过测试代码,我们可以看到顺序循环队列在初始化、入队和出队操作时都能正确执行。

队列:顺序队列和循环队列

队列:顺序队列和循环队列

队列:顺序队列和循环队列和栈的先进后出不同,队列的形式是先进先出,队列的想法来⾃于⽣活中排队的策略,顾客在付款结账的时候,按照到来的先后顺序排队结账。

先来的顾客先结账,后来的顾客后结账。

队列有两种实现形式:1 顺序表实现 2 循环顺序表 ⾸先来看下顺序表的实现,在python中,队列的实现⽤list来写⼗分的⽅便。

实现⽅式如下:class line_queue():def __init__(self):self._elem=[]def push(self,elem):self._elem.append(elem)def pop(self):elem=self._elem.pop(0)return elemdef queue_length(self):return len(self._elem)和栈唯⼀的区别是,这⾥pop是pop(0),也就是⾸先进队列的数据出列。

这个实现很简单,但是有⼀个问题,每次有元素出队列的时候,元素都必须要进⾏前移。

这就带来了⼀个问题,它的操作复杂度为O(n),⽽不是O(1)。

只有从尾部弹出元素也就是先进后出的时候复杂度为O(1).那么如何才能满⾜O(1)的出列复杂度呢。

我们可以考虑记住队头和队尾的位置。

每次出队的时候直接将队头位置的元素弹出就可以了。

具体的实现可以参考下图下⾯来看下代码的实现:class line_queue_update():def __init__(self):self._elem=[]self.head=self.rear=0def push(self,elem):self._elem.append(elem)self.rear+=1def pop(self):elem=self._elem[self.head]self.head+=1return elemdef queue_length(self):return len(self._elem)def get_elem(self):print self._elemif __name__=="__main__":q=line_queue_update()for i in range(10):q.push(i)print 'The length is %d' % q.queue_length()q.pop()q.pop()q.push(90)q.push(100)q.push(200)print 'The length is %d' % q.queue_length()运⾏结果如下:/usr/bin/python2.7 /home/zhf/py_prj/data_struct/chapter5.pyThe length is 10The length is 13这个⽅法的实现出队列的复杂度就是O(1)。

队列的顺序表示形式和实现

队列的顺序表示形式和实现

队列的顺序表⽰形式和实现队列的顺序表⽰是⽤⼀组地址连续的存储单元依次存放队列中的各个元素,并⽤指针front指向队头,指针rear指向队尾。

⼀般约定:front指针始终指向队头元素,⽽rear指针是指向队尾元素的下⼀个位置。

假溢出:当队满的时候,若还有元素进队,rear指针将会越界,从⽽导致程序出错。

⽽此时⼜不易像顺序表那样扩⼤数组空间,因为队列的实际可⽤空间并未装满。

处理假溢出:⼀种⽅法是将front指针和rear指针⼀起平移到数组的起始位置;另⼀种⽅法就是将队列假想为⼀个循环的环状空间,称之为循环队列。

循环队列的局限性:⽤户必须为它假设⼀个最⼤长度,若队列最⼤长度⽆法估计,则不宜采⽤循环队列结构。

循环队列的类型定义及基本操作:typedef struct{QElemType *base;int front, rear;}SqQueue;初始化循环队列int InitQueue(SqQueue &Q){Q.base = (QElemType*)malloc(MaxQSize*sizeof(QElemType));if (Q.base == NULL)exit(OVERFLOW);Q.front = Q.rear = 0;return 0;}将循环队列清空int ClearQueue(SqQueue &Q){Q.front = Q.rear = 0;}求队列元素的个数int QueueLength(SqQueue Q){return (Q.rear - Q.front + MaxQSize) % MaxQSize;}插⼊元素到循环队列int EnSqQueue(SqQueue &Q, QElemType e){if ((Q.rear + 1) % MaxQSize == Q.front)return ERROR; //队列满Q.base[Q.rear] = e; //元素e⼊队Q.rear = (Q.rear + 1) % MaxQSize; //修改队尾指针return OK;}从循环队列中删除元素int DeSqueue(SqQueue &Q, QElemType &e){if (Q.front == Q.rear)return ERROR;e = Q.base[Q.front]; //取队头元素⾄eQ.front = (Q.front + 1) % MaxQSize; //修改队头指针 return OK;}判断⼀个循环队列是否为空队列int SqQueue(SqQueue Q){if (Q.front == Q.rear)return TRUE;elsereturn FALSE;}//循环队列的简单操作#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define MaxQSize 10typedef struct{int *base; //数据存储区起始地址int front, rear; //队头、队尾元素所在单元号}SqQueue;int InitQueue(SqQueue &Q);int ClearQueue(SqQueue &Q);int QueueLength(SqQueue Q);int EnSqQueue(SqQueue &Q, int e);int DeSqQueue(SqQueue &Q, int &e);int SqQueueEmpty(SqQueue Q);int main(void){int i, e;SqQueue Q;InitQueue(Q);for (i=0; i<MaxQSize; i++) //只有MaxQSize-1个数据进队列EnSqQueue(Q, i);i = QueueLength(Q);printf("队列⾥的元素有%d个\n", i);for (i=0; i<3; i++){DeSqQueue(Q, e);printf("%d ", e);}printf("\n");i = QueueLength(Q);printf("队列⾥的元素有%d个\n", i);for (i=10; i<12; i++)EnSqQueue(Q, i);i = QueueLength(Q);printf("队列⾥的元素有%d个\n", i);ClearQueue(Q);i = QueueLength(Q);printf("队列⾥的元素有%d个\n", i);return 0;}int InitQueue(SqQueue &Q){Q.base = (int *)malloc(MaxQSize*sizeof(int));if (Q.base == NULL)exit(1);Q.front = Q.rear = 0;return 0;}int ClearQueue(SqQueue &Q){Q.front = Q.rear =0;return 0;}int QueueLength(SqQueue Q){return (Q.rear - Q.front +MaxQSize) % MaxQSize; }int EnSqQueue(SqQueue &Q, int e){if ((Q.rear+1)%MaxQSize == Q.front)return 1;Q.base[Q.rear] = e;Q.rear = (Q.rear + 1) % MaxQSize;return 0;}int DeSqQueue(SqQueue &Q, int &e){if (SqQueueEmpty(Q))return 1;e = Q.base[Q.front];Q.front = (Q.front + 1) % MaxQSize;return 0;}int SqQueueEmpty(SqQueue Q){if (Q.rear == Q.front)return 1;return 0;}。

队列研究的基本原理

队列研究的基本原理

队列研究的基本原理队列是一种非常重要的数据结构,其基本原理是“先进先出”,即先加入队列的元素先被取出。

队列在计算机科学中被广泛应用,例如操作系统中的进程调度、网络数据包传输等等。

本文将介绍队列的基本原理、应用场景以及常见的队列实现方式。

一、队列的基本原理队列是一种线性数据结构,可以看成是特殊的线性表。

队列的基本操作包括入队和出队。

入队是在队列的尾部添加一个元素,出队是从队列的头部删除一个元素。

由于队列是先进先出的,因此每次出队操作总是删除队列中最早被加入的元素。

队列的头部和尾部分别称为队头和队尾,队头是队列中最早加入的元素,队尾是队列中最后加入的元素。

队列的实现有多种方式,最常见的是使用数组或链表来实现。

使用数组实现队列时,需要定义一个数组来存储队列中的元素,同时使用两个指针front和rear分别指向队列的头部和尾部。

入队操作时,将元素添加到rear指向的位置,同时将rear指针向后移动一位;出队操作时,将front指针向后移动一位,同时删除队头元素。

当front等于rear时,队列为空。

使用链表实现队列时,每个节点包含一个元素和一个指向下一个节点的指针。

使用两个指针front和rear分别指向队列的头部和尾部节点。

入队操作时,新建一个节点并将其添加到rear指向的节点后面,同时将rear指针指向新节点;出队操作时,删除front指向的节点,同时将front指针指向下一个节点。

当front等于rear时,队列为空。

二、队列的应用场景队列在计算机科学中有广泛的应用场景,下面列举几个常见的例子。

1. 操作系统中的进程调度在操作系统中,进程是指正在运行的程序的实例。

操作系统需要管理多个进程的运行,因此需要进行进程调度。

操作系统使用队列来管理进程,将所有等待运行的进程加入到一个队列中,依次从队列中取出进程进行运行。

当一个进程运行结束或等待某些资源时,将其重新加入到队列中等待运行。

2. 网络数据包传输在网络中,数据包是网络传输的基本单位。

用指针实现数组循环队列的方法

用指针实现数组循环队列的方法

用指针实现数组循环队列的方法
数组循环队列是一种常见的队列数据结构,它的特点是可以循环利用数组中的空间,实现高效的入队和出队操作。

使用指针实现数组循环队列可以进一步提高效率,避免数组复制操作对性能的影响。

下面介绍一种用指针实现数组循环队列的方法:
1. 定义一个数组和两个指针,分别指向队头和队尾。

2. 队列初始时,队头和队尾指针都指向数组第一个元素。

3. 入队操作时,将元素插入队尾指针指向的位置,并将队尾指
针往后移动一个位置。

如果队列已满,则返回错误信息。

4. 出队操作时,返回队头指针指向的元素,并将队头指针往后
移动一个位置。

如果队列为空,则返回错误信息。

5. 队列长度可以通过队尾指针和队头指针之间的距离计算得出。

如果队列满了,则队尾指针指向的位置就是队头指针指向的位置,此时队列长度等于数组长度。

6. 如果队列中的元素数量不够数组长度,可以在队尾指针指向
数组最后一个元素时,将队尾指针指向数组第一个元素,并继续插入新元素。

使用指针实现数组循环队列的优点是可以避免数组复制操作对
性能的影响,同时也能够提高队列操作的效率。

但同时需要注意指针的移动和数组下标的转换,以免出现越界和死循环等问题。

- 1 -。

实验8 队列(循环队列)的表示和实现

实验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中,在主函数中进行调用测试。

实现循环队列的入队出队等基本操作

实现循环队列的入队出队等基本操作

实现循环队列的入队出队等基本操作循环队列是一种特殊的队列数据结构,通过循环利用数组空间来实现入队和出队操作。

它的特点是队头和队尾可以在数组上循环移动,从而充分利用数组空间,提高队列的效率。

下面将详细介绍循环队列的实现。

1.定义循环队列的数据结构循环队列的数据结构由以下几个成员组成:-一个固定大小的数组,用于存储队列元素。

- 一个队头指针front,指向队列的第一个元素。

- 一个队尾指针rear,指向队列的最后一个元素的下一个位置。

2.初始化循环队列首先,我们需要在内存中分配一个固定大小的数组,并初始化队头和队尾指针为0。

```pythondef __init__(self, k: int):self.queue = [0] * kself.front = self.rear = 0```3.入队操作入队操作会在队尾插入一个新元素,并将队尾指针后移一位。

如果队列已满,则入队操作会失败。

```pythondef enqueue(self, value: int) -> bool:if self.isFull(:return Falseself.queue[self.rear] = valueself.rear = (self.rear + 1) % len(self.queue)return True```4.出队操作出队操作会删除队头元素,并将队头指针后移一位。

如果队列为空,则出队操作会失败。

```pythondef dequeue(self) -> bool:if self.isEmpty(:return Falseself.front = (self.front + 1) % len(self.queue)return True```5.判空操作判空操作会检查队头和队尾指针是否相等,如果相等则说明队列为空。

```pythondef isEmpty(self) -> bool:return self.front == self.rear```6.判满操作判满操作会检查队尾指针的下一位是否等于队头指针,如果相等则说明队列已满。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

顺序循环队列表实现
————————————————————————————————作者:————————————————————————————————日期:
队列的基本概念
队列也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系与线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作,在其另一端进行删除操作。

队列中允许进行插入操作的一端称为队尾。

允许进行删除操作的一端称为队头。

队头和队尾分别由队头指针和队尾指针指示。

队列的插入操作称为入队列,队列的删除操作称为出队列。

最先入队列的元素总是最先出队列,所以队列也称为先进先出表。

下图是一个一次向队列中插入数据元素a0,a1,a2,….an-1后的示意图,其中,a0是当前队头数据元素,an-1是当前队尾的数据元素。

队头队尾
a0 a1 a2 ……an-1
<-出<-入
队列抽象数据类型
数据集合:
队列的数据集合可以表示为a0,a1,a2,a3….an-1,每个数据元素的数据类型为DataType。

操作集合:
(1)初始化QueueInitiate(Q):初始化队列Q
(2)非空否QueueNotEmpty(Q):队列Q非空否,若队列非空,函数返回值为1。

否则,函数返回0。

(3)入队列QueueAppend(Q,x):在队列Q的队尾插入数据元素x。

入队列成功返回1;
失败则返回0。

(4)出队列QueueDelete(Q,d):把队列Q的队头数据元素删除并由参数d带回。

如出队列成功,返回1;失败则返回0。

(5)取队头数据元素QueueGet(Q,d):取队头数据元素并由参数d带回。

如取到数据元素返回1,否则,返回0。

顺序队列
顺序存储结构的队列称作顺序队列
假设为队列开辟的数组单元数目为MAX_QUEUE,在C语言中,它的下标在0~MAX_QUEUE-1之间,若增加队头或队尾指针,可以利用取模运算(一个整数数值整除以另一个整数数值的余数)实现。

如下所示:
front=(front+1)%MAX_QUEUE;
rear=(rear+1)%MAX_QUEUE;
当front或rear为MAXQUEUE-1时,上述两个公式计算的结果就为0。

这样,就使得指针自动由后面转到前面,形成循环的效果。

队空和队满的标志问题:
队列变为空,队头和队尾指针相等
3.顺序循环队列的实现
根据对顺序循环队列的分析,其结构体定义如下:
typedef struct
{
DataType queue[MaxQueueSize];
int rear; /*队尾指针*/
int front; /*队头指针*/
int count; /*计数器*/
}SeqCQueue;
采用计数器法判断队列空和满的顺序循环队列的算法实现如下:
(1)初始化QueueInitiate(SeqCQueue *Q)
void QueueInitiate(SeqCQueue *Q) /*初始化顺序循环队列Q*/
{
Q->rear=0; /*定义初始化队尾指针下标值*/
Q->front=0; /*定义初始化头指针下标值*/
Q->count=0; /*定义初始化计数器值*/
}
(2)非空否QueueNotEmpty(SeqCQueue Q)
int QueueNotEmpty(SeqCQueue Q)
/*判断顺序循环队列Q非空否,非空返回1,否则返回0*/
{
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*/
{
if(Q->count>0&&Q->rear==Q->front) /*判断队列满否*/
{
printf(“队列已满无法插入!\n”);
return 0;
}
else
{
Q->queue[Q->rear]=x;
Q->rear=(Q->rear+1)%MaxQueueSize;
Q->count++;
return 1;
}
}
(4)出队列QueueDelete(SeqCQueue *Q,DataType *d)
int QueueDelete(SeqCQueue *Q,DataType *d)
/*删除顺序循环队列Q的队头元素并赋给d,成功返回1,失败返回0*/
{
if(Q->count==0)
{
printf(“队列已空无数据元素出队列!\n”);
return 0;
}
else
{
*d=Q->queue[Q->front];
Q->front=(Q->front+1)%MaxQueueSize;
Q->count--;
return 1;
}
}
(5)取队头数据元素QueueGet(SeqCQueue Q,DataType *d)
int QueueGet(SeqCQueue Q,DataType *d)
/*取顺序循环队列Q的当前队头元素并赋给d,成功返回1,失败返回0*/ {
if(Q.count==0)
{
printf(“队列已空无数据元素可取!\n”);
return 0;
}
else
{
*d=Q.queue[Q.front];
return 1;
} }。

相关文档
最新文档