队列

队列是一种只能在一端插入(队尾)，在另一端删除(队首)的有序线性表，所以，队列是一种先进先出(FIFO)线性表。
Java中定义了Queue接口，用以支持队列的常见操作。Queue接口与List、Set同一级别，都是继承了Collection接口，LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用：

Queue<Integer> queue = new LinkedList<>();

这里介绍两种自定义队列的方法：

通过动态循环数组来实现

import java.util.EmptyStackException;

public class DynArrayQueue<T>{
    /**
     * 基于动态循环数组实现队列
     * 1、当第一次元素入栈时，队头指向第一个元素，即由-1变为0
     * 2、队列中front指向队头元素，rear指向队尾元素
     * 3、当front==rear时，队列中只有一个元素
     */
    private int front = -1; // 队头
    private int rear = -1; // 队尾
    private int capacity = 10; // 容量
    private Object[] array = new Object[capacity];

    public boolean isEmpty(){ // 判断队列是否为空
        return front == -1;
    }

    public void enQueue(T data){ // 入队操作
        if((rear+1)%capacity == front){ // 如果队列已满
            Object[] newarr = new Object[capacity+capacity/2];  // 新建1.5倍大小的数组
            System.arraycopy(array, 0, newarr, 0, array.length);
            if(rear < front){
                for(int i = 0; i < front; ++i){
                    newarr[i+capacity] = array[i];
                    newarr[i] = null;
                }
                rear = rear+capacity; // 新队尾的位置
            }
            array = newarr;
            capacity = capacity + capacity/2;
        }
        rear = (rear+1) % capacity;
        array[rear] = data;
        if(front == -1) // 第一次入队操作后，使队首指向第一个元素
            front = 0;
    }

    @SuppressWarnings("unchecked")
    public T deQueue(){
        if(isEmpty())
            throw new EmptyStackException();
        T data = (T) array[front];
        if(front == rear) // 如果队列中只有一个元素
            front = rear = -1;
        else
            front = (front+1)%capacity;
        return data;
    }

    @SuppressWarnings("unchecked")
    public T getFront(){ // 获取队头元素
        if(isEmpty())
            throw new EmptyStackException();
        return (T)array[front];
    }

    public int size(){ // 队列中元素个数
        if(front == -1)
            return 0;
        int size = (rear-front+1+capacity)%capacity;
        return size == 0 ? capacity : size;
    }


}

通过链表来实现

import java.util.EmptyStackException;

import linkedlist.ListNode;

public class LLQueue<T> {
    /**
     * 基于链表实现队列
     */
    private ListNode<T> frontNode = null; // 队头结点
    private ListNode<T> rearNode = null; // 队尾结点
    private int size = 0; // 队列中元素个数

    public boolean isEmpty(){ // 判断队列是否为空
        if(frontNode == null || frontNode.getData() == null)
            return true;
        else
            return false;
    }

    public void enQueue(T data){ // 入队操作
        if(rearNode == null){ // 第一次元素入队
            rearNode = new ListNode<T>(data);
            frontNode = rearNode;
        } else {
            ListNode<T> node = new ListNode<T>(data);
            rearNode.setNext(node);
            rearNode = rearNode.getNext();
        }
        size++;
    }

    public T deQueue(){ // 出队操作
        if(isEmpty())
            throw new EmptyStackException();
        T data = frontNode.getData();
        if(frontNode == rearNode)
            frontNode = rearNode = null;
        else
            frontNode = frontNode.getNext();
        size--;
        return data;
    }

    public T getFront(){ // 获取队头元素
        if(isEmpty())
            throw new EmptyStackException();
        return frontNode.getData();
    }

    public int size(){
        return size;
    }
}

完整代码可以访问我的Github：https://github.com/StriverLi/Data-Structures-and-Algorithms-in-Java/tree/master/src/queue