思路

先确定什么情况为空，什么情况为满。

这里有两种解决方案，

1.留一个空间空置，当rear+1 == front时 ，则队列为满 （这里我们选用方案一）

2.增加一个size变量记录数据个数，size == 0则为空，size == k则为满

第一部分，确定为空的情况，我们规定：当front == rear时，队列为空（此时rear表示的是尾部元素的下一位，和栈中的top有异曲同工之妙）。

第二部分，确定为满的情况，当rear+1 == front时 ，则队列为满

实现一（用链表实现）

我们先来分析一下链表实现的场景，先给一个单向循环链表

push 1 2 3 4 5，此时达到了满的条件：rear->next == front 

pop 2次 ，front只用往后两个节点即可，并不用修改数据（因为后面继续push会覆盖）

 此时不满，又可以继续push 6 7，rear接着向后移动，并且插入新数据

 这样看起来，是不是链表实现还挺简单的？但是，这里有一个接口就很难受了——获取队尾数据。

有没有解决方法呢？肯定有，只是比较麻烦。 有三种解决方案，第一种双向链表，第二种增加一个rearPrev指针，每次rear往后移时，rearPrev要记录前一个位置，第三种遍历获取队尾数据

那有人可能会说，我可以让rear指向队尾元素，那开头rear就必须指向NULL，又多出了对空指针的判断。所以牵一发而动全身，这里用链表实现可以，但比较麻烦。 

实现二 （用数组实现 ）

那么链表实现比较麻烦，数组实现就简单吗？确实！这里用数组实现队列，代码会简洁不少，所以这里详细讲解用数组实现，有兴趣的小伙伴也可以去实现链表。

同样，先给一个空数组，满足front == rear的条件 

 push 1 2 3 4 5，此时rear+1 == front，达到满的条件。可是，rear+1 ==front是我们假想它是循环的，现实中应该怎么书写判满的条件呢？

假设循环队列存储k个有效数据，此时k == 5，开辟6个空间。  标出下标，那么此时我们可以利用取模，得出（rear+1）%（k+1）== front 的条件，其中k+1是空间个数，此时rear==5，+1为6，取模6，就变为0，就与front相等了（是不是很神奇？）

 

让我们再来看看其他情况 ，我们先pop 3次，让队列可以插入

 push 6 7 8 9，最后一个失败，此时又为满，再来分析一下：rear==2，+1为3，取模6，还是3，正好是front（是不是又验证了一遍我们的判断条件？）

分析了这么久，我们终于要开始写代码了。 

先创建MyCircularQueue结构体，并对其初始化 （这里就省略申请失败的条件，因为oj题基本不会申请失败），注意这里记得数组a开辟k+1个空间

和分析一样，先写出判空和判满的函数 ，有了前面的分析，这里是不是就很好理解了？

空：front == rear

满：（rear+1）%（k+1）==  front

 向循环队列插入数据，先判断队列是否为满，如果不满，在队尾rear插入数据，rear++（不过注意，rear有可能在边界，++要循环回来，所以最后%=（k+1））；如果为满，则返回false，表示插入失败。

 从循环队列删除数据，同样也先判断队列是否为空，如果不空，则front++，再%=（k+1）；如果为空，则表示删除失败，返回false

 获取队头元素，这个也超级简单。先判断是否为空，不为空，则直接返回下标为front的元素；如果为空，则返回-1

 获取队尾数据，关键点来了。我们就是因为链表实现这个功能复杂，才选择了数组，让我们来看看数组是怎样实现这个功能的呢？一般情况，rear如果不在边界，我们就返回下标为rear-1的元素，如果rear刚好在最左边，那就返回下标为k的元素。这里可以用一个条件判断来写代码。

但是，有一种更妙的方法，先判断是否为空，不为空，则返回下标为（rear+k）%（k+1）的元素。这是什么意思呢？其实完整的写是（rear-1+k+1）%（k+1），相当于rear为0是，rear-1为-1，但是此时加上k+1，再取模k+1，就变成了k。（是不是很妙？） 

 最后，就是简单的释放空间，先释放数组空间，再释放队列空间。

完整代码附上：

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


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

    obj->front = obj->rear = 0;
    obj->k = k;
    obj->a = (int*)malloc((k+1)*sizeof(int));

    return obj;
}

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

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (!myCircularQueueIsFull(obj))
    {
        obj->a[obj->rear] = value;
        obj->rear++;
        obj->rear %= (obj->k+1);
        return true;
    }
    return false;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (!myCircularQueueIsEmpty(obj))
    {
        obj->front++;
        obj->front %= (obj->k+1);
        return true;
    }
    return false;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (!myCircularQueueIsEmpty(obj))
    {
        return obj->a[obj->front];
    }
    return -1;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (!myCircularQueueIsEmpty(obj))
    {
        return obj->a[(obj->rear+obj->k)%(obj->k+1)];
    }
    return -1;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    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);
*/