题目描述
设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于
FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。
你的实现应该支持如下操作:
MyCircularQueue(k): 构造器,设置队列长度为 k 。 Front: 从队首获取元素。如果队列为空,返回 -1 。
Rear: 获取队尾元素。如果队列为空,返回 -1 。 enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。 isEmpty(): 检查循环队列是否为空。 isFull():
检查循环队列是否已满。
思路讲解
这道题目的意思就是设计一个循环队列,队列的大小是固定的,但可以一直排队插入数据,如果队列空间满了就排队等在后面,队列释放出了空间之后,又可以插入新的数据,就像一个固定的内存空间,可以插入数据在数据满的时候也可以删除数据,循环使用。
这里我们用数组的形式来设计一个循环队列,为什么要用数组来设计循环队列,而不用链表,那是因为,数组比链表更加方便访问,而链表操作起来会更加复杂一些,我们这里的空间是固定的,而不是随机的,开辟数组就相当于开辟了内存中可以连续存放的空间,访问数据的速度和链表相比更快。
我们这里最主要考虑的问题就是,在什么时候判断队列里面的数据存放满了,还有什么时候队列是空的
我们来画图看看
现在我们往里面插入数据,采用尾插,头不动
这样我们的数据就插满我们的队列了,我们首先把head 和tail都置为0,tail指向存放元素的下一个位置当tail把6插入完的时候tail已经完成回绕回到开头了就是head这个位置,发现当head == tail的时候我们的队列就插入满了
现在我们来删除元素,动head,tail不动。
现在发现删除元素删完之后,也是tail == head,这时候问题就来了,到底何时队列存满了数据,还有何时队列是空的,这里我们提出了一个解决方法,再在数组后面新添加一个空间,这个新添加的空间就是用来解决,队列判满这种情况的,这样我们可以把判满的条件改成head == tail+1
为什么这样可以解决问题,tail始终是指向有元素的下一个位置,当我们的插入满了的时候,我们的tail就指向了新开的空间,新开的空间指向的下一个就要回绕到开头,也就是头节点,所以 当tail +1 == head的时候队列就插入满了,而删除还是 当head == tail 不受影响。
当想明白这个问题之后,我们就可以开始写代码了,
代码分析
typedef struct {
int* data;
int head;
int tail;
int k;
} MyCircularQueue;
首先创建我们的整体结构,然后根据题意创建我们的队列
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj-> data = (int*)malloc(sizeof(int)*(k+1));//k+1就代表新增的一个空间
obj-> head = 0;
obj-> tail = 0;
obj->k = k;
return obj;
}
这里力扣给的obj的定义是这样的
到这我们的队列就初始化完成了
下面是插入
插入队列
//插入
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if(myCircularQueueIsFull(obj))//调用判满函数,如果判满就返回false
{
return false;
}
else
{
obj->data[obj->tail] = value;//在尾巴后面插入
obj->tail++;//尾巴位置++
obj->tail = obj->tail%(obj->k+1);
return true;
}
}
这里我们主要说一下这行代码
obj->tail = obj->tail%(obj->k+1);
这里主要是判断回绕,如果不采取判断何时回绕的话,数组就越界了,这里的设计很巧妙,采用取模的方式来判断
这里我们可以看到,当队列空间存放满的时候tail就指向了新开的空间tail就等于6,但插入完成之后ail本身也要++,就变成7,而K+1本身就等于7,7%7 = 0;就返回到数组开头了,完成了回绕,如果tail小于K+1,对K+1取模,就等于tail本身,这时就代表不需要回绕
删除队列
//删除
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))//删除前要判空
{
return false;
}
else
{
obj->head++;//删除直接向前覆盖就行了
obj->head = obj->head%(obj->k+1);
return true;
}
}
删除也和插入一样需要判断回绕问题,同样也是采用取模的方式判断
判满
下面是代码
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return (obj->tail+1)%(obj->k+1) == obj->head;
}
判满也是采用取模的方式进行的,我们还是拿这张图来看
这里的tail在插入最后一个数据之后变成7,7去%k+1,就是0,而0就是head的位置,就代表队列满了,所以通过这个表达式就可以判满。
取队头
/拿头
int myCircularQueueFront(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{
return obj->data[obj->head];
}
}
这里就没什么好说的了,就先判断队列是不是空的,然后返回头就行了。
取队尾数据
int myCircularQueueRear(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{
return obj->tail == 0? obj->data[obj->k]:obj->data[obj->tail-1];
}
}
这里最主要的就是这行代码
return obj->tail == 0? obj->data[obj->k]:obj->data[obj->tail-1];
这里主要判断tail有两种情况,一种是普通的,tail就在队列中间,就像这样,这种我们就直接返回tail-1就行了
还有一种情况是tail完成回绕之后处于0处,这种如果直接减一就变成负数了,就像下面这张图
这里当tail == 0的时候我们就直接让他返回队列的最后一个元素下表位置也就是k。
判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->tail == obj->head;
}
这里就直接可以看tail和head相等不相等。
释放空间
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->data);
free(obj);
}
这里注意不能直接把obj释放了,要先释放他指向的那个数组,在释放它本身
源码
typedef struct {
int* data;
int head;
int tail;
int k;
} MyCircularQueue;
//要前置声明一下
MyCircularQueue* myCircularQueueCreate(int k);
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value);
bool myCircularQueueDeQueue(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);
int myCircularQueueFront(MyCircularQueue* obj);
int myCircularQueueRear(MyCircularQueue* obj);
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj-> data = (int*)malloc(sizeof(int)*(k+1));
obj-> head = 0;
obj-> tail = 0;
obj->k = k;
return obj;
}
//插入
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if(myCircularQueueIsFull(obj))
{
return false;
}
else
{
obj->data[obj->tail] = value;
obj->tail++;
obj->tail = obj->tail%(obj->k+1);
return true;
}
}
//删除
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return false;
}
else
{
obj->head++;
obj->head = obj->head%(obj->k+1);
return true;
}
}
//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return (obj->tail+1)%(obj->k+1) == obj->head;
}
//拿头
int myCircularQueueFront(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{
return obj->data[obj->head];
}
}
int myCircularQueueRear(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{
return obj->tail == 0? obj->data[obj->k]:obj->data[obj->tail-1];
}
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->tail == obj->head;
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->data);
free(obj);
}
/**
* Your MyCircularQueue struct will be instantiated and called as such:
* MyCircularQueue* obj = myCircularQueueCreate(k);
* bool param_1 = myCircularQueueEnQueue(obj, value);
* bool param_2 = myCircularQueueDeQueue(obj);
* int param_3 = myCircularQueueFront(obj);
* int param_4 = myCircularQueueRear(obj);
* bool param_5 = myCircularQueueIsEmpty(obj);
* bool param_6 = myCircularQueueIsFull(obj);
* myCircularQueueFree(obj);
*/