队列题目：设计循环队列

题目

标题和出处

标题：设计循环队列

出处：622. 设计循环队列

难度

6 级

题目描述

要求

设计你的循环队列实现。循环队列是一种线性数据结构，其操作基于先进先出原则并且队尾和队首相连以形成一个循环。它也被称为「环形缓冲器」。

循环队列的一个好处是可以利用这个队列之前用过的空间。在一个普通队列中，一旦队列满了，即使在队列前面仍有空间，也不能插入下一个元素。但是使用循环队列，就能使用这些空间去存储新的值。

实现 $\text{MyCircularQueue}$ 类：

• $\text{MyCircularQueue(k)}$ 初始化对象，将队列的大小设为 $\text{k}$。
• $\text{boolean enQueue(int value)}$ 向循环队列插入一个元素。如果操作成功则返回 $\text{true}$。
• $\text{boolean deQueue()}$ 从循环队列中删除一个元素。如果操作成功则返回 $\text{true}$。
• $\text{int Front()}$ 获取队首元素。如果队列为空，返回 $\text{-1}$。
• $\text{int Rear()}$ 获取队尾元素。如果队列为空，返回 $\text{-1}$。
• $\text{boolean isEmpty()}$ 检查循环队列是否为空。
• $\text{boolean isFull()}$ 检查循环队列是否已满。

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

示例

示例 1：

输入：
$\text{["MyCircularQueue", "enQueue", "enQueue", "enQueue", "enQueue", "Rear", "isFull", "deQueue", "enQueue", "Rear"]}$
$\text{[[3], [1], [2], [3], [4], [], [], [], [4], []]}$
输出：
$\text{[null, true, true, true, false, 3, true, true, true, 4]}$
解释：
$\text{MyCircularQueue myCircularQueue = new MyCircularQueue(3);}$
$\text{myCircularQueue.enQueue(1);}$ // 返回 $\text{True}$
$\text{myCircularQueue.enQueue(2);}$ // 返回 $\text{True}$
$\text{myCircularQueue.enQueue(3);}$ // 返回 $\text{True}$
$\text{myCircularQueue.enQueue(4);}$ // 返回 $\text{False}$
$\text{myCircularQueue.Rear();}$ // 返回 $\text{3}$
$\text{myCircularQueue.isFull();}$ // 返回 $\text{True}$
$\text{myCircularQueue.deQueue();}$ // 返回 $\text{True}$
$\text{myCircularQueue.enQueue(4);}$ // 返回 $\text{True}$
$\text{myCircularQueue.Rear();}$ // 返回 $\text{4}$

数据范围

• $\text{1}\le \text{k}\le \text{1000}$
• $\text{0}\le \text{value}\le \text{1000}$
• 最多调用 $\text{3000}$ 次 $\text{enQueue}$、$\text{deQueue}$、$\text{Front}$、$\text{Rear}$、$\text{isEmpty}$ 和 $\text{isFull}$

前言

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

解法一

思路和算法

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

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

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

1. 令 $\text{queue}[\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{false}$，如果循环队列不为空则执行出队操作。

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

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

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

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

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

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

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

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

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

检查循环队列是否为空和检查循环队列是否已满操作可以在其余的操作中复用。具体而言，在 $\text{enQueue}$ 中调用 $\text{isFull}$ 判断循环队列是否已满，在 $\text{deQueue}$、$\text{Front}$ 和 $\text{Rear}$ 中调用 $\text{isEmpty}$ 判断循环队列是否为空。

代码

class MyCircularQueue {
    int[] queue;
    int capacity;
    int head;
    int tail;
    int size;

    public MyCircularQueue(int k) {
        queue = new int[k];
        capacity = k;
        head = 0;
        tail = 0;
        size = 0;
    }

    public boolean enQueue(int value) {
        if (isFull()) {
            return false;
        }
        queue[tail] = value;
        tail = (tail + 1) % capacity;
        size++;
        return true;
    }

    public boolean deQueue() {
        if (isEmpty()) {
            return false;
        }
        head = (head + 1) % capacity;
        size--;
        return true;
    }

    public int Front() {
        if (isEmpty()) {
            return -1;
        }
        return queue[head];
    }

    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return queue[(tail + capacity - 1) % capacity];
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean isFull() {
        return size == capacity;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

复杂度分析

• 时间复杂度：构造方法和每一项操作的时间复杂度是 $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{tail}.\text{next}:=\text{node}$，然后令 $\text{tail}:=\text{node}$。

3. 令 $\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{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 MyCircularQueue {
    Node head;
    Node tail;
    int capacity;
    int size;

    public MyCircularQueue(int k) {
        head = null;
        tail = null;
        capacity = k;
        size = 0;
    }

    public boolean enQueue(int value) {
        if (isFull()) {
            return false;
        }
        Node node = new Node(value);
        if (isEmpty()) {
            head = tail = node;
        } else {
            tail.next = node;
            tail = node;
        }
        tail.next = head;
        size++;
        return true;
    }

    public boolean deQueue() {
        if (isEmpty()) {
            return false;
        }
        head = head.next;
        tail.next = head;
        size--;
        return true;
    }

    public int Front() {
        if (isEmpty()) {
            return -1;
        }
        return head.value;
    }

    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return tail.value;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean isFull() {
        return size == capacity;
    }
}

class Node {
    int value;
    Node next;

    public Node(int value) {
        this.value = value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

复杂度分析

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

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