设计循环队列（图示超详解哦）

引言

我们在使用队列时，发现它其实是有一点缺陷的。就是在从队列前面移除元素后，这块空间就被释放掉了，如果再想插入元素的话，就要再开辟空间。这过程中其实对效率是有一定的影响的。

于是就有了循环队列的思路：
循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

这道题目就是要求我们实现一个循环队列的接口：
设计循环队列OJ链接

设计循环队列

题目介绍

我们需要实现循环队列的如下接口：

MyCircularQueue(k): 构造器，设置队列长度为 k ；
Front: 从队首获取元素。如果队列为空，返回 -1 ；
Rear: 获取队尾元素。如果队列为空，返回 -1 ；
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真；
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真；
isEmpty(): 检查循环队列是否为空；
isFull(): 检查循环队列是否已满。

思路简述

对于循环队列，因为数组可以随意访问数组中的元素，并且可以由下标很容易的计算出数组中存储的元素个数。所以我们用数组来实现这个循环队列。
对于数组实现的循环队列来说，我们可以存储队列头与队列尾元素的下标，方便计算。

但是我们不难发现，当队列为空或队列已满时，首尾下标都是重合的，这就使得我们判断出现了问题。所以我们可以额外开辟一个元素的空间，这个空间永远是空出来的。当尾下标在头下标前面一个位置时，说明循环队列已满；

另一个问题就是如何让循环队列循环起来。
我们如果只是在插入后，尾下标++；删除后，头下标–。那么开辟的数组总有满的时候，并且不能实现空间的复用。我们其实可以将++或–后的下标%数组的长度。这样，若数组最后一个位置的下标++再%数组的长度就是0，回到了数组开头，这样就实现了数组逻辑上的循环：

实现

我们需要一个结构体来存放用于存储数据的数组、首下标与尾下标、队列容量：

typedef struct 
{
	int* data;//存储数据的数组
	int front;//队列首下标
	int rear;//队列尾下标
	int capacity;//队列容量
} MyCircularQueue;

初始化循环队列

初始化循环队列时：
首先为存储队列的结构体动态开辟一块空间；
再为存储数据的数组开辟一块空间，由于这块空间中需要包含一个为空的元素，所以空间的大小是循环队列大小+1；

然后将循环队列的容量初始化为k；
将头下标ftont与尾下标rear初始化尾0；

最后返回结构体即可：

//初始化循环队列
MyCircularQueue* myCircularQueueCreate(int k) 
{
	MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	assert(obj);
	obj->data = (int*)malloc(sizeof(int) * (k + 1));
	assert(obj->data);
	obj->capacity = k;
	obj->front = 0 % (obj->capacity + 1);
	obj->rear = 0 % (obj->capacity + 1);
	return obj;
}

判断循环队列是否为空

前面已经介绍过：当front与rear相同时，说明循环队列为空，此时返回真，否则返回假：

//判断循环队列是否为空，为空返回真
bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
	assert(obj);
	if (obj->front == obj->rear)//front与rear重合时循环队列为空
	{
		return true;
	}
	else
	{
		return false;
	}
}

判断循环队列是否已满

判断是否已满时：
当循环队列已满时，rear一定在front的前一个位置，即front-rear为1；但是，当front为0时，front-rear的值就是负的容量的值。我们只需要在判断时包含这种情况即可：

//判断循环队列是否已满，已满返回真
bool myCircularQueueIsFull(MyCircularQueue* obj)
{
	assert(obj);
	if (obj->front - obj->rear == 1 || obj->front - obj->rear == -(obj->capacity))//当rear在front前面一个时循环队列已满;当front为0时，rear为k才是已满
	{
		return true;
	}
	else
	{
		return false;
	}
}

从循环队列尾入

在循环队列尾入时，首先复用myCircularQueueIsFull函数判断循环队列是否已满。
若没满，在循环队列下标为rear的位置放入一个元素（rear的起始下标为0，指向的其实为尾元素的下一个位置的下标）；
然后将rear+1%数组长度的结果赋给rear：

//从循环队列尾插入一个元素，成功返回真
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
	assert(obj);
	if (myCircularQueueIsFull(obj) == 0)//为真说明没有满
	{
		obj->data[obj->rear] = value;
		obj->rear = (obj->rear + 1) % (obj->capacity + 1);
		return true;

	}
	else
	{
		return false;
	}
}

从循环队列头出

从循环队列出时，首先复用myCircularQueueIsEmpty函数判断循环队列是否为空；
然后删除数组中下标为front的元素：所谓的删除，就是front向后移动一个元素即可：所以我们将front+1%数组长度的结果赋给front即可：

//从循环队列头出一个元素，成功返回真
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
	assert(obj);
	if (myCircularQueueIsEmpty(obj) == 0)//为真说明不是空的
	{
		obj->front = (obj->front + 1) % (obj->capacity + 1);
		return true;
	}
	else
	{
		return false;
	}
}

访问循环队列头的元素

访问队列头的元素时，只需要返回下标为front的元素即可：

//访问队列头的元素，为空返回-1
int myCircularQueueFront(MyCircularQueue* obj) 
{
	assert(obj);
	if (myCircularQueueIsEmpty(obj) == 0)//为真说明不是空的
	{
		return obj->data[obj->front];
	}
	else
	{
		return EOF;
	}
}

访问循环队列尾的元素

访问队列尾的元素时，只需要返回下标为rear-1的元素即可：

//访问队列尾的元素，为空返回-1
int myCircularQueueRear(MyCircularQueue* obj) 
{
	assert(obj); 
	if (myCircularQueueIsEmpty(obj) == 0)//为真说明不是空的
	{
        int n = 0;
        if(obj->rear==0)
        {
            n=obj->capacity;
        }
        else
        {
            n=obj->rear-1;
        }
		return obj->data[n];
	}
	else
	{
		return EOF;
	}
}

销毁循环队列

销毁循环队列时，将存储数据的数组free释放掉，再将结构体free释放即可：

//销毁循环队列
void myCircularQueueFree(MyCircularQueue* obj) 
{
	obj->capacity = 0;
	free(obj->data);
	obj->front = 0;
	obj->rear = 0;
	free(obj);
}

总结

到此，关于循环队列的题目以及介绍完了

如果大家认为我对某一部分没有介绍清楚或者某一部分出了问题，欢迎大家在评论区提出

如果本文对你有帮助，希望一键三连哦

希望与大家共同进步哦