队列题目：设计循环双端队列

题目

标题和出处

标题：设计循环双端队列

出处：641. 设计循环双端队列

难度

6 级

题目描述

要求

设计你的循环双端队列实现。

实现 $\text{MyCircularDeque}$ 类：

• $\text{MyCircularDeque(k)}$ 初始化对象，将循环双端队列的大小设为 $\text{k}$。
• $\text{boolean insertFront(int value)}$ 向循环双端队列的队首插入一个元素。如果操作成功则返回 $\text{true}$，否则返回 $\text{false}$。
• $\text{boolean insertLast(int value)}$ 向循环双端队列的队尾插入一个元素。如果操作成功则返回 $\text{true}$，否则返回 $\text{false}$。
• $\text{boolean deleteFront()}$ 从循环双端队列的队首删除一个元素。如果操作成功则返回 $\text{true}$，否则返回 $\text{false}$。
• $\text{boolean deleteLast()}$ 从循环双端队列的队尾删除一个元素。如果操作成功则返回 $\text{true}$，否则返回 $\text{false}$。
• $\text{int getFront()}$ 获取队首元素。如果双端队列为空，返回 $\text{-1}$。
• $\text{int getRear()}$ 获取队尾元素。如果双端队列为空，返回 $\text{-1}$。
• $\text{boolean isEmpty()}$ 如果循环双端队列为空则返回 $\text{true}$，否则返回 $\text{false}$。
• $\text{boolean isFull()}$ 如果循环双端队列已满则返回 $\text{true}$，否则返回 $\text{false}$。

你不允许使用内置的队列数据结构。

示例

示例 1：

输入：
$\text{["MyCircularDeque", "insertLast", "insertLast", "insertFront", "insertFront", "getRear", "isFull", "deleteLast", "insertFront", "getFront"]}$
$\text{[[3], [1], [2], [3], [4], [], [], [], [4], []]}$
输出：
$\text{[null, true, true, true, false, 2, true, true, true, 4]}$
解释：
$\text{MyCircularDeque myCircularDeque = new MyCircularDeque(3);}$
$\text{myCircularDeque.insertLast(1);}$ // 返回 $\text{True}$
$\text{myCircularDeque.insertLast(2);}$ // 返回 $\text{True}$
$\text{myCircularDeque.insertFront(3);}$ // 返回 $\text{True}$
$\text{myCircularDeque.insertFront(4);}$ // 返回 $\text{False}$，双端队列已满
$\text{myCircularDeque.getRear();}$ // 返回 $\text{2}$
$\text{myCircularDeque.isFull();}$ // 返回 $\text{True}$
$\text{myCircularDeque.deleteLast();}$ // 返回 $\text{True}$
$\text{myCircularDeque.insertFront(4);}$ // 返回 $\text{True}$
$\text{myCircularDeque.getFront();}$ // 返回 $\text{4}$

数据范围

• $\text{1}\le \text{k}\le \text{1000}$
• $\text{0}\le \text{value}\le \text{1000}$
• 最多调用 $\text{3000}$ 次 $\text{insertFront}$、$\text{insertLast}$、$\text{deleteFront}$、$\text{deleteLast}$、$\text{getFront}$、$\text{getRear}$、$\text{isEmpty}$ 和 $\text{isFull}$

前言

这道题和「设计循环队列」相似，区别在于这道题需要设计的结构是双端队列，双端队列支持在队首和队尾添加元素和删除元素。

循环双端队列的实现有两种方式，分别是基于数组和基于双向链表。数组和双向链表本身并不是环形结构，在实现时需要模拟环形结构。

解法一

思路和算法

使用数组实现循环双端队列时，需要维护数组、循环双端队列的大小（即最多允许存储的元素个数）、队首下标、队尾下标和循环双端队列中的元素个数。其中，数组的长度为循环双端队列的大小，队首下标表示队首元素所在位置的下标，队尾下标表示队尾元素的后一个位置的下标。

构造方法中，将数组 $\text{deque}$ 初始化为长度 $k$ 的数组，将循环双端队列的容量 $\text{capacity}$ 设为 $k$，将队首下标 $\text{head}$ 和队尾下标 $\text{tail}$ 都初始化为 $0$，将元素个数 $\text{size}$ 初始化为 $0$。

对于在队首添加元素操作，首先判断循环双端队列是否已满，如果循环双端队列已满则返回 $\text{false}$，如果循环双端队列未满则执行在队首添加元素操作。

1. 令 $\text{head}:=(\text{head}+\text{capacity}-1)\mathrm{mod}\text{capacity}$，取余运算确保 $\text{head}$ 在下标范围内。

2. 令 $\text{deque}[\text{head}]:=\text{value}$。

3. 令 $\text{size}:=\text{size}+1$。

4. 返回 $\text{true}$。

由于 $\text{head}$ 是队首元素所在位置的下标，因此需要首先更新 $\text{head}$ 然后将 $\text{value}$ 赋给 $\text{deque}[\text{head}]$。

对于在队尾添加元素操作，首先判断循环双端队列是否已满，如果循环双端队列已满则返回 $\text{false}$，如果循环双端队列未满则执行在队尾添加元素操作。

1. 令 $\text{deque}[\text{tail}]:=\text{value}$。

2. 令 $\text{tail}:=(\text{tail}+1)\mathrm{mod}\text{capacity}$，取余运算确保 $\text{tail}$ 在下标范围内。

3. 令 $\text{size}:=\text{size}+1$。

4. 返回 $\text{true}$。

由于 $\text{tail}$ 是队尾元素的后一个位置的下标，因此需要首先将 $\text{value}$ 赋给 $\text{deque}[\text{tail}]$ 然后更新 $\text{tail}$。

对于在队首删除元素操作，首先判断循环双端队列是否为空，如果循环双端队列为空则返回 $\text{false}$，如果循环双端队列不为空则执行在队首删除元素操作。

1. 令 $\text{head}:=(\text{head}+1)\mathrm{mod}\text{capacity}$，取余运算确保 $\text{head}$ 在下标范围内。

2. 令 $\text{size}:=\text{size}-1$。

3. 返回 $\text{true}$。

对于在队尾删除元素操作，首先判断循环双端队列是否为空，如果循环双端队列为空则返回 $\text{false}$，如果循环双端队列不为空则执行在队尾删除元素操作。

1. 令 $\text{tail}:=(\text{tail}+\text{capacity}-1)\mathrm{mod}\text{capacity}$，取余运算确保 $\text{tail}$ 在下标范围内。

2. 令 $\text{size}:=\text{size}-1$。

3. 返回 $\text{true}$。

对于获取队首元素和获取队尾元素操作，首先判断循环双端队列是否为空，如果循环双端队列为空则返回 $-1$，如果循环双端队列不为空则返回对应下标处的元素。

• 对于获取队首元素操作，返回 $\text{deque}[\text{head}]$。

• 对于获取队尾元素操作，返回 $\text{deque}[(\text{tail}+\text{capacity}-1)\mathrm{mod}\text{capacity}]$。

对于检查循环双端队列是否为空和检查循环双端队列是否已满操作，这两种情况下都有 $\text{head}=\text{tail}$，因此需要根据循环双端队列中的元素个数判断。

• 当且仅当 $\text{size}=0$ 时，循环双端队列为空。

• 当且仅当 $\text{size}=\text{capacity}$ 时，循环双端队列已满。

检查循环双端队列是否为空和检查循环双端队列是否已满操作可以在其余的操作中复用。具体而言，在 $\text{insertFront}$ 和 $\text{insertLast}$ 中调用 $\text{isFull}$ 判断循环双端队列是否已满，在 $\text{deleteFront}$、$\text{deleteLast}$、$\text{getFront}$ 和 $\text{getRear}$ 中调用 $\text{isEmpty}$ 判断循环双端队列是否为空。

代码

class MyCircularDeque {
    int[] deque;
    int capacity;
    int head;
    int tail;
    int size;

    public MyCircularDeque(int k) {
        deque = new int[k];
        capacity = k;
        head = 0;
        tail = 0;
        size = 0;
    }
    
    public boolean insertFront(int value) {
        if (isFull()) {
            return false;
        }
        head = (head + capacity - 1) % capacity;
        deque[head] = value;
        size++;
        return true;
    }
    
    public boolean insertLast(int value) {
        if (isFull()) {
            return false;
        }
        deque[tail] = value;
        tail = (tail + 1) % capacity;
        size++;
        return true;
    }
    
    public boolean deleteFront() {
        if (isEmpty()) {
            return false;
        }
        head = (head + 1) % capacity;
        size--;
        return true;
    }
    
    public boolean deleteLast() {
        if (isEmpty()) {
            return false;
        }
        tail = (tail + capacity - 1) % capacity;
        size--;
        return true;
    }
    
    public int getFront() {
        if (isEmpty()) {
            return -1;
        }
        return deque[head];
    }
    
    public int getRear() {
        if (isEmpty()) {
            return -1;
        }
        return deque[(tail + capacity - 1) % capacity];
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public boolean isFull() {
        return size == capacity;
    }
}

复杂度分析

• 时间复杂度：构造方法和每一项操作的时间复杂度是 $O(1)$。

• 空间复杂度：$O(k)$，其中 $k$ 是循环双端队列的大小。

解法二

思路和算法

由于循环双端队列需要支持在队首和队尾添加元素和删除元素，因此使用双向链表。使用双向链表实现循环双端队列时，需要维护队首结点、队尾结点、循环双端队列的大小（即最多允许存储的元素个数）和循环双端队列中的元素个数。

构造方法中，将队首结点 $\text{head}$ 和队尾结点 $\text{tail}$ 初始化为 $\text{null}$，将循环双端队列的容量 $\text{capacity}$ 设为 $k$，将元素个数 $\text{size}$ 初始化为 $0$。

对于在队首添加元素操作，首先判断循环双端队列是否已满，如果循环双端队列已满则返回 $\text{false}$，如果循环双端队列未满则执行在队首添加元素操作。

1. 创建新结点 $\text{node}$，新结点的值为 $\text{value}$。

2. 如果循环双端队列为空，则令 $\text{head}:=\text{node}$ 和 $\text{tail}:=\text{node}$；如果循环双端队列不为空，则令 $\text{head}.\text{prev}:=\text{node}$ 和 $\text{node}.\text{next}:=\text{head}$，然后令 $\text{head}:=\text{node}$。

3. 令 $\text{head}.\text{prev}:=\text{tail}$ 和 $\text{tail}.\text{next}:=\text{head}$，形成循环结构。

4. 令 $\text{size}:=\text{size}+1$。

5. 返回 $\text{true}$。

对于在队尾添加元素操作，首先判断循环双端队列是否已满，如果循环双端队列已满则返回 $\text{false}$，如果循环双端队列未满则执行在队尾添加元素操作。

1. 创建新结点 $\text{node}$，新结点的值为 $\text{value}$。

2. 如果循环双端队列为空，则令 $\text{head}:=\text{node}$ 和 $\text{tail}:=\text{node}$；如果循环双端队列不为空，则令 $\text{tail}.\text{next}:=\text{node}$ 和 $\text{node}.\text{prev}:=\text{tail}$，然后令 $\text{tail}:=\text{node}$。

3. 令 $\text{head}.\text{prev}:=\text{tail}$ 和 $\text{tail}.\text{next}:=\text{head}$，形成循环结构。

4. 令 $\text{size}:=\text{size}+1$。

5. 返回 $\text{true}$。

对于在队首删除元素操作，首先判断循环双端队列是否为空，如果循环双端队列为空则返回 $\text{false}$，如果循环双端队列不为空则执行在队首删除元素操作。

1. 令 $\text{head}:=\text{head}.\text{next}$。

2. 令 $\text{head}.\text{prev}:=\text{tail}$ 和 $\text{tail}.\text{next}:=\text{head}$，形成循环结构。

3. 令 $\text{size}:=\text{size}-1$。

4. 返回 $\text{true}$。

对于在队尾删除元素操作，首先判断循环双端队列是否为空，如果循环双端队列为空则返回 $\text{false}$，如果循环双端队列不为空则执行在队尾删除元素操作。

1. 令 $\text{tail}:=\text{tail}.\text{prev}$。

2. 令 $\text{head}.\text{prev}:=\text{tail}$ 和 $\text{tail}.\text{next}:=\text{head}$，形成循环结构。

3. 令 $\text{size}:=\text{size}-1$。

4. 返回 $\text{true}$。

对于获取队首元素和获取队尾元素操作，首先判断循环双端队列是否为空，如果循环双端队列为空则返回 $-1$，如果循环双端队列不为空则返回对应结点的值。

• 对于获取队首元素操作，返回 $\text{head}.\text{value}$。

• 对于获取队尾元素操作，返回 $\text{tail}.\text{value}$。

对于检查循环双端队列是否为空和检查循环双端队列是否已满操作，需要根据循环双端队列中的元素个数判断。

• 当且仅当 $\text{size}=0$ 时，循环双端队列为空。

• 当且仅当 $\text{size}=\text{capacity}$ 时，循环双端队列已满。

检查循环双端队列是否为空和检查循环双端队列是否已满操作可以在其余的操作中复用。

代码

class MyCircularDeque {
    Node head;
    Node tail;
    int capacity;
    int size;

    public MyCircularDeque(int k) {
        head = null;
        tail = null;
        capacity = k;
        size = 0;
    }
    
    public boolean insertFront(int value) {
        if (isFull()) {
            return false;
        }
        Node node = new Node(value);
        if (isEmpty()) {
            head = tail = node;
        } else {
            head.prev = node;
            node.next = head;
            head = node;
        }
        head.prev = tail;
        tail.next = head;
        size++;
        return true;
    }
    
    public boolean insertLast(int value) {
        if (isFull()) {
            return false;
        }
        Node node = new Node(value);
        if (isEmpty()) {
            head = tail = node;
        } else {
            tail.next = node;
            node.prev = tail;
            tail = node;
        }
        head.prev = tail;
        tail.next = head;
        size++;
        return true;
    }
    
    public boolean deleteFront() {
        if (isEmpty()) {
            return false;
        }
        head = head.next;
        head.prev = tail;
        tail.next = head;
        size--;
        return true;
    }
    
    public boolean deleteLast() {
        if (isEmpty()) {
            return false;
        }
        tail = tail.prev;
        head.prev = tail;
        tail.next = head;
        size--;
        return true;
    }
    
    public int getFront() {
        if (isEmpty()) {
            return -1;
        }
        return head.value;
    }
    
    public int getRear() {
        if (isEmpty()) {
            return -1;
        }
        return tail.value;
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public boolean isFull() {
        return size == capacity;
    }
}

class Node {
    int value;
    Node prev;
    Node next;

    public Node(int value) {
        this.value = value;
    }
}

复杂度分析

• 时间复杂度：构造方法和每一项操作的时间复杂度是 $O(1)$。

• 空间复杂度：$O(k)$，其中 $k$ 是循环双端队列的大小。