数据结构与算法（四）——队列

二、队列

1、介绍

　　队列是一种先进先出的线性表，它只允许在一端（队尾）进行插入操作，在另一端（队头）进行删除操作。可以用数组或链表来实现，一般用链表来实现，简称为链队列，建立在内存的动态区。

2、队列的顺序存储实现

　　顾名思义，用顺序表的方法实现，通常用数组。队列的顺序储存结构：

　　下面用数组实现队列：
　　思想：队列出队入队动态图：

　　队列的特性：队尾插入，队头删除。那么，一个元素入队列，rear++；一个元素出队列，front++。
　　结论：看图可知
　　判空：起始状态，front == rear == -1，则空队列判定，front == rear。
　　判满：一个元素入队列，rear++，则满队列判定，rear == length() - 1。
　　代码示例：数组实现队列

// 用数组模拟队列
public class MyQueue<T> {
    private T[] elementData;
    private int front;
    private int rear;

    public MyQueue(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = (T[]) new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = (T[]) new Object[]{};
        } else {
            throw new IllegalArgumentException("Illegal Capacity: " +
                    initialCapacity);
        }

        front = -1;
        rear = -1;
    }

    // 入队
    public boolean offer(T e) {
        if (isFull()) {
            System.out.println("队列满,不能添加~");
            return false;
        }
        rear++;
        elementData[rear] = e;
        return true;
    }

    // 出队
    public T poll() {
        if (isEmpty()) {
            throw new RuntimeException("队空,没有任何数据~");
        }
        front++;
        return elementData[front];
    }

    // 读取队头
    public T peek() {
        if (isEmpty()) {
            throw new RuntimeException("队空,没有任何数据~");
        }
        return elementData[front + 1];
    }

    // 判空
    public boolean isEmpty() {
        return front == rear;
    }

    // 判满
    private boolean isFull() {
        return rear == elementData.length - 1;
    }

    // 获取队列元素的个数
    public int size() {
        return rear - front;
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        }

        StringBuilder builder = new StringBuilder();
        builder.append("[");
        for (int i = front + 1; i < rear + 1; i++) {
            builder.append(elementData[i])
                    .append(",");
        }
        // 去掉最后一个,
        builder.deleteCharAt(builder.length() - 1);
        builder.append("]");

        return builder.toString();
    }
}

　　代码示例：测试类

// 测试类
public static void main(String[] args) {
    MyQueue<Integer> myQueue = new MyQueue<>(5);
    myQueue.offer(1);
    myQueue.offer(10);
    myQueue.offer(5);
    myQueue.offer(9);
    myQueue.offer(90);
    myQueue.offer(900);

    // 1 10 5 9 90
    System.out.println(myQueue);
    System.out.println("size:" + myQueue.size());

    System.out.println(myQueue.poll());
    System.out.println(myQueue.poll());
    System.out.println(myQueue.poll());
    System.out.println(myQueue.poll());
    System.out.println(myQueue);
    System.out.println("size:" + myQueue.size());

    myQueue.offer(900);
}

// 结果
堆满,不能添加~
[1,10,5,9,90]
size:5
1
10
5
9
[90]
size:1
堆满,不能添加~

　　问题：看图可知
　　假溢出：这样实现的队列，在H、e出队后，继续入队列，会出现"堆满，不能添加元素"或"数组越界"的情况。但事实上，数组索引 0 和 1 的位置已经空了，这叫假溢出。
　　那么，如何解决这个问题呢？
　　很自然的想到，如果此时继续入队列，就将元素放在索引 0 的位置。这就是循环队列。

　　循环队列：

　　为解决假溢出，将数组的首尾相接，模拟出来的逻辑上的循环，容量是固定的。循环队列出队入队动态图：

　　特别注意：①这里修改了front、rear的含义，起始状态，front == rear == 0。②上图是一个循环队列，请脑补一下，将他们首尾相接。所以上图，后两图rear == 0。
　　为了让小伙伴方便看的清楚，下面给出一个上图首尾相接的图。
　　思想：

　　由队列的特性：队尾插入，队头删除。那么，一个元素入队列，rear++；一个元素出队列，front++。
　　问题：队空（图a）：front == rear == 0。队满（图d1）：front == rear。那么，队空和队满就无法判断。
　　解决方案：牺牲一个存储单元（图d2），即队列最后一个存储单元不用。

　　结论：看图可知

　　判空：起始状态，front == rear == 0，则空队列判定，front == rear。
　　判满：一个元素入队列，rear++，则满队列判定，(rear + 1) % length() == front。
　　队列长度：队列元素的个数，(rear - front + length()) % length()。
　　代码示例：数组实现循环队列

// 用数组模拟循环队列
public class MyCircleQueue<T> {
    private T[] elementData;
    private int front;
    private int rear;

    public MyCircleQueue(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = (T[]) new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = (T[]) new Object[]{};
        } else {
            throw new IllegalArgumentException("Illegal Capacity: " +
                    initialCapacity);
        }

        front = 0;
        rear = 0;
    }

    // 入队
    public boolean offer(T e) {
        if (isFull()) {
            System.out.println("队列满,不能添加~");
            return false;
        }
        elementData[rear] = e;
        rear = (rear + 1) % elementData.length;
        return true;
    }

    // 出队
    public T poll() {
        if (isEmpty()) {
            throw new RuntimeException("队空,没有任何数据~");
        }
        final T t = elementData[front];
        front = (front + 1) % elementData.length;

        return t;
    }

    // 读取队头
    public T peek() {
        if (isEmpty()) {
            throw new RuntimeException("队空,没有任何数据~");
        }
        return elementData[front];
    }

    // 判空
    public boolean isEmpty() {
        return front == rear;
    }

    // 判满
    private boolean isFull() {
        return (rear + 1) % elementData.length == front;
    }

    // 获取队列元素的个数
    public int size() {
        return (rear - front + elementData.length) % elementData.length;
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        }

        StringBuilder builder = new StringBuilder();
        builder.append("[");
        // 从front开始遍历，遍历 size() 个元素
        for (int i = front; i < front + size(); i++) {
            builder.append(elementData[i % elementData.length])
                    .append(",");
        }
        // 去掉最后一个,
        builder.deleteCharAt(builder.length() - 1);
        builder.append("]");

        return builder.toString();
    }
}

　　代码示例：测试类

// 测试类
public static void main(String[] args) {
    MyCircleQueue<Integer> myQueue = new MyCircleQueue<>(6);
    myQueue.offer(1);
    myQueue.offer(10);
    myQueue.offer(5);
    myQueue.offer(9);
    myQueue.offer(90);

    // 1 10 5 9 90
    System.out.println(myQueue);
    System.out.println("size:" + myQueue.size());
    myQueue.offer(900);

    System.out.println(myQueue.poll());
    System.out.println(myQueue.poll());
    System.out.println(myQueue.poll());
    System.out.println(myQueue.poll());
    System.out.println(myQueue);
    System.out.println("size:" + myQueue.size());

    // 可以继续入队数据
    myQueue.offer(900);
    System.out.println(myQueue);
}

// 结果
[1,10,5,9,90]
size:5
队列满,不能添加~
1
10
5
9
[90]
size:1
[90,900]

3、队列的链式存储实现

　　顾名思义，用链表的方法实现，通常用单链表。队列的链式储存结构：

　　下面用链表实现队列：
　　代码示例：带头结点的链表实现队列

public class MyLinkedQueue<E> {
    // 头指针.不变
    private final Node<E> front;

    // 尾指针
    private Node<E> rear;

    public MyLinkedQueue() {
        // 初始化头结点
        front = new Node<>(null);
        rear = front;
    }

    // 入队
    public boolean offer(E e) {
        Node<E> node = new Node<>(e);

        rear.next = node;
        rear = node;

        return true;
    }

    // 出队
    public E poll() {
        Node<E> temp = front.next;

        if (temp == null) {
            return null;
        }

        // 出队.删除队头元素
        front.next = front.next.next;
        if (isEmpty()) {
            rear = front;
        }

        return temp.item;
    }

    // 获取.队头
    public E peek() {
        Node<E> temp = front.next;

        if (temp != null) {
            return temp.item;
        }
        return null;
    }

    // 空队列时,front和rear都指向头结点.
    public boolean isEmpty() {
        return front.next == null;
    }

    /**
     * 打印队列
     */
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();

        Node<E> temp = front.next;

        while (temp != null) {
            builder.append(temp.item)
                    .append(",");
            temp = temp.next;
        }

        if (builder.length() == 0) {
            return "[]";
        }

        builder.insert(0, "[");
        // 去掉最后一个,
        builder.deleteCharAt(builder.length() - 1);
        builder.append("]");

        return builder.toString();
    }

    /**
     * 队列的结点
     */
    private static class Node<E> {
        public E item;
        public Node<E> next;

        public Node(E item) {
            this.item = item;
        }
    }

}

　　代码示例：测试类

// 测试类
public static void main(String[] args) {
    MyLinkedQueue<Integer> queue = new MyLinkedQueue<>();

    // 添加.入队
    queue.offer(9);
    queue.offer(5);
    queue.offer(2);
    queue.offer(7);
    System.out.println(queue);

    // 出队
    final Integer poll = queue.poll();
    System.out.println(poll);
    System.out.println(queue);

    // 获取.队头
    final Integer peek = queue.peek();
    System.out.println(peek);
    System.out.println(queue);
}

// 结果
[9,5,2,7]
9
[5,2,7]
5
[5,2,7]