设计循环队列（C语言）

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

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

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

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

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);

题目来源（力扣）：设计循环队列

数组实现

【直观图解】
为了符合我们的思考逻辑，我们想象成数组尾元素连到了数组首元素，形成一个闭环：

为了实现循环队列，判空和判满的设计是很重要的。那么具体该如何设计呢？
让循环队列的实际长度比有效长度多1，这样就能区分开 空 和 满 两种状态。

循环队列为空时：

循环队列为满时：

当为空时，front == tail
当为满时，tail + 1 == front 。
当然这只是逻辑上的，实际上还要做取模处理。

【基本思路】
创造循环队列时，实际长度要比有效长度多1。
为了让头尾指针能够在数组内循环起来，需要做取模处理。
由于想象成数组闭环，会更容易理解取模处理。

【代码实现】

typedef struct {
    int* a;
    int front;  // 头指针
    int tail;  // 尾指针
    int k;  // 队列的最大有效元素个数
} MyCircularQueue;

//判空判满函数的声明
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

    cq->a = (int*)malloc(sizeof(int)*(k + 1));  // 申请比有效长度多1的空间
    cq->front = cq->tail = 0;
    cq->k = k;
    return cq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	//先判断是否为满
    if(myCircularQueueIsFull(obj))
        return false; 

    obj->a[obj->tail] = value;
    obj->tail = (obj->tail+1) % (obj->k+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //先判断是否为空
    if(myCircularQueueIsEmpty(obj))
        return false; 

    obj->front = (obj->front+1) % (obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    //先判断是否为空
    if(myCircularQueueIsEmpty(obj))
        return -1; 

    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    //先判断是否为空
    if(myCircularQueueIsEmpty(obj))
        return -1; 

    return obj->a[(obj->tail+obj->k) % (obj->k+1)];
}

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

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

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a = NULL;
    obj->front = obj->tail = obj->k = 0;
    free(obj);
}

由于在myCircularQueueCreate函数中是由外而里地申请空间，所以在myCircularQueueFree函数中要由里而外地释放所申请的空间。

链表实现

链表实现的原理跟数组实现的原理基本一样。为了让头尾指针循环起来，把尾节点和第一个节点链起来，形成循环单链表，构成一个闭环。

【直观图解】

循环队列为空时，

循环队列为满时，

【基本思路】
跟上面用数组实现的类似，在构造循环队列时实际长度要比有效长度多1。
不过鉴于链表本身的特点，判空判满比数组实现的要来得简单。

【代码实现】

typedef struct Node{    
    int val;
    struct Node* next;
}Node;

typedef struct {
    Node* head;
    Node* tail;
} MyCircularQueue;

//判空判满函数的声明
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    cq->head = (Node*)malloc(sizeof(Node));  // 申请比有效长度多1的空间
    Node* cur = cq->head;
    while(k--)
    {
        cur->next = (Node*)malloc(sizeof(Node));
        cur = cur->next;
    }
    cur->next = cq->head;
    cq->tail = cq->head;
    return cq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
        return false;

    obj->tail->val = value;
    obj->tail = obj->tail->next;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return false;

    obj->head = obj->head->next;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;

    return obj->head->val;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;

    Node* rear = obj->head;
    while(rear->next != obj->tail)
    {
        rear = rear->next;
    }
    return rear->val;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;
}


bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->tail->next == obj->head;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    int flag = 0;
    Node* cur = obj->head;
    while(cur != obj->head || flag == 0)  //flag == 0是为了第一次能进入循环而设置的
    {
        Node* next = cur->next;
        free(cur);
        cur = next;
        flag = 1;
    }
    obj->head = obj->tail = NULL;
    free(obj);
}

本专栏
有关链表的题目

其它专栏
有关数组的题目