前言

今天我们将学习循环队列实现，我们首先介绍队列的概念和结构，之后一步步讲解循环队列由来与实现。

一、队列的概念与结构

1、队列的概念

队列： 只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。队列是一种先进先出FIFO（first in first out）的线性表，允许插入的一端称为队尾，允许删除的一端称为队头。（这种结构很符合我们生活中的习惯，排在第一个的优先出列，最后来的当然就在队伍最后。）

2、队列的结构

3、实例

比如： ①键盘的输入：输入“abc”，输出也是“abc”；②生活中的排队等等。

二、循环队列

1、队列的实现方式有两种

线性表有顺序存储和链式存储。同样，队列作为一种特殊的线性表，也同样存在这两种存储方式。

2、队列顺序存储的不足

队列的顺序存储其实就是使用数组来实现。数组实现队列，一般数组下标为0的一端为队头，数组尾为队尾。

入队： 入队是在队尾插入数据，即在数组尾追加一个数据，不需要移动数据，所以时间复杂度为O（1）。如下图：

出队： 出队是在队头删除数据，即数组的头删，需要挪动后面的所有元素，保证所有元素都从队头出去，此时时间复杂度为O（N）。如下图：

但是每一次出队列都需要挪动数据，效率不太好。那能不能不将队头的位置固定在下标为0的位置，即每出队列一次，队头向后跳过一个元素，此时时间复杂度为O(1)。如下图：

使用这种方法出队列，虽然效率提高了，但又引出了一个新问题——“假溢出”。

假溢出： 如下图，假设队列的总个数为5，当数组末尾的空间已经被占用了，此时再入队，就会产生数组越界的问题，可实际上，我们队列在下标0、1、2的地方还是空闲的。这种现象就叫做“假溢出”。

那“假溢出”有没有解决方案呢？

答案是：有的，有三种解决方案。

①当队列满了，就扩容。但缺点就是空间利用率低。

②不改变队头的位置，挪动数据。缺点：时间复杂度为O(N)。

③循环队列。优点：效率高。（缺点实在来说就只有，队列大小实现前要确定好。）

3、循环队列的定义

循环队列： 我们把队头与队尾是相互链接的队列称为循环队列。因为循环队列首尾相连，所以只要队列没有满就可以插入数据，不会产生假溢出问题。

理解： ①队列的大小要事先确定；②队列首尾相连。

实现：①顺序存储实现；②链式存储实现。这两种实现方式哪种更好呢？

答案是：顺序存储实现更好。假设队列大小为5，队首指针为front，队尾指针的下一个为rear，分析如下：

①链式存储实现：

问题1：队列空与队列满情况一样，如下图：


解决方案：

①队列成员加一个成员size变量储存有效数据个数——>队列满：size == k；队列空：size == 0。

②队列多开辟一个空间——>队列满：rear->next == front;队列空：rear == front。（这里我们使用方案2解决。）

问题2：取队尾元素不好取，如下图：


解决方案：①双向链表；②队列加一个成员变量prev储存rear的前驱结点。

②顺序存储实现：

问题1：怎么实现首尾相连，即rear与front到了下标k的位置怎么回到下标0的位置。


tip：

①取队尾：（rear - 1 + k + 1）% （k + 1）


②队列满：（rear + 1）% （k + 1）== front，队列空：rear == front


总结： 由上分析可知，链式存储对比顺序存储的劣势有：①多一个指针域，浪费空间；②不好找队尾元素；③代码实现复杂等等。所以下面我们将使用顺序存储实现循环队列。

4、循环队列的实现

队列的实现，应该支持如下操作：

• MyCircularQueue(k)：构造器，在堆区申请队列对象，初始化队首、队尾指针、队列长度。
  
• Front：获取队首元素。如果队列为空，返回-1。
  
• Rear：获取队尾元素。如果队列为空，返回-1。
  
• enQueue(value)：入队列——队尾插入一个元素。如果成功插入返回真。
  
• deQueue()：出队列——队头删除元素。如果成功删除返回真。
  
• isEmpty()：检查队列是否为空。
  
• isFull()：检查队列是否已满。
  
• Free()：销毁队列。
  

循环队列在力扣有题目，大家可以先去做一做。链接在下面。

循环队列链接

循环队列的代码实现：

//循环队列的结构
typedef struct 
{
    int* a;//指向堆区开辟的数组
    int front;//队首指针——表示队首位置
    int rear;//队尾指针——表示队尾的下一个
    int length;//队列长度
} MyCircularQueue;

//初始化——在堆区开辟队列对象与队列空间，并初始化队首与队尾,队列长度
MyCircularQueue* myCircularQueueCreate(int k) 
{
    //在堆区开辟循环队列的对象
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //判断是否开辟成功
    if(NULL == obj)
    {
        //打印错误信息
        perror("malloc fail");
        return NULL;
    }
    //申请队列空间——为避免队列满与空情况一样，队列多开辟一个空间
    obj->a = (int*)malloc(sizeof(int) * (k + 1));
    //判断是否开辟成功
    if(NULL == obj)
    {
        //打印错误信息
        perror("malloc fail");
        return NULL;
    }
    //初始化队首、队尾指针
    obj->front = 0;
    obj->rear = 0;
    //初始化队列长度
    obj->length = k + 1;
    //返回在堆区开辟循环队列对象
    return obj;
}
//检查队列是否已满，满返回真
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    //断言obj不为空
    assert(obj);
    //相等则满
    return (obj->rear + 1) % obj->length == obj->front;
}

//入队列：队尾插入数据，成功返回真
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
    assert(obj);
    //调用myCircularQueueIsFull判断队列是否满
    if(myCircularQueueIsFull(obj))
    {
        return false;//满，直接返回假
    }
    //队尾插入数据
    obj->a[obj->rear] = value;
    //插入之后，rear+1
    obj->rear++;
    //rear每一次+1后，防止越界，当rear = k时，取模回到下标0
    obj->rear %= obj->length;
    //插入成功返回真
    return true;
}
//检查队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    assert(obj);
    //相等队列为空
    return obj->rear == obj->front;
}
//出队列：队头出队列，即front++，出队列成功返回真
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    assert(obj);
    //调用myCircularQueueIsEmpty判断队列是否为空
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    //删除队头，即front++
    obj->front++;
    //front每一次+1后，防止越界，即当front = k时，取模回到下标0
    obj->front %= obj->length;
    //出队列成功返回真
    return true;
}
//获取队首元素。如果队列为空，返回 -1 。
int myCircularQueueFront(MyCircularQueue* obj) 
{
    assert(obj);
    //调用myCircularQueueIsEmpty判断队列是否为空
    if(myCircularQueueIsEmpty(obj))
    {
        //为空，返回-1
        return -1;
    }
    //不为空返回队首元素
    return obj->a[obj->front];
}
//获取队尾元素。如果队列为空，返回 -1 。
int myCircularQueueRear(MyCircularQueue* obj) 
{
    assert(obj);
    //调用myCircularQueueIsEmpty判断队列是否为空
    if(myCircularQueueIsEmpty(obj))
    {
        //为空，返回-1
        return -1;
    }
    //返回队尾元素，rear为队尾的下一个，(rear - 1 + obj->length) % obj->length)即为队尾位置，注意不能使用--操作符
    return obj->a[(obj->rear - 1 + obj->length) % obj->length];
}
//销毁队列
void myCircularQueueFree(MyCircularQueue* obj) 
{
    assert(obj);
    //注意销毁的顺序，要先释放队列结构中的数组，再释放队列对象
    free(obj->a);
    //free之后，obj->a指向不变，防止野指针，置为空
    obj->a = NULL;
    free(obj);
    obj = NULL;
}

希望对大家有帮助，循环队列就讲解完成了。循环队列有个缺点就是必须先开辟队列空间，队列的大小实现就要确定好，那有没有队列空间按需提供的呢？答案是：有的，就是链式队列。在下一期作者会对其详细讲解。