队列的定义、表示、实现
1
front 2 a1
3 a2
.
a3
rear .
N-1
循环队列（臆造）
N-1
0
1
rear
front a1
2
a3 a2
3
15
新问题：在循环队列中，队空时 front=rear；队满时也 会有 front=rear；判决条件将出现二义性！ 解决方案有二： ①使用一个计数器记录队列中元素个数（即队列长度）； ②人为浪费一个单元，约定：队列头指针在队列尾指针的 下一位置上作为队列呈“满”状态的标志。则队满特征可 改为front=(rear+1)%N （N为最大队列长度）；
（2）删除动作分析： 前面约定指针front指向队首元素的位置，故： e = Q. base [ Q. front ] ; Q. front = ( Q. front + 1 ) % MAXQSIZE;
先取出元素，后 移动队头指针
队列尺寸
25
出队操作完整算法
Status DeQueue ( SqQueue &Q, QElemType &e) {//若队列不空，删除循环队列q的队头元素，
rear; //队尾指针
}SqQueue
建队核心语句：
Q. base=(QElemType *)malloc(sizeof (QElemType ）
* MAXQSIZE); //分配空间
17
队空条件 : front = rear (初始化时：front = rear ) 队满条件： front = (rear+1) % N (N=MAXQSIZE) 队列长度：L=（N＋rear－front）% N
5
三、队列的表示和实现
1.单链队列
// ---Leabharlann -队列的链式存储结构-----结点类型定义：
链队中任一 结点的结构
typedef struct QNode {
QElemType
data; //元素
struct QNode *next; //指向下一结点的指针
} Qnode , * QueuePtr ;
InitStack(temps);
27
while( ! QueueEmpty (Q) ) //初始化temps栈 {
DeQueue (Q, x); Push (temps, x); }
While( ! StackEmpty (temps) ) {
Pop (temps, x); EnQueue (Q, x); } }
12
问题：（1）怎样实现入队和出队操作？核心语句如下：
入队(尾部插入)： Q[rear]=e ; rear++ ; 出队(头部删除)： e=Q[front] ; front++;
（2） 空队列的特征？ 约定：front=rear
（3）队列会满吗？ 极易装满！因为数组通常有长度限制，而其
前端空间无法释放。有假溢出现象。如图：
允许插入的一端为队尾，允许删除的一 端为队头。
例如：队列 Q= (a1 , a2 , a3 , …， an )
队头元素
队尾元素
在队尾插入元素称为入队；
在队首删除元素称为出队。 2
2. 逻辑结构： 与线性表相同，仍为一对一关系。 3. 存储结构：顺序队或链队，以循环顺序队更常见。
4. 运算规则：只能在队首和队尾运算，且访问结点 时依照先进先出（FIFO）的原则。
} ADT Stack
4
基本操作: 建队列、判断队列是否为空、入队、 出队、读队头元素值，等等。
（1）初始化队列 InitQueue(&Q) （2）入队 EnQueue(&Q,e) （3）出队 DeQueue(&Q,&e) （4）获取队头元素内容 GetHead(Q,&e) （5）判断队列是否为空 QueueEmpty(Q)
J2 J1
front=1
J3 J4
J5
J8 J9 J7
J6 J5
rear=4
rear=0 front=5
rear=0
front=5
解：由图可知，队头和队尾指针的初态分别为front=1
和rear=0。
删除4个元素后front=5；
再插入4个元素后，rear=(0+4)%6=4
19
例2. Q[0…10]是一个循环队列，初始状态为 front=rear=0,画出做完下列操作后队列的头尾指针 的状态变化情况，若不能入队，请指出其元素，并说 明理由。 d, e, b, g, h 入队 d, e 出队 i, j, k, l, m 入队 b 出队 n, o, p 入队
11
2. 顺序队列 队列的顺序存储结构如下图所示：
0
1
2
n-2 n-1
a1
a2
a3
...
an-1 an
front
rear
附设两个指针front和rear分别指示队列头元素的位
置和队列尾元素的下一个位置
约定：初始化建空队列时，令front=rear=0；
0
1
2
...
n-2 n-1
front=0
rear=0
算法说明：向循环队列的队尾插入一个元素
分 析： (1) 插入前应当先判断队列是否满？
if (( Q . rear + 1 ) % MAXQSIZE )==Q.front) return ERROR;
(2）插入动作 Q. base [Q. rear] = e; Q. rear = ( Q . rear + 1 ) % MAXQSIZE;
∧
Q.rear
Q. front==Q. rear
7
// -----基本操作的算法描述-----
建队操作——构造空队列Q Status InitQueue (LinkQueue &Q) { // 构造一个空队列
Q.front = Q.rear =
(QueuePtr)malloc(sizeof(QNode));
J2
J3
J1
front
J4 J5
rear
问1：左图中队列 MAXQ6 SIZE N=？
问2：左图中队列长度 L=？ 5
问3： 在具有N个单元的循 环队列中，队满时共有多少 个元素？ N-1个
18
例1. 一循环队列如下图所示，若先删除4个元素，接 着再插入4个元素，请问队头和队尾指针分别指向哪个 位置?
front->next=p->next; free(p);
链队会满吗？ 一般不会，因为删除时有free动作。除
非内存不足！
9
Status EnQueue (LinkQueue &Q, QElemType e) { // 插入元素e为Q的新的队尾元素
p = (QueuePtr) malloc (sizeof (QNode)); if (!p) exit (OVERFLOW); //存储分配失败 p->data = e; p->next = NULL; Q.rear->next = p; Q.rear = p; return OK; }
5. 实现方式 ：关键是掌握入队和出队操作，具体实 现依顺序队或链队的不同而不同。
3
二、队列的抽象数据类型定义
ADT Queue { 数据对象： D＝{ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 } 数据关系： R1＝{ <ai-1, ai >| ai-1, ai∈D, i=2,...,n } 约定a1 端为队列头，an 端为队列尾。 基本操作：
10
Status DeQueue (LinkQueue &Q, QElemType &e) {
// 若队列不空，则删除Q的队头元素， //用 e 返回其值，并返回OK；否则返回ERROR if (Q.front == Q.rear) return ERROR; p = Q.front->next; e = p->data; Q.front->next = p->next; if (Q.rear == p) Q.rear = Q.front; //一定要考虑 free (p); return OK; }
第三章 栈和队列
3.1 栈（Stack） 3.2 队列 （Queue)
1. 定义 2. 逻辑结构 3. 存储结构 4. 运算规则 5. 实现方式
1. 定义 2. 逻辑结构 3. 存储结构 4. 运算规则 5. 实现方式
1
一、概念：
3.2 队列
1. 定义 只能在表的一端进行插入运算，在表的 另一端进行删除运算的线性表。
if (!Q.front) exit (OVERFLOW);
//存储分配失败
Q.front->next = NULL;
return OK;
}
8
链队列的入队和出队操作
Q front
p
a1
a2
(队首)
rear
a3 ^ S e ^
(队尾)
入队（尾部插入）：rear->next=S; rear=S;
出队（头部删除）：p=front->next;
链队列类型定义：
关于整个链队的 总体描述
typedef struct { QueuePtr front ; QueuePtr rear ;
//队头指针 //队尾指针
} LinkQueue;
6
为了操作方便，添加一个头结点，令头指针指向头结点。
Q.front Q.rear
a1
…
an ∧
空队列 Q.front
顺序队操作实验报告
一、实验目的1. 理解顺序队列的基本概念和操作方法。
2. 掌握顺序队列的创建、初始化、入队、出队、清队等基本操作。
3. 熟悉顺序队列在实际问题中的应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容1. 顺序队列的定义和实现2. 顺序队列的创建和初始化3. 顺序队列的入队操作4. 顺序队列的出队操作5. 顺序队列的清队操作6. 顺序队列的遍历操作7. 顺序队列的应用实例四、实验步骤1. 顺序队列的定义和实现首先，我们需要定义一个顺序队列的数据结构。
在C++中，我们可以使用结构体来定义顺序队列。
```cpp#include <iostream>using namespace std;#define MAX_SIZE 100struct SeqQueue {int data[MAX_SIZE];int front;int rear;};```2. 顺序队列的创建和初始化创建一个顺序队列并初始化其头尾指针。
```cppvoid InitQueue(SeqQueue &Q) {Q.front = 0;Q.rear = 0;}```3. 顺序队列的入队操作当队列未满时，可以将元素插入队列的尾部。
```cppbool EnQueue(SeqQueue &Q, int x) {if ((Q.rear + 1) % MAX_SIZE == Q.front) { return false; // 队列已满}Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % MAX_SIZE;return true;}```4. 顺序队列的出队操作当队列非空时，可以删除队列头部的元素。
```cppbool DeQueue(SeqQueue &Q, int &x) {if (Q.front == Q.rear) {return false; // 队列为空}x = Q.data[Q.front];Q.front = (Q.front + 1) % MAX_SIZE; return true;}```5. 顺序队列的清队操作将队列头尾指针都设置为0，清空队列。
queue的使用方法 -回复
queue的使用方法-回复队列是一种常见的数据结构，用于存储一系列元素，并按照先进先出（FIFO）的原则进行操作。
它可以用于处理一些需要临时保存数据并按照先后顺序进行处理的场景，比如任务调度、打印任务队列等。
在本文中，我们将介绍队列的使用方法，重点讨论如何实现队列、队列的基本操作和相关的应用场景。
第一部分：队列的基本概念和实现思路（500字）1. 队列的定义和特点队列是一种线性数据结构，采用顺序存储或链式存储方式。
它的特点是先进先出（FIFO），即新元素从队列的尾部添加，而老元素从队列的头部删除。
2. 队列的实现思路队列的实现可以基于数组或链表。
使用数组实现时，需要定义一个固定大小的数组，通过两个指针分别指向队列的头部和尾部。
使用链表实现时，每个节点存储队列中的一个元素，并通过指针连接节点，形成一个链表。
3. 数组实现的队列示例我们定义一个长度为n的数组queue，以及两个指针front和rear，分别指向队列的头和尾。
当我们添加一个新元素时，将其存储在rear指针指向的位置，并将rear指针后移；当我们删除一个元素时，将其从front指针指向的位置删除，并将front指针后移。
需要注意的是，当rear指针到达数组末尾时，我们可以通过循环将其移动到数组的开头，实现循环队列。
4. 链表实现的队列示例我们定义一个链表的头结点和尾结点，分别指向队列的头和尾。
当我们添加一个新元素时，将其作为尾结点的下一个节点，并将尾结点指向它；当我们删除一个元素时，将头结点的下一个节点从链表中删除，并将头结点指向下一个节点。
第二部分：队列的基本操作（500字）1. 入队操作入队操作将一个新元素添加到队列中。
在数组实现中，我们首先判断队列是否已满，若已满则无法添加新元素；若未满，则将新元素添加到rear 指针指向的位置，并将rear指针后移。
在链表实现中，我们直接在尾结点后添加新节点，并更新尾结点指针。
2. 出队操作出队操作将队列头部的元素删除，并返回该元素。
c语言队列的实现以及操作
c语言队列的实现以及操作摘要: 队列是数据结构中的一种，在实际生活中也有广泛的应用，本文通过介绍c语言的相关基础知识和算法，实现基本的队列结构以及其中的插入，删除，遍历，清空操作。
关键词：C语言；实现；队列；操作队列是数据结构中的一种，它按照先进先出的原则存储数据，可以分为循环队列和非循环队列，本文将结合c语言的基础知识，利用简单的算法实现非循环队列以及其中的插入，删除，遍历，清空操作。
一、实现队列1.声明结构体在使用c语言实现队列时，首先需要声明一个结构体Queue来定义队列，并定义队头和队尾指针，表示队列的入口和出口，以及空间的大小容量maxSize，并且用一个数组data[]来存储数据。
struct Queue{int data[maxSize]; //存储数据int front; //队头int rear; //队尾int maxSize; //队列容量};2.初始化队列在进行队列操作之前，我们需要将队列初始化，将队头队尾指针置于初始位置，表示队列为空，并将队列最大容量maxSize赋值。
void InitQueue(Queue *queue){queue->front = 0;queue->rear = 0;queue->maxSize = maxSize;}3.入队操作在进行入队操作时，我们先判断队列是否已满，如果未满，就将数据入队，并将队尾指针加一，否则返回队列已满的错误信息。
bool EnQueue(Queue *queue,int data){if((queue->rear+1)%queue->maxSize == queue->front) //队列满return false;queue->data[queue->rear] = data;queue->rear = (queue->rear+1)%queue->maxSize;return true;}4.出队操作在进行出队操作时，我们先判断队列是否为空，如果不为空，就将队头指针对应的数据出队，并将队头指针加一，否则返回队列已空的错误信息。
c语言队列实现代码
c语言队列实现代码队列是一种常见的数据结构，它具有先进先出的特点，常常用于实现缓冲区等功能。
在c语言中，我们可以使用数组来实现队列。
下面我们将详细介绍c语言队列的实现代码。
1. 定义一个队列结构体我们可以定义一个结构体来表示队列。
结构体中包含队列的大小，队头和队尾指针以及用于存储元素的数组。
代码如下：```#define MAXSIZE 10typedef struct {int size; // 队列大小int front; // 队头指针int rear; // 队尾指针int elements[MAXSIZE]; // 用于存储元素的数组} queue;```其中，size表示队列的大小，front和rear分别表示队头和队尾指针，elements数组用于存储元素。
2. 初始化队列在使用队列之前，我们需要对队列进行初始化，即将队头和队尾指针都设置为0。
代码如下：```void init_queue(queue* q) {q->size = 0;q->front = 0;q->rear = 0;}```在这个函数中，我们将size、front和rear都设置为0，表示队列为空。
3. 入队操作当我们要向队列中添加一个元素时，需要将元素放入队尾，并将队尾指针后移。
如果队列已满，则无法再添加元素。
代码如下：```int enqueue(queue* q, int element) {if (q->size == MAXSIZE) {return -1; // 队列已满}q->elements[q->rear] = element;q->rear = (q->rear + 1) % MAXSIZE;q->size++;return 0;}```在这个函数中，我们首先检查队列是否已满，如果队列已满则返回错误码-1。
否则，我们将新元素放入队尾，然后将队尾指针后移，并将队列大小加1。
数据结构-第3章-队列
a
front
b
c
d
e
f
g
rear
3.2 队列的顺序存储及实现
在使用队列前，先初始化队列，此时，队列为空，队头指针 front和 队尾指针rear都指向队列的第一个位置，即front=rear=0，如图3.3 所示。
下标 0 1 2 3 4 5 6Байду номын сангаас7 8 9
3.3 队列的链式存储及实现
（2）判断队列是否为空。 int QueueEmpty(LinkQueue *Q) {
return Q->rear==Q->front;
}
//头尾指针相等队列为空
3.3 队列的链式存储及实现
（3）将元素x入队。先为新结点申请一个空间，然后将x赋给数据 域，并使原队尾元素结点的指针域指向新结点，队尾指针指向新结点， 从而将结点加入队列中。操作过程如图3.20所示。
3.2 队列的顺序存储及实现
（4）入队
int EnQueue(CirQueue *Q , DataType x)
{ if(QueueFull(Q)) printf(“Queue overflow”); else{ Q->data[Q->rear]=x; Q->rear=(Q->rear+1)%QueueSize; } }
3.3 队列的链式存储及实现
链式队列的类型描述如下：
/*结点类型定义*/
typedef struct QNode { DataType data; struct QNode * next; } QueueNode; /*队列类型定义*/ typedef struct { QueueNode * front; //队头指针
队列研究的实施步骤有哪些
队列研究的实施步骤有哪些引言在计算机科学领域，队列是一种常用的数据结构。
队列研究的实施步骤涉及队列的定义、基本操作、应用场景等方面。
本文将介绍队列研究的实施步骤，以帮助读者更好地理解和应用队列。
步骤一：定义队列队列是一种先进先出（First-In-First-Out，FIFO）的数据结构，它只允许在队尾插入元素，在队头删除元素。
队列可以用数组、链表或其他数据结构实现。
在队列的定义中，需要明确队列的数据类型和容量限制。
步骤二：实现基本操作队列的基本操作包括入队（enqueue）和出队（dequeue）操作。
入队操作将元素插入队列的队尾，出队操作删除队列的队头元素。
除此之外，还包括其他常用操作，如获取队头元素（getFront）、获取队列长度（getSize）等。
常见的队列操作实现有顺序队列、循环队列、链式队列等。
选择合适的实现方式，根据需求和性能要求来决定。
步骤三：分析队列的性质和特点队列的性质和特点对于深入理解和应用队列起到关键作用。
队列的性质包括FIFO特性、队列是否为空、队列是否已满等。
队列的特点有序性、高效性、稳定性等。
分析队列的性质和特点可以帮助研究者更好地理解和优化队列的应用。
步骤四：研究队列的应用场景队列作为一种常用的数据结构，在各个领域都有广泛的应用。
研究队列的应用场景可以帮助开发人员解决实际问题。
常见的队列应用场景包括任务调度、消息队列、缓冲区等。
步骤五：比较队列与其他数据结构的优劣队列作为一种数据结构，与其他数据结构如栈、链表、树等都有不同的特点和应用场景。
比较队列与其他数据结构的优劣可以帮助研究者更好地选择适合的数据结构来解决问题。
步骤六：性能分析和优化队列的性能分析和优化是队列研究的重要内容。
通过对队列的性能参数如入队和出队的时间复杂度进行分析，可以评估队列的性能指标。
对队列的性能进行优化可以提高算法和系统的效率。
常见的队列性能优化技术包括改进队列实现方式、调整队列参数、优化队列的存储结构等。
1.4限定性线性表-队列
这种循环意义下的加1操作可以描述为： if(I+1==m) i=0; else i++; 利用模运算可简化为： i=(i+1)%m
显然，因为循环队列元素的空间可以被利用，除非向 量空间真的被队列元素全部占用，否则不会上溢。因此， 除一些简单的应用外，真正实用的顺序队列是循环队列。
问题二
如图所示：由于入队时尾指针向前追赶头指针，出 队时头指针向前追赶尾指针，故队空和队满时头尾指针 均相等。因此，我们无法通过front=rear来判断队列 “空”还是“满”。 解决此问题的方法至少有三种 方法一是另设一个布尔变量以匹别队列的空和满； （教材上给定的方法）
(3)出队操作
判断队列是否为空： 若 front==rear 已空为“下溢”
否则非空，则重新设置队头指针：
front=(front+1)% m;
(4) 计算循环队列中的元素个数
（rear- front+m）%m 或 若rear>front rear-front 若rear<front rear-front+m
循环队列是队列的一种顺序表示和实现方法。
问题一 为充分利用向量（0:m-1）。克服上述假上溢现象
的方法是将向量空间想象为一个首尾相接的圆环，并称
这种向量为循环向量，存储在其中的队列称为循环队列。 在循环队列中进行出队、入队操作时，头尾指针仍要加 1，朝前移动。只不过当头尾指针指向向量上界（m-1） 时，其加1操作的结果是指向向量的下界0。 Nhomakorabea作
业
3.设栈s和队列q的初始状态为空，元素 e1,e2,e3,e4,e5,e6依次通过栈s，一个元素出栈后即 进入队列q，若出队的顺序为e2,e4,e3,e6,e5,e1，则 栈s的容量至少应该是多少？ 3
队列的介绍和利用环形队列实现STM32进阶之串口环形缓冲区的概述
队列的介绍和利用环形队列实现STM32进阶之串口环形缓冲区的概述队列的概念
在此之前，我们来回顾一下队列的基本概念：队列(Queue)：是一种先进先出(First In First Out ,简称FIFO)的线性表，只允许在一端插入（入队），在另一端进行删除（出队）。
队列的特点
类似售票排队窗口，先到的人看到能先买到票，然后先走，后来的人只能后买到票
队列的常见两种形式
普通队列
在计算机中，每个信息都是存储在存储单元中的，比喻一下吧，上图的一些小正方形格子就是一个个存储单元，你可以理解为常见的数组，存放我们一个个的信息。
当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的，那么处理完后呢，就会把数据释放掉，再处理下一个。
那么，已经处理的数据的内存就会被浪费掉。
因为后来的数据只能往后排队，如过要将剩余的数据都往前移动一次，那么效率就会低下了，肯定不现实，所以，环形队列就出现了。
环形队列
它的队列就是一个环，它避免了普通队列的缺点，就是有点难理解而已，其实它就是一个队列，一样有队列头，队列尾，一样是先进先出（FIFO）。
我们采用顺时针的方式来对队列进行排序。
队列头 (Head) :允许进行删除的一端称为队首。
队列尾 (Tail) :允许进行插入的一端称为队尾。
环形队列的实现：在计算机中，也是没有环形的内存的，只不过是我们将顺序的内存处理。
实验报告队列
一、实验目的1. 理解队列的概念和特点；2. 掌握队列的基本操作，包括入队、出队、查看队列头元素等；3. 能够使用队列解决实际问题。
二、实验环境1. 操作系统：Windows 10；2. 编程语言：C语言；3. 开发环境：Visual Studio 2019。
三、实验内容1. 队列的定义和实现；2. 队列的基本操作；3. 使用队列解决实际问题。
四、实验步骤1. 队列的定义和实现（1）定义队列的数据结构```c#define MAXSIZE 100 // 队列的最大容量typedef struct {int data[MAXSIZE]; // 队列的存储空间int front; // 队列头指针int rear; // 队列尾指针} Queue;```（2）初始化队列```cvoid InitQueue(Queue q) {q->front = 0;q->rear = 0;}```（3）判断队列是否为空```cint IsEmpty(Queue q) {return q->front == q->rear;}```（4）判断队列是否已满```cint IsFull(Queue q) {return (q->rear + 1) % MAXSIZE == q->front; }```2. 队列的基本操作（1）入队操作```cint EnQueue(Queue q, int x) {if (IsFull(q)) {return 0; // 队列已满}q->data[q->rear] = x;q->rear = (q->rear + 1) % MAXSIZE; return 1;}```（2）出队操作```cint DeQueue(Queue q, int x) {if (IsEmpty(q)) {return 0; // 队列为空}x = q->data[q->front];q->front = (q->front + 1) % MAXSIZE; return 1;}```（3）查看队列头元素```cint GetHead(Queue q, int x) {if (IsEmpty(q)) {return 0; // 队列为空}x = q->data[q->front];return 1;}```3. 使用队列解决实际问题（1）实现一个简单的函数，将一个整数数组中的元素按照逆序输出```cvoid ReversePrint(int arr[], int n) {Queue q;InitQueue(&q);for (int i = 0; i < n; i++) {EnQueue(&q, arr[i]);}int x;while (!IsEmpty(&q)) {DeQueue(&q, &x);printf("%d ", x);}printf("\n");}```（2）实现一个函数，计算两个整数序列的交集```cvoid Intersection(int arr1[], int n1, int arr2[], int n2, int result[]) {Queue q;InitQueue(&q);for (int i = 0; i < n1; i++) {EnQueue(&q, arr1[i]);}int x;int i = 0, j = 0;while (!IsEmpty(&q)) {DeQueue(&q, &x);while (i < n2 && arr2[i] < x) {i++;}if (i < n2 && arr2[i] == x) {result[j++] = x;}}result[j] = 0; // 标记交集结束}```五、实验结果与分析1. 实验结果（1）定义队列的数据结构（2）初始化队列（3）判断队列是否为空（4）判断队列是否已满（5）入队操作（6）出队操作（7）查看队列头元素（8）使用队列逆序输出整数数组（9）使用队列计算两个整数序列的交集2. 实验分析通过本次实验，我们掌握了队列的基本概念、数据结构、操作方法以及在实际问题中的应用。
队列的顺序表示形式和实现
队列的顺序表⽰形式和实现队列的顺序表⽰是⽤⼀组地址连续的存储单元依次存放队列中的各个元素，并⽤指针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;}。