实现队列

队列的特点是先进先出（FIFO），我们之前实现了数组，具体在

https://www.cnblogs.com/skychmz/p/11968449.html

现在我们可以利用这个数组类来实现队列。

首先我们新建一个队列的原型，具有基本的方法和变量

public class ArrayQueue<E>{

    private Array<E> array;

    public ArrayQueue(int capacity){
        array = new Array<>(capacity);
    }

    public ArrayQueue(){
        array = new Array<>();
    }

    public int getSize(){
        return array.getSize();
    }

    public boolean isEmpty(){
        return array.isEmpty();
    }

    public int getCapacity(){
        return array.getCapacity();
    }
}

然后我们实现操作队列元素的方法

　　根据队列先进先出的特性，我们往队列尾部加入元素，也就是enqueue方法，通过数组的addLast方法实现

public void enqueue(E e){
        array.addLast(e);
    }

　　根据队列先进先出的特性，取元素我们是从队列头部取，也就是dequeue方法，通过数组的removeFirst方法实现

public E dequeue(){
        return array.removeFirst();
    }

　　最后实现查看队列第一个元素的方法，通过数组的getFirst方法实现

public E getFront(){
        return array.getFirst();
    }

关于循环队列

　　上面实现的队列在取出元素的时候，后面的元素都会向前移一位，当队列元素数量多的时候出队操作会变得十分耗时，这是因为这个队列是基于我们写的数组实现的，为了解决这个问题，我们不用这个数组实现，而是利用front和tail两个标记来实现循环队列

　　首先创建一个循环队列的原型，然后再实现元素的操作方法

public class LoopQueue<E> {

    private E[] data;
    //front指向队首，tail指向队尾
    private int front, tail;public LoopQueue(int capacity){
        data = (E[])new Object[capacity + 1];
        front = 0;
        tail = 0;
    }

    public LoopQueue(){
        this(10);
    }

　//判断循环队列为空的条件是front==tail，所以必须浪费一个位置，否则不管队列为空还是已满front==tail都成立
    public int getCapacity(){
        return data.length - 1;
    }

    public boolean isEmpty(){
        return front == tail;
    }

    public int getSize(){
        return (tail - front + data.length) % data.length;
　　}

 }

　　我们先实现resize方法，因为出队入队都需要用到resize

private void resize(int newCapacity){

        E[] newData = (E[])new Object[newCapacity + 1];
        int size=getSize();
        //把原数组的元素复制到新数组，由于新数组是从0开始复制，所以和原数组的元素存在偏移front，又因为原数组是循环数组，所以需要%data.length
        for(int i = 0 ; i < size ; i ++)
            newData[i] = data[(i + front) % data.length];

        data = newData;
        front = 0;
        tail = size;
    }

 

　　入队操作

public void enqueue(E e){
        //数组已满时，扩容
        if((tail + 1) % data.length == front)
            resize(getCapacity() * 2);

        data[tail] = e;
        tail = (tail + 1) % data.length;

    }

　　出队操作

public E dequeue(){

        if(isEmpty())
            throw new IllegalArgumentException("队列为空！");

        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;//数组小于容量的四分之一时，缩容
        if(getSize() == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

　　查看队首元素操作

public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("队列为空！");
        return data[front];
    }