每日一练：LeeCode-641. 设计循环双端队列【设计】

本文是力扣LeeCode-641. 设计循环双端队列 学习与理解过程，本文仅做学习之用，对本题感兴趣的小伙伴可以出门左拐LeeCode。

设计实现双端队列。

实现 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 。

示例 1：

输入
[“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

提示：
1 <= k <= 1000
0 <= value <= 1000
insertFront, insertLast, deleteFront, deleteLast, getFront, getRear, isEmpty, isFull 调用次数不大于 2000 次

思路

思路参考leeCode博主liweiwei1419，做这道题前，可以先回顾一下 LeeCode-622. 设计循环队列

1、定义循环变量 front 和 rear 。一直保持这个定义，到底是先赋值还是先移动指针就很容易想清楚了。

• front：指向队列头部第 1 个有效数据的位置；
• rear：指向队列尾部（即最后 1 个有效数据）的 下一个位置，即下一个从队尾入队元素的位置。
  说明：这个定义是依据「动态数组」的定义模仿而来。

2、为了避免「队列为空」和「队列为满」的判别条件冲突，我们有意浪费了一个位置；浪费一个位置是指：循环数组中任何时刻一定至少有一个位置不存放有效元素。

• 判别队列为空的条件是：front == rear;
• 判别队列为满的条件是：(rear + 1) % capacity == front;。可以这样理解，当 rear 循环到数组的前面，要从后面追上 front，还差一格的时候，判定队列为满。

3、因为有循环的出现，要特别注意处理数组下标可能越界的情况。

• 指针后移的时候，下标 +1，要取模；
• 指针前移的时候，为了循环到数组的末尾，需要先加上数组的长度，然后再对数组长度取模（注意：0-1的出现，越界）。

class MyCircularDeque {
    private int capacity;
    private int[] arr;
    private int front,rear;

    public MyCircularDeque(int k) {
        capacity = k+1;
        arr = new int[capacity];
        front = 0;  // 头部指向第 1 个存放元素的位置;插入时，先减，再赋值;删除时，索引 +1（注意取模）
        rear = 0;   // 尾部指向下一个插入元素的位置;插入时，先赋值，再加;删除时，索引 -1（注意取模）
    }
    
    public boolean insertFront(int value) {
        if(isFull())return false;
        front = (front-1+capacity)%capacity;
        arr[front] = value;
        return true;
    }
    
    public boolean insertLast(int value) {
        if(isFull())return false;
        
        arr[rear] = value;  //先这步很重要
        rear = (rear+1)%capacity;
        return true;
    }
    
    public boolean deleteFront() {
        if(isEmpty())return false;    
        front = (front+1)%capacity; // front 被设计在数组的开头，所以是 +1
        return true;
    }
    
    public boolean deleteLast() {
        if(isEmpty())return false;
        rear = (rear-1+capacity)%capacity;  // rear 被设计在数组的末尾，所以是 -1
        return true;
    }
    
    public int getFront() {
        if(isEmpty())return -1;
        return arr[front];
    }
    
    public int getRear() {
        if(isEmpty()){
            return -1;
        }
        return arr[(rear-1+capacity)%capacity]; // 当 rear 为 0 时防止数组越界
    }
    
    public boolean isEmpty() {
        return front == rear;
    }
    
    public boolean isFull() {
        return (rear+1)%capacity == front;  // 这个设计是非常典中典的做法
    }
}

/**
 * Your MyCircularDeque object will be instantiated and called as such:
 * MyCircularDeque obj = new MyCircularDeque(k);
 * boolean param_1 = obj.insertFront(value);
 * boolean param_2 = obj.insertLast(value);
 * boolean param_3 = obj.deleteFront();
 * boolean param_4 = obj.deleteLast();
 * int param_5 = obj.getFront();
 * int param_6 = obj.getRear();
 * boolean param_7 = obj.isEmpty();
 * boolean param_8 = obj.isFull();
 */

大佬们有更好的方法，请不吝赐教，谢谢。