数据结构之队列（循环队列）

合集 - 数据结构与算法(24)

1.算法衡量优劣之时间复杂度2023-09-052.数据结构与算法之概念2023-09-013.算法衡量优劣之空间复杂度2023-09-064.数据结构之数组2023-09-065.数据结构之链表2023-09-116.数据结构之栈2023-09-147.N-皇后问题2023-09-198.算术表达式的表示法（即求值法）2023-09-249.算术表达式求值法（表达式求值）之前序表示法求值2023-09-2510.算术表达式求值法（表达式求值）之后序表示法求值2023-09-2711.数据结构之队列（一般队列）2023-10-08

12.数据结构之队列（循环队列）2023-10-11

13.数据结构之队列（双向队列）2023-10-1414.数据结构之树（基本概念）2023-10-2415.数据结构之树（二叉树）2023-10-2916.数据结构之树（Huffman tree(赫夫曼树 / 霍夫曼树 / 哈夫曼树 / 最优二叉树)）2023-10-3117.数据结构之树（二叉树的存储方式之数组）2023-11-0218.数据结构之树（二叉树的存储方式之链表）2023-11-0519.数据结构之树（遍历）2023-11-0520.数据结构之树（二叉运算树）2023-11-0721.数据结构之树（二叉搜索树）2023-11-0822.数据结构之树（线索树）2023-11-1123.数据结构之树（树转化为二叉树也叫二叉化）2023-11-1224.确定唯一二叉树2023-11-12

收起

循环队列

又称为环形队列，有如下4个特点：

• 在循环队列的定义中规定了两个索引指针：front 和 rear。front 指向第一个有效元素的位置，而rear 可以理解为用来记录队尾元素的下一个位置。
• 当队列为空时，front == rear;
• 当队列满时，(rear + 1) % n = front. 这样可以让队列看起来像一个环状结构，并使得 front 和 rear 可以循环使用。
• 队列的大小为 n - 1 个元素（n-1是队列真实的容量），其中一个空位留给判断队列为空的条件。

循环队列是一种特殊的线性表，它的内部用数组来实现。

与普通的队列不同的是，如果队满时再入队一个元素，并不会导致队列溢出，而是继续从队头插入，覆盖原有元素。

相对于链式存储结构的队列，数组实现的循环队列更加高效。

Java

package org.allen.data.structure.queue;

import javax.swing.plaf.synth.SynthOptionPaneUI;

/**
 * 循环队列
 * <pre>
 *     出队：front指向第一个有效元素，删除即可。
 *           注意：
 *               (1)不要吧front直接设置为下标0，防止头尾指针混乱，无法判断队列为空还是已满
 *               (2)当尾指针指向队列的最后一个位置时，再插入一个数据，tail则指回到下标0，重新计算
 *               (3)对尾指针求模运算的结果需要加上队列长度，否则可能越界
 *     入队：rear指向下一个空位，插入数据，更新rear值
 *           注意：由于有空位，所以不会覆盖原始数据
 * </pre>
 */
public class CircularQueue {
//    private int N;// 队列长度
    protected int N;  // 队列长度,是其真实容量 + 1
    private int[] array; // 存放数据的数组
    private int start; // 队列头部
    private int end; // 队列尾部

    public CircularQueue(int capacity) {
        this.N = capacity + 1;
        this.array = new int[N];
        this.start = 0;
        this.end = 0;
    }

    public boolean isEmpty() {
        return start == end;
    }

    public boolean isFull() {
        return (end + 1) % N == start;
    }

    public int size() {
        if (end > start) {
            return end - start;
        } else {
            return N - start + end;
        }
    }

    public Integer peek() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }

        return array[start];
    }

    public void enqueue(int item) {
        if (isFull()) {
            throw new RuntimeException("Queue is full");
        }

        array[end] = item;
        end = (end + 1) % N;
    }

    public int dequeue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }

        int temp = array[start];
        start = (start + 1) % N;

        return temp;
    }

    public static void main(String[] args) {
        CircularQueue circularQueue = new CircularQueue(3);
//        1. 测试队列满
//        circularQueue.enqueue(1);
//        circularQueue.enqueue(2);
//        circularQueue.enqueue(3);
//        circularQueue.enqueue(4);

        circularQueue.enqueue(1);
        circularQueue.enqueue(2);
        circularQueue.enqueue(3);
        System.out.println(circularQueue.size()); // 3
        System.out.println(circularQueue.peek()); // 1
        System.out.println(circularQueue.isFull()); // true
        System.out.println(circularQueue.isEmpty()); // false
        System.out.println(circularQueue.N); // 4

        System.out.println(circularQueue.dequeue());  // 1
        System.out.println(circularQueue.dequeue());  // 2
        System.out.println(circularQueue.dequeue());  // 3
        System.out.println(circularQueue.dequeue());  // 报错 Queue is empty

    }

}

输出：

?

1 2 3 4 5 6 7 8 9 10 11 12

3 1 true false 4 1 2 3 Exception in thread "main" java.lang.RuntimeException: Queue is empty     at org.allen.data.structure.queue.CircularQueue.dequeue(CircularQueue.java:66)     at org.allen.data.structure.queue.CircularQueue.main(CircularQueue.java:95) Disconnected from the target VM, address: '127.0.0.1:57545', transport: 'socket'

　　

Python

 

class MyCircularDeque:
    def __init__(self, k: int):
        self.capacity = k + 1  # 额外空出一个位置作为约定
        self.circularDeque = [0] * (k + 1)
        self.front = 0
        self.rear = 0

    def is_empty(self) -> bool:
        return self.front == self.rear

    def is_full(self) -> bool:
        return (self.rear + 1) % self.capacity == self.front

    def insertFront(self, value: int) -> bool:
        if self.is_full():
            return False
        self.front = (self.front - 1 + self.capacity) % self.capacity
        self.circularDeque[self.front] = value
        return True

    def insertLast(self, value: int) -> bool:
        if self.is_full():
            return False
        self.circularDeque[self.rear] = value
        self.rear = (self.rear + 1) % self.capacity
        return True

    def deleteFront(self) -> bool:
        if self.is_empty():
            return False
        self.front = (self.front + 1) % self.capacity
        return True

    def deleteLast(self) -> bool:
        if self.is_empty():
            return False
        self.rear = (self.rear - 1 + self.capacity) % self.capacity
        return True

    def getFront(self) -> int:
        if self.is_empty():
            return -1
        return self.circularDeque[self.front]

    def getRear(self) -> int:
        if self.is_empty():
            return -1
        return self.circularDeque[self.rear - 1]