java数据结构——4循环队列的威力

什么是队列呢？

队列也是一种线性结构

相比数组，队列对应的操作是数组的子集

只能从一端（队尾）添加元素，只能从另一端（队首）取出元素。

所以队列是一种先进先出（FIFO）的数据结构。

我们还是先看看一个队列应该有哪些功能：

package com.Leo;

public interface Queue<E> {
    //获取队列大小
    int getSize();

    //判断队列是否为空
    boolean isEmpty();

    //向队列尾端添加一个元素
    void enqueue(E e);

    //取出队列头部元素
    E dequeue();

    //查看队首
    E getFront();
}

我用借口的方式，来声明这些队列的功能，利用JAVA的多态，我们分别写两个实现，先利用第一章博客二次封装的数组来写一个普通的队列的实现类：

import com.Leo.Array;
import com.Leo.Queue;

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

    private Array<E> array;

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

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

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

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

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

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

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

    @Override
    public String toString() {
        return "ArrayQueue{" +
                "array=" + array +
                '}';
    }
}

在使用二次封装的动态数组中，获取队列大小、判断队列是否为空、取出队列头部元素、查看队首 这些方法都是O(1)的时间复杂度，唯独dequeue()这个出队方法，使用的是ARRAY类的removeFirst（）方法，这个方法的时间复杂度为O(n)代码如下：

    //删除第一个元素
    public E removeFirst() {
        return remove(0);
    }
    
    //从数组中删除index位置的元素，返回删除的元素
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("修改失败，索引错误");
        }
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        data[size] = null;
        return ret;
    }

通过remove方法的这个FOR循环，其实也就是把第二位之后的每一位都向前推进一位，所以这个方法的时间复杂度是O(n)，接下来我们使用数组来实现一个循环队列，让这个队列的出队、入队等方法的时间复杂度都为O（1）,代码如下：

package com.Leo;

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

    private E[] data;
    private int font;  //指向队首的索引
    private int tail;  //指向对尾的索引
    private int size;

    public LoopQueue(int capaCity) {
        data = (E[]) new Object[capaCity + 1];
        font = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue() {
        this(10);
    }

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

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

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

    @Override
    public void enqueue(E e) {

        //当队列满时
        if ((tail + 1) % data.length == font) {
            //扩容
            resize(getCapaCity() * 2);
        }
        data[tail] = e;
        tail = (tail + 1) % data.length;
        size++;
    }

    private void resize(int newCapaCity) {
        E[] newData = (E[]) new Object[newCapaCity + 1];
        for (int i = 0; i < size; i++) {
            newData[i] = data[(i + font) % data.length];
        }
        data = newData;
        font = 0;
        tail = size;
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("当前队列为空，不能出队");
        }
        E ret = data[font];
        data[font] = null;
        font = (font + 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("当前队列为空，不能出队");
        }
        return data[font];
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("loopQueue:size = %d , capacity = %d\n", size, getCapaCity()));
        sb.append("font[");
        for (int i = font; i != tail; i = (i + 1) % data.length) {
            sb.append(data[i]);
            if ((i + 1) % data.length != tail) {
                sb.append(", ");
            }
        }
        sb.append("]tail");
        return sb.toString();
    }
}

在这个LoopQueue也就是循环队列中，为什么出队的时间复杂度是O(1)呢，因为循环队列中，设计了两个类似指针的属性，一个是tail：指向队尾的索引 一个是font：指向队首的索引。

初始化让数组的大小+1，即队列要存放10个元素，定位SIZE为11（保证预留空间，后面解释）。

当队列为空时，我们的tail=font=0 即都指向索引为0，

当有元素入队，我们把元素放在data[tail]，我们让(tail + 1) % data.length 即tail右移一位，

当有元素出队时，我们把data[font] = null，我们让(font + 1) % data.length即font右移一位,

当font == tail 时，我们判断数组为空

当(tail + 1) % data.length == font 时，我们判断队列满，不可以入队了，也可以去进行扩容，我们之前把数组的size+1就是为了应对这种情况，来区分队列满和队列空。

如果读者还是很不清晰，可以按照我所讲述的步骤，用笔纸画一个数组队列来模拟一下，你应该就很清晰了。理解之后，我们发现，循环队列的入队、出队，都是通过tail,font这两个指向队尾队首的指针来操作的，每次入队出队我们只要维护一下这两个指针，进行一次+1的赋值就OK了，并不用整体的去移动整个数组向前推进一位，所以循环数组的出队的时间复杂度是:O(1);

我用10W个元素的数据，每3个入队后，出队一个，测试了一下普通队列和循环队列的效率

普通队列：10S                                                   循环队列：0.8S

所以，当你写的队列要频繁出队时，使用循环队列，效率提高很多！