做题记录——队列

1. lc622:设计循环队列

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-circular-queue

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

思路：一开始的思路是，给数组分配k个空间，用base和top分别指向头尾的位置，入队则top=(top+1)%k，删除则base=(base+1)%k，队首元素即base所指向的元素，队尾元素即(top+k-1)%k位置的元素【加k是考虑到top为0的特殊情况】，【ps:记得判断队列是否为空或是否为满】，但队列为空时base=top，队列全满时也是base=top，无法区分，因此给数组分配k+1个空间，用size=k+1代替上述的k，则队列全满时的判定条件就为(top+1)%size==base。

代码：

class MyCircularQueue {
private:
    vector<int>q;
    int size;
    int top;
    int base;
public:
    MyCircularQueue(int k) {
        size=k+1;
        q=vector<int>(size);
        base=top=0;
    }
    
    bool enQueue(int value) {
        if(isFull())return false;
        q[top]=value;
        top=(top+1)%size;
        return true;
    }
    
    bool deQueue() {
        if(isEmpty())return false;
        base=(base+1)%size;
        return true;
    }
    
    int Front() {
        if(isEmpty())return -1;
        return q[base];
    }
    
    int Rear() {
        if(isEmpty())return -1;
        return q[((top+size)-1)%size];
    }
    
    bool isEmpty() {
        return base==top;
    }
    
    bool isFull() {
        return (top+1)%size==base;
    }
};

2.lc641:设计循环双端队列

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-circular-deque

题目：设计实现双端队列。

实现 MyCircularDeque 类:

MyCircularDeque(int k) ：构造函数,双端队列最大为 k 。
boolean insertFront():将一个元素添加到双端队列头部。如果操作成功返回 true，否则返回 false。
boolean insertLast():将一个元素添加到双端队列尾部。如果操作成功返回 true，否则返回 false。
boolean deleteFront()：从双端队列头部删除一个元素。如果操作成功返回 true，否则返回 false。
boolean deleteLast()：从双端队列尾部删除一个元素。如果操作成功返回 true，否则返回 false。
int getFront() ：从双端队列头部获得一个元素。如果双端队列为空，返回 -1 。
int getRear() ：获得双端队列的最后一个元素。 如果双端队列为空，返回 -1 。
boolean isEmpty() ：若双端队列为空，则返回 true ，否则返回 false  。
boolean isFull() ：若双端队列满了，则返回 true ，否则返回 false 。

示例 ：

输入
["MyCircularDeque", "insertLast", "insertLast", "insertFront", "insertFront", "getRear", "isFull", "deleteLast", "insertFront", "getFront"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
输出
[null, true, true, true, false, 2, true, true, true, 4]

解释
MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3
circularDeque.insertLast(1);                    // 返回 true
circularDeque.insertLast(2);                    // 返回 true
circularDeque.insertFront(3);                  // 返回 true
circularDeque.insertFront(4);                  // 已经满了，返回 false
circularDeque.getRear();                        // 返回 2
circularDeque.isFull();                            // 返回 true
circularDeque.deleteLast();                    // 返回 true
circularDeque.insertFront(4);                 // 返回 true
circularDeque.getFront();                      // 返回 4

思路：和上面设计循环队列的思路是一样的。

代码：

class MyCircularDeque {
private:
    vector<int>q;
    int size;
    int base;
    int top;
public:
    MyCircularDeque(int k) {
        base=top=0;
        size=k+1;
        q=vector<int>(size);
    }
    
    bool insertFront(int value) {
        if(!isFull()){
            base=(base+size-1)%size;
            q[base]=value;
            return true;
        }
        return false;
    }
    
    bool insertLast(int value) {
        if(!isFull()){
            q[top]=value;
            top=(top+1)%size;
            return true;
        }
        return false;
    }
    
    bool deleteFront() {
        if(!isEmpty()){
            base=(base+1)%size;
            return true;
        }
        return false;
    }
    
    bool deleteLast() {
        if(!isEmpty()){
            top=(top+size-1)%size;
            return true;
        }
        return false;
    }
    
    int getFront() {
        if(!isEmpty()){
            return q[base];
        }
        return -1;
    }
    
    int getRear() {
        if(!isEmpty()){
            return q[(top+size-1)%size];
        }
        return -1;
    }
    
    bool isEmpty() {
        if(base==top)return true;
        return false;
    }
    
    bool isFull() {
        if((top+1)%size==base)return true;
        return false;
    }
};