【数据结构】循环队列

循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

---

目录

前言

一、传统队列的局限性

二、循环队列的解决方案

三、实现原理

四、例题+代码实现

1. 顺序存储结构

1.1 循环队列类

1.2 构造器，设置队列长度为 k 

1.3 检查循环队列是否为空

1.4 检查循环队列是否已满

1.5 向循环队列插入一个元素

1.6  从循环队列中删除一个元素

1.7 从队首获取元素 

1.8 获取队尾元素 

1.9 销毁循环队列

2. 链式存储结构

总结

---

前言

循环队列：打破空间限制，实现高效数据操作。

在计算机科学中，队列是一种遵循“先进先出”（FIFO）原则的线性数据结构。想象一下排队买奶茶的场景，先到的人先买到奶茶，这就是队列的典型应用。然而，传统的队列在使用数组实现时存在一个明显的缺陷：空间浪费。

---

一、传统队列的局限性

假设我们使用一个长度为5的数组来实现队列。初始状态下，队列为空，front 和 rear 指针都指向数组的起始位置。

1. 入队操作：依次插入元素 A、B、C、D，rear 指针移动到下标为4的位置。

2. 出队操作：移除元素 A，front  指针移动到下标为1的位置。

此时，数组下标为0的位置空出来了，但如果我们继续插入元素 E，rear 指针将移动到数组末尾，即使数组前面还有空闲空间，也无法再插入新的元素。这就是所谓的“假溢出”现象，造成了存储空间的浪费。

---

二、循环队列的解决方案

为了解决传统队列的空间浪费问题，循环队列应运而生。循环队列将数组的首尾相连，形成一个环形结构。当 rear 指针到达数组末尾时，如果数组前面还有空闲空间，rear 指针会绕回到数组的起始位置，继续利用空闲空间存储数据。

---

三、实现原理

这里主要用顺序存储结构即数组来实现循环队列。

顺序存储结构可以通过坐标模上数组大小实现循环结构。

链式存储结构可以通过队头结点与队尾结点首尾相连实现。 

循环队列的空间大小是不变的。即不可以中途插入或删除数据，只能通过坐标指针读取。

根据队列先进先出原则，应有头指针 front 指向队头，以及尾指针 rear 指向队尾。

因为判空和判满的代码都是 front == rear ，因此，为了区分，有以下两种方案：

1. 定义一个 size 变量来存储数据大小的值，如果 size == k 则满
2. 多开辟一块空间不用作为缓冲，使 rear + 1 == front 为满，rear == front 为空

---

四、例题+代码实现

题目链接：622.设计循环队列 - 力扣（LeeCode）https://leetcode.cn/problems/design-circular-queue/

判空： 

front == rear

 判满：

front == (rear + 1) %  QueueSize

通用的计算队列长度的公式： 

(rear - front + QueueSize) % QueueSize

1. 顺序存储结构

循环队列大小是固定的，因此若要改变数据个数，需重开一个新的循环队列，即每个循环队列的k是不变的。

1.1 循环队列类

typedef struct {
    int* a;
    int head;   //指向头
    int tail;   //指向尾的下一个
    int k;      //数据个数（实际空间多开一个）
} MyCircularQueue;

1.2 构造器，设置队列长度为 k 

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pcq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //多开一个空间解决假溢出问题
    pcq->a = (int*)malloc(sizeof(int)*(k+1));
    pcq->head = pcq->tail = 0;
    pcq->k = k;
    return pcq;
}

1.3 检查循环队列是否为空

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;
}

1.4 检查循环队列是否已满

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->head == (obj->tail + 1) % (obj->k + 1);
}

1.5 向循环队列插入一个元素

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
        return false;
    obj->a[obj->tail ++] = value;
    obj->tail %= (obj->k + 1);
    return true;
}

1.6  从循环队列中删除一个元素

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return false;
    obj->head ++;
    obj->head %= (obj->k + 1);
    return true;
}

1.7 从队首获取元素 

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[obj->head];
}

1.8 获取队尾元素 

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    int rear = ((obj->tail + obj->k) % (obj->k + 1));
    return obj->a[rear];
}

1.9 销毁循环队列

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a = NULL;
    free(obj);
}

2. 完整代码示例

代码如下：

typedef struct {
    int* a;
    int head;   //指向头
    int tail;   //指向尾的下一个
    int k;      //数据个数（实际空间多开一个）
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pcq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //多开一个空间解决假溢出问题
    pcq->a = (int*)malloc(sizeof(int)*(k+1));
    pcq->head = pcq->tail = 0;
    pcq->k = k;
    return pcq;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->head == (obj->tail + 1) % (obj->k + 1);
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
        return false;
    obj->a[obj->tail ++] = value;
    obj->tail %= (obj->k + 1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return false;
    obj->head ++;
    obj->head %= (obj->k + 1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[obj->head];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    int rear = ((obj->tail + obj->k) % (obj->k + 1));
    return obj->a[rear];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a = NULL;
    free(obj);
}

---

总结

循环队列是一种高效的数据结构，它通过巧妙地利用数组空间，解决了传统队列的空间浪费问题。理解循环队列的原理和实现方式，对于学习和应用数据结构具有重要意义。