破解「LeetCode 622：设计循环队列」——进阶 FIFO 算法

前端

2024-01-09 04:50:16

对于数据结构和算法爱好者来说，LeetCode 622「设计循环队列」是一个经典的挑战。循环队列是一种独特的线性数据结构，其操作表现基于 FIFO（先进先出）原则，同时队尾被连接在队首之后以形成一个循环。

由于具有循环特性，循环队列在内存分配和读取效率方面优于传统的队列实现。它通常被用于操作系统、网络通信和多任务处理等领域。

掌握循环队列的设计和实现对于算法工程师和软件开发人员来说是一项必备技能。在本文中，我们将带领您深入了解循环队列，并提供清晰的 Java、Python 和 C++ 代码实现。

我们首先从循环队列的概念和基本原理入手，然后详细讲解其设计思路和实现步骤。接下来，我们将提供完整的 Java、Python 和 C++ 代码实现，并通过示例来演示循环队列的使用方法。最后，我们将探讨循环队列在实际应用中的常见场景和优缺点。

无论您是初学者还是经验丰富的开发者，本文将帮助您全面掌握循环队列的知识，并为您的编程能力锦上添花。

循环队列的奥秘

循环队列的工作原理类似于一个圆形跑道，队列中的元素像运动员一样在跑道上循环移动。当队列已满时，新元素将覆盖队首的元素，就像运动员在跑道上超越彼此一样。

循环队列的设计巧妙地利用了数组数据结构，以实现先进先出的特性。数组中预留一定空间作为队列的存储区域，并通过两个指针——队首指针和队尾指针——来管理队列中的元素。队首指针指向队列中第一个元素，而队尾指针指向队列中最后一个元素。

代码实现大放送

为了帮助您更好地理解循环队列的实现，我们提供了三种语言的代码示例：Java、Python 和 C++。

Java 代码：

class CircularQueue {
    private int[] elements;
    private int head;
    private int tail;
    private int size;

    public CircularQueue(int capacity) {
        elements = new int[capacity];
        head = -1;
        tail = -1;
        size = 0;
    }

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

        if (isEmpty()) {
            head = 0;
        }

        tail = (tail + 1) % elements.length;
        elements[tail] = value;
        size++;
    }

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

        int value = elements[head];
        head = (head + 1) % elements.length;
        size--;

        if (isEmpty()) {
            head = -1;
            tail = -1;
        }

        return value;
    }

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

    public boolean isFull() {
        return size == elements.length;
    }

    public int size() {
        return size;
    }
}

Python 代码：

class CircularQueue:
    def __init__(self, capacity):
        self.elements = [None] * capacity
        self.head = -1
        self.tail = -1
        self.size = 0

    def enqueue(self, value):
        if self.isFull():
            raise IndexError("Queue is full")

        if self.isEmpty():
            self.head = 0

        self.tail = (self.tail + 1) % len(self.elements)
        self.elements[self.tail] = value
        self.size += 1

    def dequeue(self):
        if self.isEmpty():
            raise IndexError("Queue is empty")

        value = self.elements[self.head]
        self.head = (self.head + 1) % len(self.elements)
        self.size -= 1

        if self.isEmpty():
            self.head = -1
            self.tail = -1

        return value

    def isEmpty(self):
        return self.size == 0

    def isFull(self):
        return self.size == len(self.elements)

    def size(self):
        return self.size

C++ 代码：

class CircularQueue {
private:
    int* elements;
    int head;
    int tail;
    int size;
    int capacity;

public:
    CircularQueue(int capacity) {
        elements = new int[capacity];
        head = -1;
        tail = -1;
        size = 0;
        this->capacity = capacity;
    }

    ~CircularQueue() {
        delete[] elements;
    }

    void enqueue(int value) {
        if (isFull()) {
            throw std::runtime_error("Queue is full");
        }

        if (isEmpty()) {
            head = 0;
        }

        tail = (tail + 1) % capacity;
        elements[tail] = value;
        size++;
    }

    int dequeue() {
        if (isEmpty()) {
            throw std::runtime_error("Queue is empty");
        }

        int value = elements[head];
        head = (head + 1) % capacity;
        size--;

        if (isEmpty()) {
            head = -1;
            tail = -1;
        }

        return value;
    }

    bool isEmpty() {
        return size == 0;
    }

    bool isFull() {
        return size == capacity;
    }

    int size() {
        return size;
    }
};