【ShuQiHere】Queues:队列数据结构的全面解析

ShuQiHere

于 2024-09-13 23:26:46 发布

阅读量699

点赞数 11

分类专栏：【ShuQiHere】数据结构与算法文章标签：数据结构 python 开发语言

本文链接：https://blog.csdn.net/wangshuqi666/article/details/142236111

版权

【ShuQiHere】数据结构与算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

【ShuQiHere】

引言 📚

在计算机科学中，队列（Queue） 是一种非常常见且重要的线性数据结构。它遵循 先进先出（FIFO, First In First Out） 原则，即最先进入队列的元素会最早被移除。这一特点使得队列在很多实际应用场景中得以广泛使用，例如操作系统的任务调度、网络请求处理等。本文将详细介绍队列的基本概念、操作方法、应用场景以及其在代码中的实现方式。

队列的定义与特点 🔑

队列可以看作是一种特殊的线性表，它与栈（Stack）类似，但在插入和删除元素的方式上有所不同。栈是 后进先出（LIFO, Last In First Out），而队列则是 先进先出（FIFO）。队列的操作分为两个部分：

入队（Enqueue）：将元素插入到队列的尾部（rear）。
出队（Dequeue）：将元素从队列的头部（front）移除。

队列的这种设计非常适合需要按顺序处理的场景。举个例子，假设我们有一个空队列，依次向其中插入元素 A、B、C，队列将变为：

A -> B -> C

当执行两次出队操作后，A 和 B 将被移除，剩下的队列内容为：

队列的基本操作 ⚙️

队列的主要操作有以下几种：

Enqueue（入队）：向队列的尾部添加元素。
Dequeue（出队）：从队列的头部移除元素。
isEmpty（判空）：检查队列是否为空。
isFull（判满）：检查队列是否已满。

为了帮助理解，以下是用 Java 实现的一个简化版队列代码：

public class Queue {
    private int front, rear, size;
    private int capacity;
    private int[] array;

    // 构造函数，初始化队列
    public Queue(int capacity) {
        this.capacity = capacity;
        front = this.size = 0;
        rear = capacity - 1;
        array = new int[this.capacity];
    }

    // 向队列中添加元素
    public void enqueue(int item) {
        if (isFull()) {
            System.out.println("Queue is full!");
            return;
        }
        rear = (rear + 1) % capacity;  // 循环队列实现
        array[rear] = item;
        size = size + 1;
        System.out.println(item + " enqueued to queue");
    }

    // 从队列中移除元素
    public int dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty!");
            return Integer.MIN_VALUE;
        }
        int item = array[front];
        front = (front + 1) % capacity;  // 循环队列实现
        size = size - 1;
        return item;
    }

    // 检查队列是否已满
    public boolean isFull() {
        return size == capacity;
    }

    // 检查队列是否为空
    public boolean isEmpty() {
        return size == 0;
    }
}

在上述代码中，enqueue 和 dequeue 操作通过环形数组实现，这可以确保在数组使用完之后能够从头开始继续使用空闲位置。

队列的实际应用 💡

队列的先进先出特性使得它非常适用于需要按顺序处理任务的场景。以下是几个经典的应用场景：

打印队列（Printer Queue）：当多个文档提交到打印机时，它们会按提交顺序进行打印。最早提交的文档会最先被处理。
任务调度（Task Scheduling）：操作系统通常使用队列来调度任务，任务按其到达的顺序被执行。
缓冲区（Buffer）：数据流的处理需要按照到达的顺序进行，可以使用队列维护这种顺序，例如网络包的处理、视频流的缓冲等。

队列的实现方式 🛠️

在实际开发中，队列可以通过**数组（Array）或链表（Linked List）**来实现。这两种方式各有优缺点。

数组实现（Array Implementation）🧮

使用数组实现队列时，通常会维护两个指针，分别用于标识队首（front）和队尾（rear）。队列的操作通过这两个指针进行管理：

入队：将元素插入到队尾，队尾指针后移。
出队：从队首移除元素，队首指针后移。

然而，数组实现队列的一个问题是，当队尾指针到达数组末尾时，即使数组前面还有空闲空间，新的元素也无法入队。这时可以使用循环数组（Circular Array）。

循环数组（Circular Array）🔄

循环数组是一种通过在数组末尾和开头之间“循环”来解决空间浪费问题的方法。当队列到达数组末尾时，可以从数组的开头继续插入新元素，这样可以充分利用空间。通过对指针进行取模操作（modulo operation），我们可以实现队列的循环操作。

public class CircularQueue {
    private int front, rear, size;
    private int capacity;
    private int[] array;

    public CircularQueue(int capacity) {
        this.capacity = capacity;
        front = this.size = 0;
        rear = capacity - 1;
        array = new int[this.capacity];
    }

    public void enqueue(int item) {
        if (isFull()) {
            System.out.println("Queue is full!");
            return;
        }
        rear = (rear + 1) % capacity; // 循环数组的入队操作
        array[rear] = item;
        size++;
        System.out.println(item + " enqueued to queue");
    }

    public int dequeue() {
        if (isEmpty()) {
            System.out.println("Queue is empty!");
            return Integer.MIN_VALUE;
        }
        int item = array[front];
        front = (front + 1) % capacity; // 循环数组的出队操作
        size--;
        return item;
    }

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

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