641. 设计循环双端队列（中等系列）

设计实现双端队列。

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

第一种：Deque双端队列

class MyCircularDeque {

    // 使用双端队列来实现循环双端队列
    Deque<Integer> deque = new LinkedList();
    int size;  // 当前队列中的元素数量
    int limit; // 队列的容量限制

    // 构造函数，初始化队列的容量限制
    public MyCircularDeque(int k) {
        size = 0;
        limit = k;
    }
    
    // 在队头插入元素
    public boolean insertFront(int value) {
        if(isFull()){
            return false; // 队列已满，插入失败
        }else{
            deque.offerFirst(value); // 在队头插入元素
            size++; // 队列大小增���
            return true; // 插入成功
        }
    }
    
    // 在队尾插入元素
    public boolean insertLast(int value) {
         if(isFull()){
            return false; // 队列已满，插入失败
        }else{
            deque.offerLast(value); // 在队尾插入元素
            size++; // 队列大小增加
            return true; // 插入成功
        }
    }
    
    // 删除队头元素
    public boolean deleteFront() {
         if(isEmpty()){
            return false; // 队列为空，删除失败
        }else{
            deque.pollFirst(); // 删除队头元素
            size--; // 队列大小减少
            return true; // 删除成功
        }
    }
    
    // 删除队尾元素
    public boolean deleteLast() {
        if(isEmpty()){
            return false; // 队列为空，删除失败
        }else{
            deque.pollLast(); // 删除队尾元素
            size--; // 队列大小减少
            return true; // 删除成功
        }
    }
    
    // 获取队头元素的值
    public int getFront() {
        if(isEmpty()){
            return -1; // 队列为空，返回特定标志值
        }else{
            return deque.peekFirst(); // 返回队头元素的值
        }
    }
    
    // 获取队尾元素的值
    public int getRear() {
         if(isEmpty()){
            return -1; // 队列为空，返回特定标志值
        }else{
            return deque.peekLast(); // 返回队尾元素的值
        }
    }
    
    // 判断队列是否为空
    public boolean isEmpty() {
        return size == 0; // 队列大小为0时为空
    }
    
    // 判断队列是否已满
    public boolean isFull() {
        return size == limit; // 队列大小等于限制时为已满
    }
}

第二种：自定义数组实现

class MyCircularDeque {

    public int[] deque;  // 循环双端队列的数组
    public int size, r, l, limit;  // 当前大小，右指针，左指针，容量限制

    public MyCircularDeque(int k) {
        deque = new int[k];  // 初始化循环双端队列的数组
        size = r = l = 0;  // 初始化大小、右指针、左指针为0
        limit = k;  // 设置容量限制
    }
    
    // 在队头插入元素
    public boolean insertFront(int value) {
        if (isFull()) {
            return false;  // 如果队列已满，插入失败
        } else {
            if (isEmpty()) {
                l = r = 0;  // 如果队列为空，初始化左右指针为0
                deque[0] = value;  // 在数组的第一个位置插入元素
            } else {
                l = l == 0 ? (limit - 1) : (l - 1);  // 计算新的左指针位置
                deque[l] = value;  // 在新的左指针位置插入元素
            }
            size++;  // 增加队列大小
            return true;  // 插入成功
        }
    }
    
    // 在队尾插入元素
    public boolean insertLast(int value) {
        if (isFull()) {
            return false;  // 如果队列已满，插入失败
        } else {
            if (isEmpty()) {
                l = r = 0;  // 如果队列为空，初始化左右指针��0
                deque[0] = value;  // 在数组的第一个位置插入元素
            } else {
                r = r == limit - 1 ? 0 : (r + 1);  // 计算新的右指针位置
                deque[r] = value;  // 在新的右指针位置插入元素
            }
            size++;  // 增加队列大小
            return true;  // 插入成功
        }
    }
    
    // 删除队头元素
    public boolean deleteFront() {
        if (isEmpty()) {
            return false;  // 如果队列为空，删除失败
        } else {
            l = l == limit - 1 ? 0 : (l + 1);  // 计算新的左指针位置
            size--;  // 减小队列大小
            return true;  // 删除成功
        }
    }
    
    // 删除队尾元素
    public boolean deleteLast() {
        if (isEmpty()) {
            return false;  // 如果队列为空，删除失败
        } else {
            r = r == 0 ? limit - 1 : (r - 1);  // 计算新的右指针位置
            size--;  // 减小队列大小
            return true;  // 删除成功
        }
    }
    
    // 获取队头元素
    public int getFront() {
        if(isEmpty){
            return false; //如果队列为空,返回失败         
        }else{
        return deque[l];  // 返回队头元素
        }
    }
    
    // 获取队尾元素
    public int getRear() {
        if(isEmpty){
            return false; //如果队列为空,返回失败          
        }else{
          return deque[r];  // 返回队尾元素
        }       
    }
    // 判断队列是否为空
    public boolean isEmpty() {
        return size == 0;
    }
    
    // 判断队列是否已满
    public boolean isFull() {
        return size == limit;
    }
}

https://leetcode.cn/problems/design-circular-deque/description/

参考左程云老师算法系列