设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满
一)循环队列
设计一个循环对列，重点在于在各项操作中维持数据不变式，即维持对象属性之间的正确关系。
（1）构造函数中定义四个属性：
self._len:队列长度
self._elems:用于记录循环队列元素的列表
self._head:队列中第一个元素的下标
self._num:队列中的元素个数
（2）进队列
在队列尾部加入元素，并是self._num加1，以维持对象属性之间的正确关系。
（3）出队列
只是对列中第一个元素下标的指针后移1，同时将self._num减1。
其余操作容易理解，可参看以下代码。
（4）获取队列首元素
若队列为空，即self._num等于0，返回-1；否则，返回索引self._head中的元素
（5）获取队列尾端元素
若对列为空，返回-1；否则，返回索引(self._head + self._num - 1) % self._len中元素，之所以要进行取模操作，是因为该队列为循环对列，存储队列元素的列表最后一个位置的下一个位置为其首位置
（6）队列为空
self._num为0
（7）队列为满
self._num等于self._len
class MyCircularQueue {
public:
/** Initialize your data structure here. Set the size of the queue to be k. */
vector<int> q;
int p_start,num,fullNum;
MyCircularQueue(int k) {
p_start=0;
num=0;
fullNum=k;
for(int i=0;i<k;i++)
q.push_back(0);
}
/** Insert an element into the circular queue. Return true if the operation is successful. */
bool enQueue(int value) {
if(!isFull())
{
q[(num+p_start)%fullNum]=value;
num++;
return true;
}
return false;
}
/** Delete an element from the circular queue. Return true if the operation is successful. */
bool deQueue() {
if(isEmpty())
return false;
else
{
p_start=(p_start+1)%fullNum;
num--;
return true;
}
}
/** Get the front item from the queue. */
int Front() {
if(isEmpty())
return -1;
else
return q[p_start];
}
/** Get the last item from the queue. */
int Rear() {
if(isEmpty())
return -1;
else
{
return q[(num-1+p_start)%fullNum];
}
}
/** Checks whether the circular queue is empty or not. */
bool isEmpty() {
return num==0;
}
/** Checks whether the circular queue is full or not. */
bool isFull() {
return num==fullNum;
}
};
以下官方解法，感觉不好理解………………
class MyCircularQueue {
private:
vector<int> data;
int head;
int tail;
int size;
public:
/** Initialize your data structure here. Set the size of the queue to be k. */
MyCircularQueue(int k) {
data.resize(k);
head = -1;
tail = -1;
size = k;
}
/** Insert an element into the circular queue. Return true if the operation is successful. */
bool enQueue(int value) {
if (isFull()) {
return false;
}
if (isEmpty()) {
head = 0;
}
tail = (tail + 1) % size;
data[tail] = value;
return true;
}
/** Delete an element from the circular queue. Return true if the operation is successful. */
bool deQueue() {
if (isEmpty()) {
return false;
}
if (head == tail) {
head = -1;
tail = -1;
return true;
}
head = (head + 1) % size;
return true;
}
/** Get the front item from the queue. */
int Front() {
if (isEmpty()) {
return -1;
}
return data[head];
}
/** Get the last item from the queue. */
int Rear() {
if (isEmpty()) {
return -1;
}
return data[tail];
}
/** Checks whether the circular queue is empty or not. */
bool isEmpty() {
return head == -1;
}
/** Checks whether the circular queue is full or not. */
bool isFull() {
return ((tail + 1) % size) == head;
}
};
/**
* Your MyCircularQueue object will be instantiated and called as such:
* MyCircularQueue obj = new MyCircularQueue(k);
* bool param_1 = obj.enQueue(value);
* bool param_2 = obj.deQueue();
* int param_3 = obj.Front();
* int param_4 = obj.Rear();
* bool param_5 = obj.isEmpty();
* bool param_6 = obj.isFull();
*/