顺序队列与环形队列的基本概述及应用

#define ElemType int    //我们这里举例就定义为int类型，当然什么类型都可以
#define MaxSize 50    //我们这举例就定义MaxSize为50，填多少都可以
typedef struct
{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;

队列到顺序队的映射过程如图所示：

顺序队中实现队列的基本运算

我们接下来的示意图中MaxSize=5。初始front=rear=-1。图如下：

综上所述，对于q所指的顺序队（即顺序队q），初始时设置q->rear=q->front=-1，可以归纳出对后面算法设计来说非常重要的4个要素。

队空的条件：q->front==q->rear。
队满的条件：q->rear==MaxSize-1(data数组的最大下标）。
元素e进队的操作：先将rear增1，然后取出data数组中front位置的元素。

顺序队的基本运算算法

我们先列个表简单概括一下：

函数	功能描述	关键操作
`InitQueue`	初始化队列	分配内存，`front`和 `rear`置为 -1
`DestroyQueue`	销毁队列	释放队列所占内存
`QueueEmpty`	判断队列是否为空	检查 `front == rear`
`enQueue`	元素入队	`rear`先加1，然后在 `rear`位置放入元素
`deQueue`	元素出队	`front`先加1，然后取出 `front`位置的元素

1）初始化队列 `InitQueue`

cpp 复制代码

void InitQueue(SqQueue *&q) {
    q = (SqQueue *)malloc(sizeof(SqQueue));
    q->front = q->rear = -1; // 队头和队尾指针初始化为-1
}

功能：为顺序队列申请内存空间并进行初始化。
细节：
- 参数 SqQueue *&q表示一个指向队列指针的引用，允许函数修改调用者传来的指针。
- 初始时将 front和 rear都设为 -1。这是一种常见的初始化方式，表示队列为空。
注意：确保在调用其他队列操作函数前已成功执行此函数。

2）销毁队列 `DestroyQueue`

cpp 复制代码

void DestroyQueue(SqQueue *&q) {
    free(q); // 释放队列结构体内存
}

功能：释放 malloc为队列分配的内存，防止内存泄漏。

3）判断队列空 `QueueEmpty`

cpp 复制代码

bool QueueEmpty(SqQueue *q) {
    return (q->front == q->rear); // 判断队头指针是否等于队尾指针
}

功能：判断队列是否为空。
细节：当 front和 rear相等时，队列为空。由于初始化时将它们都设为 -1，且出队入队操作可能使它们相等，此判断在非循环队列且初始化为-1的逻辑下是有效的。
重要注意 ：这种判断方式强烈依赖于初始值设为 -1 以及后续的入队出队操作逻辑。如果初始值不同（如0），此判断法则需调整。

4）入队操作 `enQueue`

cpp 复制代码

bool enQueue(SqQueue *&q, int e) {
    if (q->rear == MaxSize - 1) // 判断队尾是否已到数组最大下标
        return false;            // 队满，入队失败
    q->rear++;                   // 队尾指针后移
    q->data[q->rear] = e;        // 新元素放入队尾位置
    return true;                 // 入队成功
}

功能：将新元素 e添加到队尾。
细节与问题：
1. 判满条件 ：if (q->rear == MaxSize - 1)检查队尾指针是否已到达数组末端。这是判断队列是否已满的条件。
2. "假溢出" ：这是该实现的一个主要问题 。即使 q->front不为 -1（即队列前面还有空位），只要 rear到达数组末端，就无法再插入新元素，导致假溢出 （False Overflow）。例如，经过多次入队和出队后，数组前端可能仍有空闲空间，但 rear已到末尾，无法再利用这些空间。
3. 操作顺序 ：先移动 rear指针，再存入数据。

5）出队操作 `deQueue`

cpp 复制代码

bool deQueue(SqQueue *&q, ElemType &e) {
    if (q->front == q->rear) // 判断队列是否为空
        return false;        // 队空，出队失败
    q->front++;              // 队头指针后移
    e = q->data[q->front];   // 取出当前队头指针所指元素
    return true;             // 出队成功
}

功能：删除队头元素并将其值赋给 e。
细节与特点：
1. 判空条件 ：使用 if (q->front == q->rear)。
2. **front指针的含义** ：在这段代码中，front指针指向的是队头元素的【前一个位置】。这也是为什么初始化时要设为 -1。
  - 出队时，先执行 q->front++，使其指向真正的队头元素位置，然后再取出元素 e = q->data[q->front]。
3. "假溢出"加剧 ：出队操作仅仅将 front指针后移，原队头位置的内存空间实际上被废弃了。这加剧了前面提到的"假溢出"问题，因为数组前部的空间无法被新入队的元素使用。

以上就是顺序队最为重要的基本运算实现了，想必大家看到这些也可以对顺序队有了更加清晰的理解吧

队列的环形队列存储结构及其基本运算的实现

基本实现算法

1. 初始化队列 `InitQueue1`

cpp 复制代码

void InitQueue1(SqQueue *&q) {
    q = (SqQueue *)malloc(sizeof(SqQueue));
    q->front = q->rear = 0; // 队头和队尾指针初始化为0
}

功能：为环形队列申请内存空间并进行初始化。
细节：
- 参数 SqQueue *&q是一个引用参数，允许函数修改调用者传来的指针。
- 初始时将 front和 rear都设为 0。这是环形队列最常见的初始化方式。
注意：确保在调用其他队列操作函数前已成功执行此函数。

2. 销毁队列 `DestroyQueue1`

cpp 复制代码

void DestroyQueue1(SqQueue *&q) {
    free(q); // 释放队列结构体内存
}

功能：释放 malloc为队列分配的内存，防止内存泄漏。
注意：此函数释放了队列结构体的内存，但假设 q->data是结构体内部的静态数组（如 ElemType data[MaxSize]），所以无需单独释放。如果 data是动态分配的指针，则需要先释放 q->data再释放 q。此外，更安全的做法是在释放后将指针 q置为 NULL，但这里没有体现。

3. 判断队列空 `QueueEmpty1`

cpp 复制代码

bool QueueEmpty1(SqQueue *q) {
    return (q->rear == q->front); // 判断队头指针是否等于队尾指针
}

功能：判断队列是否为空。
细节：当 front和 rear相等时，队列为空。这是环形队列判断队空的基本条件。

4. 入队操作 `enQueue1`

cpp 复制代码

bool enQueue1(SqQueue *&q, int e) {
    if ((q->rear + 1) % MaxSize == q->front) // 判断队满
        return false;                        // 队满，入队失败
    q->rear = (q->rear + 1) % MaxSize;       // 队尾指针循环后移
    q->data[q->rear] = e;                    // 新元素放入当前队尾位置
    return true;                             // 入队成功
}

功能：将新元素 e添加到队尾。
细节与原理：
1. 判满条件 ：if ((q->rear + 1) % MaxSize == q->front)。此条件是"牺牲一个存储单元"法的核心
  
  。当队尾指针的下一个位置是队头时，就认为队列已满 。这样做的目的是为了区分队空和队满（因为两者在表面上都是 front == rear）。因此，这个队列最多可存储 MaxSize - 1个元素。
2. 操作顺序 ：先移动指针，再存入数据 。这是一个非常关键的特点。rear指针始终指向最后一个有效元素的下一个空位（或者说，当前队尾位置可以放入新元素）。
3. 循环：通过取模运算 % MaxSize实现指针的循环移动。当 rear指向数组末尾时（MaxSize-1），再加一取模就会回到数组开头（0）。

5. 出队操作 `deQueue1`

cpp 复制代码

bool deQueue1(SqQueue *&q, int &e) {
    if (q->rear == q->front)        // 判断队空
        return false;               // 队空，出队失败
    q->front = (q->front + 1) % MaxSize; // 队头指针循环后移
    e = q->data[q->front];          // 取出当前队头指针所指元素
    return true;                    // 出队成功
}

功能：删除队头元素并将其值赋给 e。
细节与原理：
1. 判空条件 ：if (q->rear == q->front)。
2. **front指针的含义** ：在这段代码中，**front指针指向的是队头元素的【前一个位置】** 。这也是为什么出队时，需要先执行 q->front = (q->front + 1) % MaxSize;使其指向真正的队头元素位置，然后再取出元素 e = q->data[q->front];。
3. 操作顺序 ：先移动指针，再取出数据。与入队操作顺序一致。
4. 循环：同样通过取模运算实现循环。

6. 计算元素个数 `Count`

cpp 复制代码

int Count(SqQueue *q) {
    return ((q->rear - q->front + MaxSize) % MaxSize);
}

功能：计算队列中当前有多少个元素。
细节与原理：
- 公式 (rear - front + MaxSize) % MaxSize是计算环形队列元素个数的标准方法。
- **+ MaxSize** ：是为了防止 rear - front出现负数，确保被除数始终为正。
- **% MaxSize** ：最后取模是为了将结果映射到 0到 MaxSize-1的范围内。
- 例如，若 MaxSize=5, front=2, rear=0，计算过程：(0-2+5) % 5 = 3 % 5 = 3。这表示队列中有3个元素。

环形队列的小总结

"牺牲一个单元"策略 ：这是该实现最核心的特点。通过故意浪费一个存储单元，巧妙地解决了队空和队满的判断条件冲突问题（否则当队列真满时，front也会等于 rear，无法与队空区分）。因此，队列的实际容量是 MaxSize - 1。
指针的指向
- front：指向队头元素的前一个位置。
- rear：指向队尾元素的下一个空位。
- 这种指向约定使得入队和出队操作都遵循"先移动指针，再操作数据"的统一顺序。
循环的实现 ：通过取模运算 % MaxSize让指针在数组的物理边界上实现"循环"，这是环形队列的灵魂。它使得队列可以重复利用出队后释放的空间，克服了普通顺序队列的"假溢出"问题。
操作顺序 ：无论是入队还是出队，都是先移动指针，再操作数据。这一点需要牢记，它与指针的初始定义是自洽的。

总的来说队列的顺序结构和环形结构就是以上的基本内容。在本文我没有举例相关应用，因为再举就篇幅太长，起码搞一万字了，在这就不举应用题了，希望本文可以帮助到大家理解队列的两个基本结构。

顺序队列与环形队列的基本概述及应用

队列的基本概念介绍

1.队列的基本概念

2.队列的特点

3.类比

队列的顺序存储结构及其基本运算的实现

顺序队列的定义

顺序队中实现队列的基本运算

顺序队的基本运算算法

1）初始化队列 InitQueue

2）销毁队列 DestroyQueue

3）判断队列空 QueueEmpty

4）入队操作 enQueue

5）出队操作 deQueue

队列的环形队列存储结构及其基本运算的实现

相关概念定义

基本实现算法

1. 初始化队列 InitQueue1

2. 销毁队列 DestroyQueue1

3. 判断队列空 QueueEmpty1

4. 入队操作 enQueue1

5. 出队操作 deQueue1

6. 计算元素个数 Count

环形队列的小总结

1）初始化队列 `InitQueue`

2）销毁队列 `DestroyQueue`

3）判断队列空 `QueueEmpty`

4）入队操作 `enQueue`

5）出队操作 `deQueue`

1. 初始化队列 `InitQueue1`

2. 销毁队列 `DestroyQueue1`

3. 判断队列空 `QueueEmpty1`

4. 入队操作 `enQueue1`

5. 出队操作 `deQueue1`

6. 计算元素个数 `Count`