数据结构———队列

目录

1.基本概念

2.队列常用操作

3.队列的实现

3.1数组实现

3.2链表实现

队列的典型应用

---

1.基本概念

定义：
队列是一种特殊的线性表，它只允许在一端进行插入操作，在另一端进行删除操作。
插入的一端称为队尾（Rear），删除的一端称为队头（Front）。
操作：
入队（Enqueue）：在队尾添加一个新元素。
出队（Dequeue）：从队头移除一个元素。
查看队头元素（Front）：获取队头元素而不移除它。
查看队尾元素（Rear）：获取队尾元素而不移除它。
判空（IsEmpty）：检查队列是否为空。
长度（Size）：返回队列中的元素数量。
特性：
先进先出（FIFO）：队列遵循先进先出的原则，即最先加入队列的元素将是最先被移除的。
顺序存储：队列可以使用数组或链表实现，其中数组实现通常固定大小，而链表实现可以动态调整大小。

2.队列常用操作

队列的常见操作如表 5-2 所示。需要注意的是，不同编程语言的方法名称可能会有所不同。我们在此采用与栈相同的方法命名。

表 5-2   队列操作效率

我们可以直接使用编程语言中现成的队列类：

/* 初始化队列 */
Queue<Integer> queue = new LinkedList<>();
 
/* 元素入队 */
queue.offer(1);
queue.offer(3);
queue.offer(2);
queue.offer(5);
queue.offer(4);
 
/* 访问队首元素 */
int peek = queue.peek();
 
/* 元素出队 */
int pop = queue.poll();
 
/* 获取队列的长度 */
int size = queue.size();
 
/* 判断队列是否为空 */
boolean isEmpty = queue.isEmpty();

3.队列的实现

3.1数组实现

数组实现的队列通常有一个固定的大小，需要额外处理队满的情况。（将数组替换成动态数组）

在数组中删除首元素的时间复杂度为 O(n) ，这会导致出队操作效率较低。然而，我们可以采用以下巧妙方法来避免这个问题。

我们可以使用一个变量 front 指向队首元素的索引，并维护一个变量 size 用于记录队列长度。定义 rear = front + size ，这个公式计算出的 rear 指向队尾元素之后的下一个位置。

基于此设计，数组中包含元素的有效区间为 [front, rear - 1]，各种操作的实现方法下所示。

• 入队操作：将输入元素赋值给 rear 索引处，并将 size 增加 1 。
• 出队操作：只需将 front 增加 1 ，并将 size 减少 1 。

可以看到，入队和出队操作都只需进行一次操作，时间复杂度均为 O(1)。

public class ArrayQueue {
    private int front;
    private int rear;
    private int[] queue;
    private final int capacity;
 
    public ArrayQueue(int size) {
        this.capacity = size;
        this.queue = new int[size];
        this.front = -1;
        this.rear = -1;
    }
 
    // 入队
    public boolean enqueue(int item) {
        if (isFull()) {
            return false;
        }
        if (isEmpty()) {
            front = 0;
        }
        rear++;
        if (rear == capacity) {
            rear = 0;
        }
        queue[rear] = item;
        return true;
    }
 
    // 出队
    public int dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        int item = queue[front];
        if (front == rear) {
            front = -1;
            rear = -1;
        } else {
            front++;
            if (front == capacity) {
                front = 0;
            }
        }
        return item;
    }
 
    // 查看队头元素
    public int peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return queue[front];
    }
 
    // 判空
    public boolean isEmpty() {
        return front == -1;
    }
 
    // 判满
    public boolean isFull() {
        return (rear + 1) % capacity == front;
    }
}

3.2链表实现

链表实现：使用单链表或双链表来存储队列中的元素，同样通过两个指针来跟踪队头和队尾。

链表实现的队列可以动态扩展，不需要担心队满的问题。

public class LinkedListQueue<T> {
    private Node<T> front;
    private Node<T> rear;
    private int size;
 
    private static class Node<T> {
        T data;
        Node<T> next;
 
        Node(T data) {
            this.data = data;
        }
    }
 
    public LinkedListQueue() {
        front = null;
        rear = null;
        size = 0;
    }
 
    // 入队
    public void enqueue(T item) {
        Node<T> newNode = new Node<>(item);
        if (isEmpty()) {
            front = newNode;
        } else {
            rear.next = newNode;
        }
        rear = newNode;
        size++;
    }
 
    // 出队
    public T dequeue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        T item = front.data;
        front = front.next;
        if (front == null) {
            rear = null;
        }
        size--;
        return item;
    }
 
    // 查看队头元素
    public T peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return front.data;
    }
 
    // 判空
    public boolean isEmpty() {
        return front == null;
    }
 
    // 获取队列大小
    public int size() {
        return size;
    }
}

队列的典型应用

1. 异步处理：当一个系统需要执行一些耗时的任务时，可以将这些任务放入队列中，然后由后台进程或线程池来处理这些任务。这种方式可以避免阻塞主线程，提高系统的响应速度。例如，用户注册后发送欢迎邮件或短信，这些操作可以放入队列中异步处理。
2. 应用解耦：在分布式系统中，不同的服务之间通过消息队列进行通信，可以降低服务间的依赖关系，提高系统的可维护性和可扩展性。比如，订单服务和库存服务之间可以通过消息队列传递订单状态更新的消息。
3. 流量削锋：当系统在短时间内接收大量请求时，可以使用队列来缓存这些请求，避免直接将压力传递给后端服务，从而保护后端服务免受瞬时高并发的影响。例如，网站在促销活动期间可能会出现大量的访问请求，可以使用队列来平滑这些请求。
4. 消息通讯：在多线程或多进程环境中，队列可以作为线程间或进程间通信的工具，确保消息按照一定的顺序被处理。比如，生产者-消费者模型中，生产者将数据放入队列，消费者从队列中取出数据进行处理。
5. 任务调度：在操作系统中，队列用于管理等待执行的任务或进程，确保它们按照一定的顺序被执行。例如，打印队列管理待打印的文档。
6. 银行排队系统：在银行等服务场所，顾客按照到达的顺序排队等候服务，这可以模拟成队列的行为。每当有一个服务窗口可用时，队列中的下一个顾客就会被服务。
7. 缓冲区管理：在网络传输或文件系统中，队列可以用来管理缓冲区中的数据块，确保数据按顺序处理。
8. 模拟和游戏开发：在模拟程序和游戏中，队列可以用来管理事件发生的顺序，确保事件按照预定的时间顺序发生。
9. 编译器和解析器：编译器和解析器中，队列可以用来暂存字符或符号，以便按顺序处理。
10. 资源管理：在多用户系统中，队列可以用来管理对共享资源的访问，比如打印机、磁盘等。