循环队列最早出现在计算机系统设计中，它的出现主要是为了满足实际需求：在存储机制上，传统的队列存储方式难以满足一些实际应用中需要存储大量数据的场景。在有限的数组空间内，传统的队列存储方式可能会出现存储空间浪费过多、存储元素数量不够等问题。而循环队列由于可以利用数组空间的循环使用，从而更加高效地存储大量数据，因此更适合一些实际生产环境中的应用场景。

文章目录

循环队列的概念
循环队列的应用
循环队列存储结构
循环队列接口实现
- 循环队列初始化
- 检测循环队列是否为空
- 检查循环队列是否已满
- 循环队列队尾入队列
- 循环队列队头出队列
- 循环队列获取尾元素
- 循环队列获取首元素
- 销毁循环队列
总结

循环队列的概念

循环队列也是一种非常经典的数据结构，和普通队列类似，它也是一种先进先出（FIFO）的数据结构 , 原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。它使用数组来实现队列的数据储存和操作。循环队列的特点是当队列尾部到达数组的尽头时可以绕回队列的头部，在逻辑形式上看循环队列即形成了一个环形队列，从而达到了更高效的存储和操作效率。在循环队列中，队首和队尾指针可以循环移动，这样就可以利用数组的循环特性，实现空间的最大化利用。

循环队列的应用

循环队列在计算机领域中被广泛应用，尤其是在存储和数据传输方面。一些常见的应用场景包括

网络缓存

在网络通信中，往往需要处理大量的数据流。为了减轻短时间内的网络压力，可以使用循环队列作为缓存，缓冲传输过来的数据。

缓存处理

循环队列可以方便地创建一个缓冲区，用于在内存中缓存较大的数据量，从而在数据计算和处理中提高效率。

任务调度

在操作系统设计中，循环队列被广泛用于实现任务调度的功能。操作系统通常需要管理同步和并发执行的多个任务，而循环队列可以很好地维护这些任务的队列。

双向队列

循环队列除了可以实现单向队列，还可以实现双向队列。双向队列既可以从队列头部进入元素，也可以从队列尾部进入元素，将队列从一端变成了两端，更加灵活实用。

总之，循环队列在操作数据流，任务调度，网络通信等众多领域中都有着广泛的应用。它具有高效存储和操作数据的特点，并且易于实现，是一种非常重要实用的数据结构。

循环队列存储结构

循环队列的存储结构是基于一维数组实现的。但相对于普通的数组，循环队列将队列首尾相连，从逻辑形式形成了一个环形结构。在循环队列中，队列的长度是固定的，并且数组的下标也是固定的。

使用数组来实现循环队列的存储结构有以下几个优点：

数组具有连续的存储空间，可以更好地利用内存。
数组能够提供随机访问数据项的能力，方便快捷，性能高效。
通过适当设置下标的规则，可以实现循环队列的各种操作，如入队、出队、判空、判满等。

循环队列的存储结构中需要用一个一维数组，以及两个指针front 和 rear 来表示队头和队尾指针。其中，front 表示队头指针，它指向的是队头元素；rear 表示队尾指针，它指向的是队尾元素的下一个位置。因为循环队列是环形的，所以在使用队列时，我们需要始终注意指针的值和队列的长度之间的关系。

#define sz 8 //循环队列的最大空间
typedef struct Queue
{
	int *a; //指向队列空间的基址
	int front; //头指针
	int rear; //尾指针
	int k;	 //队列存储空间个数
}CircularQueue;

循环队列与普通队列相比，最大的不同之处在于其队列的队首和队尾指针是可循环的。在循环队列中，队列为空的时候，队首和队尾指针相等；当队列满时，队尾指针必须为队首指针的前一个位置（考虑到环形队列的特点，实际上表现为队尾指针+1等于队首指针（后面实现接口会讲为什么））。故循环队列的空间利用率比普通队列的效率更高，在需要优化存储空间的场景下使用较多。
! 循环队列的存储结构相对简单，但在使用时需要特别注意指针的值和队列长度的关系，避免出现指针指向越界等错误。那下面我们来实现他的接口吧。

循环队列接口实现

首先我们要了解该循环队列如何判空，或者判满？

当头指针和尾指针相等时该情况循环队列是满还是空呢？

解决方案

余留一个空间空置。满: rear + 1 == front 空:rear == front

为什么余留一个空间空置呢？因为这里使用了一个浪费一个空间的方法来处理循环队列。这个空间一般不存储数据，而是留给循环队列尾指针使用，以便尾指针跟踪队列的最后一个元素。在队列空时，此时头指针和尾指针都指向循环队列头部的位置，在队列满时，此时尾指针在最后一个元素的后一个位置，此时尾指针+1 就是等于头指针指向第一个元素。此时循环队列就是满了

增加一个size变量记录数据个数。空: size==0 满: size == 队列存储空间个数

循环队列初始化

综上所述，循环队列在开辟空间时，应该开辟队列存储空间个数 + 1个，余留多一个空间空置，方便判空和判满.其他的都是基本的操作了.具体看代码注释.

//初始化循环队列
CircularQueue* CircularQueueCreate(int k) {
    CircularQueue* ret = (CircularQueue*)malloc(sizeof(CircularQueue)); //分配队列头空间
    if (!ret) //判断是否为空
    {
    	perror("malloc file");
        return NULL;
    }

    ret->a = (int*)malloc(sizeof(int) * (k + 1)); //分配队列存储空间（长度为k+1，浪费一个空间用于循环）
    ret->k = k;   // 设置队列容量
    ret->fornt = 0;   // 队首指针初始为 0
    ret->rear = 0;    // 队尾指针初始为 0

    return ret;  //返回新建的循环队列
}

检测循环队列是否为空

当front和tail相同时，队列为空.

bool CircularQueueIsEmpty(CircularQueue* obj) {
    return (obj->fornt) == (obj->tail);
}

检查循环队列是否已满

判断循环队列是否已满：尾指针real + 1,但是要注意的是循环队列为了实现环形存储，需要对循环队列长度k+1取模。为什么呢？

使用取模就是为了实现循环的目的。例如：假设该队列的数组容量是 k，则当 rear 指针指向数组的第 k 个元素时，如果此时再往 rear 增加一个偏移量 1，就应该将 rear 指针指向数组的第 0 个元素。这时就需要使用取模，将 (rear + 1) % (k + 1) 的结果赋值给 rear 指针。然后判断是否相等.

假如rear尾指针指向循环队列最后一个空置位置，如果不取模，rear+1会导致数组越界，此时就失去循环的意义了。取模的意义就是为了让rear到了数组最后一个下标时+1回到第0个元素。例如：尾指针是指向下标最后一个元素5的 5+1 % 5 + 1 = 0。

bool CircularQueueIsFull(CircularQueue* obj) {
    return (obj->rear + 1) % (obj->k + 1) == obj->fornt;
}

循环队列队尾入队列

在往循环队列中添加元素时，需要先判断队列是否已满，然后在尾指针后面添加元素，并将尾指针向后移动一位，最后对尾指针进行取模操作，以实现循环队列的效果。

bool CircularQueuePush(CircularQueue* obj, int value) {
    if (CircularQueueIsFull(obj)) {  // 判断队列是否已满
        return false;   // 返回 false 表示添加元素失败
    } else {  // 否则说明队列未满
        obj->a[obj->tail] = value;  // 在队尾添加元素
        obj->rear++;  // 队尾指针往后移动一位
        obj->rear %= (obj->k+1);  // 更新队尾指针，实现循环队列
        return true;   // 返回 true 表示添加元素成功
    }
}

obj->rear %= (obj->k+1)这个操作是为了实现循环队列，因为队列的长度是固定的，如果尾指针超过了队列的长度，就需要将它重新回到队列的开始处。其实跟上面判满的取模的逻辑差不多.

我们再举个例子，假设队列的长度为 k+1=6，且数组下标从 0 开始。初始条件下，队列为空，头指针和尾指针都指向位置 0。当我们首次插入元素时，尾指针会移动到下标 1 的位置，而当我们再次插入元素时，尾指针会移动到下标 2 的位置，以此类推。当尾指针指向下标 5 的位置，即队列的最后一个位置时，我们需要将尾指针再向前移动一位，并将其指向下标 0 的位置，从而实现循环队列的效果。这个操作就是通过取模的方式来实现的，即每当尾指针大于等于队列长度时，我们将它除以队列长度后的余数赋值给尾指针，从而让尾指针重新回到队列的开始处。

循环队列队头出队列

循环队列删除对头数据时，先判断是否为空，如果为空就直接返回无需删除，不为空就将头指针往后移动一位，并对新的头指针做取模操作以实现循环队列。

bool CircularQueuePop(CircularQueue* obj) {
    if (CircularQueueIsEmpty(obj)) {  // 判断队列是否为空
        return false;   // 返回 false 表示删除元素失败
    } else {  // 否则说明队列非空
        obj->front++;   // 头指针向后移动一位
        obj->front %= (obj->k+1);  // 对新的头指针做取模操作，实现循环队列
        return true;   // 返回 true 表示删除元素成功
    }
}

为什么向后移动一位就是删除呢?

循环队列中，队列的头尾指针指向的是环形数组中的某一个元素，队列中的元素都是按照插入顺序排列在头尾指针之间的。因此，队列的删除操作其实就是移动头指针指向下一个元素，也就是所谓的“出队”操作。在队列中删除元素不会真正地删除那个元素，而是将头指针向后移动一位并指向下一个元素，这样就实现了元素的逻辑删除。

obj->front %= (obj->k+1) 为什么要取模？

这个取模操作，和添加元素中所使用的一样。这个操作的目的是让头指针重新回到队列的开始处。具体来说，如果头指针 front 指向数组的最后一个位置，再次执行删除操作时，我们需要将头指针向后移动一位，并将其指向数组的第一个位置，从而循环利用数组的位置。所以，在移动头指针时，需要对其进行取模操作，以保证头指针始终指向有效的数组元素。

循环队列获取尾元素

该代码具体流程是：如果队列为空，则返回 -1，否则返回尾指针所指位置的值。

int CircularQueueRear(CircularQueue* obj) {
    if (CircularQueueIsEmpty(obj)) {  // 判断队列是否为空
        return -1;  // 如果队列为空，则返回 -1
    } else {  // 否则说明队尾存在元素
        return obj->a[(obj->rear + obj->k) % (obj->k + 1)];  // 返回尾指针所指位置的元素值
    }
}

return obj->a[(obj->rear + obj->k) % (obj->k + 1)]; 如何理解？

其实该代码是返回 rear之前的一个元素值。下面我讲用图来解答.

当rear指向了下标5的位置，我们应该返回下标下标为4的位置。
例如：当rear为5时， 5+5%6 = 4. 返回了数组下标为4的元素.

可能这里有的人会有疑问? 我直接返回return [rear-1] 不就可以了吗，还用取模那么麻烦吗？那接下来看看这种情况

如果当rear是0时，直接return [rear-1] 返回数组下标-1不就造成越界访问了？所以我们的取模妙就妙在这里，当rear为0时，0+5 % 6 =5 , 直接返回数组下标为5的尾元素。

循环队列获取首元素

如果队列为空，则返回 -1，否则返回队首元素的值。

int CircularQueueFront(CircularQueue* obj) {
    if (CircularQueueIsEmpty(obj)) {  // 判断队列是否为空
        return -1;  // 如果队列为空，则返回 -1
    } else {  // 否则说明队首存在元素
        return obj->a[obj->fornt];  // 返回队首元素的值
    }
}

销毁循环队列

该代码实现简简单，直接看代码注释吧.

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);  // 释放队列中元素所占用的内存空间
    obj->k = 0;  // 将队列长度设为 0
    obj->fornt = 0;  // 将队首指针设为 0
    obj->tail = 0;  // 将队尾指针设为 0
    free(obj);  // 释放循环队列结构体所占用的内存空间
}