队列

3. 队列

队列（queue）简称队，和堆栈一样，也是一种运算受限的线性表。其限制只允许在表的一端进行插入，被称为队尾（rear），另外一端只允许删除，被称为队头（front）。向队尾插入元素称为入队或进队，新元素入队后称为新的队尾元素，从队头删除元素称为离队或出队，其后续元素成为新的队头元素。

由于队列的插入和删除操作分别在队列的队尾和队头进行，所以每个元素必然按照进入的顺序离队，也就是先进队的元素先离队，所以队列又被称为先进先出表（First In First Out），简称FIFO。

由于队列是一种特殊的线性表，因此和线性表一样，队列也有两种实现方式，即顺序存储和链式存储。下面分别介绍队列的这两种实现方式。

3.1 队列的顺序存储实现

队列的顺序实现，我们可以把队列当做一般的顺序表用的数组加以实现，但是这样效果并不理想。尽管我们可以在O(1)时间内实现队列的入队操作，但是对于出队操作，删除队头元素以后，所有的元素必须向前移动一个存储单元格，这样，队列 的离队操作的时间复杂度变为O(n）。

另外一种解决办法是由于数据元素在底层数组中的位置是固定的，我们执行插入和删除操作只需要分别将队尾引用+1和将队头引用+1。但是这样又出现了另外一种问题，队列的假溢出，即离队后元素的空间不能使用，但是又没有办法向其中添加元素。

为了重新利用队列底层数组被删除元素所占用的空间，消除可能出现的假溢出现象，可以将顺序队列改为循环队列。

循环队列是收尾相连的队列，当首尾引用到达capacity-1后，再前进以为就将其置为0，从而使被删除元素所占用的空间可以利用。循环队列的实现如下：

import java.util.Arrays;

/**
 * 循环队列的顺序存储实现
 * @author retreatweb
 *
 */
public class SequenceQueue<T> {
    //定义底层数组的默认长度
    private int DEFAULT_SIZE = 10;
    //定义底层数组的容量
    private int capacity;
    //定义一个数组用于保存队列中的元素
    private Object[] elementData;
    //保存队列中元素的个数
    private int front = 0;
    private int rear = 0;

    //以默认数组长度定义空参数构造器
    public SequenceQueue(){
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
    }

    //以一个初始化实例创建队列
    public SequenceQueue(T element){
        this();
        elementData[0] = element;
        rear++;
    }
    /**
     * 以指定数组的长度来初始化队列
     * @param element 队列的第一个元素
     * @param initSize 初始化素组的长度
     */
    public SequenceQueue(T element,int initSize){
        capacity = initSize;
        elementData = new Object[capacity];
        elementData[0] = element;
        rear++;
    }
    /**
     * 获取队列的长度
     * @return
     */
    public int length(){
        if(empty()){
            return 0;
        }else{
            return rear > front ? rear - front : rear + capacity - front;
        }
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean empty() {
        //rear == front且rear处的元素为null
        return rear == front && elementData[rear] == null;
    }
    /**
     * 队列中插入元素
     * @param element 要插入的元素
     */
    public void add(T element){
        if(rear == front && elementData[rear] != null){
            throw new IndexOutOfBoundsException("队列已满！");
        }
        elementData[rear++] = element;
        //如果rear已经到头就转头
        rear = rear == capacity ? 0 : rear; 
    }
    /**
     * 移除队列
     * @return 返回被移除元素
     */
    public T remove(){
        if(empty()){
            throw new IndexOutOfBoundsException("空队列异常！");
        }
        //保留队列front端的元素值
        T oldValue = (T) elementData[front];
        //释放front元素
        elementData[front++] = null;
        front = front == capacity ? 0 : front;
        return oldValue;
    }
    /**
     * 获取队头元素
     * @return 队头元素
     */
    public T peek(){
        if(empty()){
            throw new IndexOutOfBoundsException("空队列异常！");
        }
        return (T) elementData[front];
    }
    /**
     * 清空队列
     */
    public void clear(){
        //将底层数组所有元素置为为null
        Arrays.fill(elementData, null);
        front = 0;
        rear = 0;
    }

    public String toString(){
        if(empty()){
            return "[]";
        }else{
            //如果front<rear则有效元素为front到rear之间的元素
            if(front < rear){
                StringBuilder sb = new StringBuilder("[");
                for (int i = front; i < rear; i++) {
                    sb.append(elementData[i].toString()+",");
                }
                int len = sb.length();
                return sb.delete(len - 2, len).append("]").toString();
            }
            //如果front>=rear则有效元素变为front到capacity和0到rear之间的元素
            else{
                StringBuilder sb = new StringBuilder("[");
                for (int i = front; i < capacity; i++) {
                    sb.append(elementData[i].toString()+",");
                }
                for (int i = 0; i < rear; i++) {
                    sb.append(elementData[i].toString()+",");
                }
                int len = sb.length();
                return sb.delete(len - 2, len).append("]").toString();
            }
        }
    }
}

3.2 队列的链式存储实现

队列的链式存储可以采用单链表实现。链队列理论上允许添加无数个元素，因此不会存在队列满的问题。其实现代码如下：

/**
 * 队列的链式存储实现
 * @author retreatweb
 *
 */
public class LinkQueue<T> {

    /**
     * 定义一个内部类，表示立链栈的节点
     * @author retreatweb
     *
     */
    private class Node{
        //保存节点的数据 
        private T data;
        //指向下个节点的引用
        private Node next;
        //无参构造器
        public Node(){

        }
        //初始化所有属性的构造器
        public Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
    //保存链队列的头节点
    private Node front;
    //保存链队列的尾节点
    private Node rear;
    //保存连队列的元素的个数
    private int size;
    //创建空链队列
    public LinkQueue(){
        front = null;
        rear = null;
    }
    //以指定数据元素创建链队列
    public LinkQueue(T element){
        front = new Node(element,null);
        rear = front;
        size++;
    }
    /**
     * 获得链队列的长度
     * @return 返回链队列的元素的个数
     */
    public int length(){
        return size;
    }
    /**
     * 入队
     * @param element 要入队的元素
     */
    public void add(T element){
        //如果链队列为空
        if(front == null){
            front = new Node(element,null);
            rear = front;
        }else{
            //创建一个新节点，原队尾节点的next指向新节点
            Node newNode = new Node(element,null);
            rear.next = newNode;
            //以新节点做为新的尾节点
            rear = newNode;
        }
        size++;
    }
    /**
     * 删除队头元素
     * @return 返回被删除的元素
     */
    public T remove(){
        Node oldNode = front;
        front = front.next;
        oldNode.next = null;
        size--;
        return oldNode.data;
    }
    /**
     * 获取链式队列的最后一个元素
     */
    public T element(){
        return rear.data;
    }
    /**
     * 判断链式队列是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }
    /**
     * 清空队列
     */
    public void clear(){
        front = null;
        rear = null;
        size = 0;
    }

    public String toString(){
        if(isEmpty()){
            return "[]";
        }else{
            StringBuilder sb = new StringBuilder("[");
            for (Node current = front; current != null; current = current.next) {
                sb.append(current.data.toString()+",");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();
        }
    }
}