队列及其实现

和栈相反，队列（Queue）是一种先进先出(First In First Out，缩写为FIFO)的线性表。它只允许在表的一端进行插入，而在另一端进行删除元素。这和我们日常生活中的排队是一致的，最早进入队列的元素最早离开。

在队列中，允许插入的一端叫做队尾（rear），允许删除的一端则成为队头（front）。向队尾插入元素称为进队或入队，新元素入队后成为新的队尾元素；从队头删除元素称为离队或出队，其后续元素成为新的队首元素。

1.队列的顺序存储与实现

在队列的顺序存储中，我们可以将队列当作一般的数组加以实现，但这样做的效果并不好。尽管我们可以用一个指针rear来指示队尾，使得enqueue运算可以在O(1)时间内完成，但是在执行dequeue时，为了删除队首元素，必须将数组中其他所有元素都向前移动一个位置，这样，当队列中有n个元素时，dequeue就需要O(n)时间。

为此呢，我们也可以考虑增加一个front指针来指向队首的位置，这样的话删除队首元素只需要将front指针后移即可，如下图所示：

但是这样又有一个问题，就是当rear指针移动到数组最后的时候，这时候队列并没有满，数组的前面还有空余的空间，所以也不宜进行存储再分配来扩大数组空间。

一个比较巧妙的办法是将顺序队列臆造为一个环状的空间，即数组A[0..capacity-1]中的单元不是排成一排，而是围成一个圆环，即A[0]接在A[capacity-1]后面。如下图所示：

上面的数组，我们可以称之为循环数组，而用循环数组实现的队列称为循环队列。我们用front指针指向队首元素所在的单元，用rear指针指向队尾元素所在单元的下一个单元。如上图所示，队首元素存储在数组下标为0的位置，front=0，队尾元素存储在数组下标为2的位置，rear=3。

---

但是，这里又有一个问题，即如何表示满队列和空队列。

举例来说，如下图（b）所示，在该循环队列中，队首元素为e₀，队尾元素为e₃。当e₄、e₅、e₆、e₇相继入队列后，如图（c）所示，队列空间被占满，此时队尾指针rear追上队首指针front，即有rear=front。反之呢，如果从图（b）所示的状态开始，e₀、e₁、e₂、e₃相继出队，则得到空队列，此时队首指针front追上队尾指针rear，所以也有front=rear。

可见，仅凭front=rear是无法判断队列状态是“空”还是“满”的。

解决这个问题有两个处理思路，一种即增加一个变量size，用它表示队列中的元素的个数，通过size的大小即可判断队列是否为满或者空。第二种思路就是少用一个存储单元，当队尾指针的下一个单元就是队首指针所指单元时，则队列已满，停止入队。这样队尾指针就不会追上队首指针，而队列满时就不会有front=rear了，而是需要满足(rear+1) % capacity = front。而队列判空的条件不变，仍是front=rear。

下述代码基于第二种思路，利用循环数组实现了循环队列：

public class ArrayQueue<T> {
    private final int DEFAULT_CAPACITY = 8; // 默认容量
    private T[] elements;// 数组
    private int front;// 队头指针
    private int rear; // 队尾指针

    @SuppressWarnings("unchecked")
    public ArrayQueue() {
        elements = (T[]) new Object[DEFAULT_CAPACITY];
        front = 0;
        rear = 0;
    }

    /**
     * 队列的大小，即队列中元素的个数
     * 
     * @return
     */
    public int size() {
        // 注意负数，-1 % 8 = -1 而不是 7，所以这里要加上elements.length
        return (rear - front + elements.length) % elements.length;
    }

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

    /**
     * 判断队列是否满
     * 
     * @return
     */
    private boolean isFull() {
        return (rear + 1) % elements.length == front;
    }

    /**
     * 入队
     * 
     * @param e
     */
    public void enqueue(T e) {
        if (isFull()) {
            ensureCapacity();
        }
        elements[rear] = e;
        rear = (rear + 1) % elements.length;
    }

    /**
     * 扩充容量
     */
    @SuppressWarnings("unchecked")
    private void ensureCapacity() {
        // 新的数组
        T[] temp = (T[]) new Object[elements.length * 2 + 1];
        int size = size();
        for (int i = 0; i < size; i++) {
            temp[i] = elements[front];
            front = (front + 1) % elements.length;
        }
        front = 0;
        rear = size;
        elements = temp;
    }

    /**
     * 出队
     * 
     * @return
     */
    public T dequeue() {
        if (isEmpty()) {
            // 暂时先抛出这个异常
            throw new RuntimeException();
        }
        T e = elements[front];
        front = (front + 1) % elements.length;
        return e;
    }
}

2.队列的链式存储与实现

队列的链式存储使用单链表来实现。为了方便，这里使用带头结点的单链表。

根据单链表的特点，我们可以选择链表的头部作为队首，尾部作为队尾。

public class LinkedQueue<T> {
    class Node {
        private T data;// 数据域
        private Node next;// 指针域

        public Node() {
            this(null, null);
        }

        public Node(T data, LinkedQueue<T>.Node next) {
            super();
            this.data = data;
            this.next = next;
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }

    private Node front; // 队头指针
    private Node rear; // 队尾指针
    private int size; // 元素个数

    public LinkedQueue() {
        front = new Node();
        rear = front;
        size = 0;
    }

    /**
     * 判空
     * 
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 队列的大小，即元素的个数
     * 
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 入队
     * 
     * @param e
     */
    public void enqueue(T e) {
        Node newNode = new Node(e, null);
        rear.setNext(newNode);
        rear = newNode;
        size++;
    }

    public T dequeue() {
        if (isEmpty()) {
            // 暂时抛出这个异常
            throw new RuntimeException();
        }
        front = front.getNext();
        size--;
        return front.getData();
    }
}

代码使用了size这个成员变量来指示队列的大小。这样，所有的操作都可以在O(1)时间内完成。