leetcode-设计循环队列

题目链接

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

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

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

在设计循环队列时，可以采用数组的结构也可以循环链表的结构，在这里可能很多人会觉得用循环双向链表会更好，但其实试下起来会复杂一些，下面我会通过数组的形式来解答这道题

解题思路：

定义结构体

typedef struct {
    int* data;
    int front;
    int rear;
    int k;
} MyCircularQueue;

首先这个结构体需要一个指针指向一个数组，其中fron是数组数据的起点位置的下标，rear是村粗下一个数据位置的下标，k表示数组容量的大小。如下图所示

可能看到这会有点迷惑，为什么k是4呢？因为在设计这个数组前我们要清楚怎么判断这个数组为空，什么时候为满。

为空的时候很简单当front和rear相等时，则表示为空，像这样：

但如果数组为满的时候，则也是这样：

因此在判断空和满的时候就比较麻烦，因此我们需要采用其他策略，首先第一种解决方案是多加一个size表示计数器，当增加数据时，size+1,减少数据时size-1。第二种方法就是图中所示的多加一个位置空间，当(rear+1)%k+1=front则表示空间满了。

理清思路后就可以开始继续写代码了

判空和判满代码：

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%(obj->k+1) == obj->front;
}

初始化代码：

MyCircularQueue* myCircularQueueCreate(int k) {
    int* obj=(int*)malloc(sizeof(int)*(k+1));
    if(NULL == obj)
    {
        perror("malloc fail");
        return NULL;
    }
    MyCircularQueue* cq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    cq->data=obj;
    cq->front=cq->rear=0;
    cq->k=k;
    return cq;
}

注意：malloc申请的空间个数是k+1个。

插入数据代码：

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //检查是否已满
    bool flag=myCircularQueueIsFull(obj);
    if(flag)
    {
        return false;
    }
    //未满插入数据
    obj->data[obj->rear++]=value;
    obj->rear%=obj->k+1;
    return true;
}

当空间未满插入完数据后，rear需要+1指向下一个数组空间下标但如果不注意细节可能会导致数组越界，例如：

像这种情况，rear+1直接越界了，所以还需每自增一次对rear模与(k+1)，这里的k是4，k+1=5,当rear%5结果为0，刚好可以回到0下边的位置。

删除数据代码:

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //检查是否为空
    bool flag=myCircularQueueIsEmpty(obj);
    if(flag)
    {
        return false;
    }
    //不为空删除数据
    obj->front++;
    obj->front%=obj->k+1;
    return true;
}

数组的删除不用真正的删除空间的数据，因为对数组的访问是通过front下标，所以只用向前移动一次front就可以实现”删除“。

注意：移动frontd和rear移动一样也要注意数组越界问题。

获取队首元素代码：

int myCircularQueueFront(MyCircularQueue* obj) {
    bool flag=myCircularQueueIsEmpty(obj);
    if(flag)
    {
        return -1;
    }
    else
    {
        return obj->data[obj->front];
    }
}

获取队首元素比较简单，front的值就是队首元素的下标。

获取队尾元素代码：

int myCircularQueueRear(MyCircularQueue* obj) {
    bool falg=myCircularQueueIsEmpty(obj);
    if(falg)
    {
        return -1;
    }
    else
    {
        int index=obj->rear-1;
        index=(index+obj->k+1)%(obj->k+1);
        return obj->data[index];
    }
}

我们知道rear是队尾元素的下一个位置所以rear-1就表示队尾元素的下标，但如果只这么想又会出问题，例如下图：

在这种情况下直接-1会导致数组越界，为了避免这样我们需要这样(rear-1+(k+1)）%(k+1) 进行这样的一步操作后rear=4，刚好就可以指针正确的位置。