循环队列

队列概念

　　队列（Queue）是限定只能在一端插入、另一端删除的线性表。允许删除的一端叫做队头（front),允许插入的一端叫做队尾（rear），没有元素的队列称为“空队列”。

　　队列具有先进先出（FIFO）的特性。

普通顺序队列存在的问题

　　在普通顺序队列中,入队的操作就是先将尾指针rear右移一个单位，然后将元素值赋值给rear单位。出队时，则是头指针front后移一个单位。像这样进行了一定数量的入队和出队操作后，可能会出现这样的情况：

　　尾指针rear已指到数组的最后有一个元素，即rear==MaxLen-1，此时若再数组的前面部分可能还有很多闲置空间，即这种溢出并非是真的没有可用的存储空间，故称这种溢出现象为“假溢出”。显然，必须要解决这一块假溢出的问题，否则顺序队列就没有太多使用价值。

循环队列

       

说明：

　　1. 判断满条件为  front =  (rear + 1) % size  即满

       2. 每入队一个元素， tail =  (tail + 1) % size

       3. 令队列空间中的一个单元闲置，使得队列非空时，rear与front之间至少间隔一个空闲单。　　

 

循环队列: 

public class LoopQueue<E> implements Queue<E> {

    private E[] data;
    private int front,tail;
    private int size;

    public LoopQueue(int capacity){
        //需要多一个空间 留空
        data = (E[])new Object[capacity+1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue(){
        this(10);
    }

    public int getCapacity(){
        return data.length - 1;
    }

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

    @Override
    public int getSize(){
        return size;
    }

    //入队
    @Override
    public void enqueue(E e){
        //队列满了判断
        if ((tail + 1) % data.length == front)
            resize(getCapacity() * 2);

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

    //出队
    @Override
    public E dequeue(){

        if (isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue");

        E ret = data[front];
        //data[front] = null;
        front = (front + 1) % data.length;
        size --;

        //缩容
        if (size == getCapacity() / 4 && getCapacity() / 2 != 0 )
            resize(getCapacity() / 2);

        return ret;
    }

    @Override
    public E getFront(){
        if (isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue");

        return data[front];
    }

    private void resize(int newCapacity){
        E[] newData = (E[])new Object[newCapacity + 1];
        for (int i = 0; i < size; i++){
            //把旧的数组的首元素 放入到新的元素中 ,这里不用i,因为i不一定是首位元素
            newData[i] = data[(front + i) % data.length];
        }

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

    //覆盖父类
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue:size = %d,capacity = %d
", size, getCapacity()));
        res.append("front [");
        for (int i = front; i != tail; i = (i + 1) % data.length){
            res.append(data[i]);
            if ((i + 1) % data.length != tail)
                res.append(", ");
        }
        res.append("] tail");

        return res.toString();
    }

}