设计循环队列-C语言实现

题目描述

设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于
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);
*/