数据结构和算法-队列

队列是一种线性数据结构，它遵循一种先进先出（First In First Out）的策略，即最先进入队列的元素最先被取出。

常用操作

队列支持以下基本操作：

• enqueue(item)：将元素添加到队列尾部
• dequeue()：从队列头部删除元素并返回
• peek()：返回队列头部元素，但不删除
• isEmpty()：判断队列是否为空
• size()：返回队列的大小

实现方式

队列可以用数组或链表实现。用数组实现的队列，我们需要使用两个指针，一个指向队列头部，一个指向队列尾部。插入元素时，我们将元素添加到队列尾部，并将尾部指针后移；删除元素时，我们从队列头部删除元素，并将头部指针后移。需要注意的是，队列可能会出现溢出和下溢的情况。

以下是用数组实现的队列的代码片段：

public class ArrayQueue<T> {
    private int maxSize; // 队列容量
    private int front; // 队列头部
    private int rear; // 队列尾部
    private T[] array; // 存储队列元素的数组
    
    public ArrayQueue(int capacity) {
        array = (T[]) new Object[capacity];
        maxSize = capacity;
        front = 0;
        rear = -1;
    }
    
    public void enqueue(T item) {
        if (rear == maxSize - 1) {
            throw new RuntimeException("Queue is full");
        }
        array[++rear] = item;
    }
    
    public T dequeue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        T item = array[front++];
        return item;
    }
    
    public T peek() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        T item = array[front];
        return item;
    }
    
    public boolean isEmpty() {
        return front == rear + 1;
    }
    
    public int size() {
        return rear - front + 1;
    }
}

用链表实现的队列，我们只需要维护一个指向队列头部的指针和一个指向队列尾部的指针即可。插入元素时，我们将元素添加到队列尾部，并将尾部指针后移；删除元素时，我们从队列头部删除元素，并将头部指针后移。需要注意的是，链表实现的队列不可能出现溢出和下溢的情况。

以下是用链表实现的队列的代码片段：

public class LinkedQueue<T> {
    private int size; // 队列大小
    private Node<T> head; // 队列头部
    private Node<T> tail; // 队列尾部
    
    public LinkedQueue() {
        size = 0;
        head = null;
        tail = null;
    }
    
    public void enqueue(T item) {
        Node<T> node = new Node<>(item);
        if (tail == null) {
            head = node;
        } else {
            tail.next = node;
        }
        tail = node;
        size++;
    }
    
    public T dequeue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        T item = head.data;
        head = head.next;
        size--;
        return item;
    }
    
    public T peek() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        T item = head.data;
        return item;
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public int size() {
        return size;
    }
    
    private static class Node<T> {
        T data;
        Node<T> next;
        
        public Node(T data) {
            this.data = data;
            this.next = null;
        }
    }
}

应用场景

队列常用于处理一些先来后到的问题，例如：

• 操作系统中进程的调度
• 打印队列中的文档
• 网络数据包的管理
• 基于事件的异步编程
• 广度优先搜索（BFS）等算法中

总结

队列是一种先进先出的线性数据结构，支持插入、删除、查看头部元素、获取队列大小等基本操作。队列可以用数组或链表实现，通过使用队列，我们可以更方便地处理一些先来后到的问题。