数据结构与算法（六）——循环队列的顺序存储结构（超详解，附动图+代码）

• 上一篇最后我们分析了队列的利弊，故我们这里对队列进行优化。就有了这一篇，循环队列。
  队列的问题主要便是入队的时间复杂度O(1).出队的时间复杂度0(n) 。还有就是当进行插入和删除操作后，线性表的开始空间可能会被空出来，会浪费且占用空间。
• 所以我们这里让队列首位相连变成了一个环，但是如何相连，相连之后入队和出队又是如何操作呢，相连以后会不会出现问题呢，出现问题又该如何解决呢，大家跟我一起往下看吧。

优化（循环队列）：

• 首先让队头指针和队尾指针一样随着数据元素的变化而变化。这样入队和出队的操作都是O(1)，然后我们将线性表首尾相连，当队头或队尾指针到达尾部时，如需后移可重新指向表头，变成一个环，指针从尾到头有一个周期性，也就是数线性表长度，指针+1对线性表长度取余就可以完成指针从头到尾的跳跃，这样就解决了空间浪费的问题。然后将一个空间预留出来不存任何元素，尾指针始终指向这个null空间，这时，队列满的条件是（rear+1）%n== front，队列为空的条件是 rear == front。这样可以解决判断队列满和队列空的条件都是（rear+1）%n==front的问题，这里n是线性表的长度，没法判断。如下图（这个图花了我很大的功夫，这篇博客的核心思想便在这俩张动图之中，大家一定要仔细看）：

图一：解决了空间浪费的问题

图二：解决判断队列满和队列空的条件都是（rear+1）%n==front的问题

用Java代码实现循环队列的顺序存储结构，使用ArrayQueueLoop实现Queue接口，重写Queue的方法，这里写的接口都是我们自己编写的，不是java里面自带的接口，大家注意一下，代码如下：

import java.util.Iterator;

//循环队列  底层用动态数组实现
public class ArrayQueueLoop<E> implements Queue<E> {
    private E[] data;     //定义数组
    private int front;    //头指针
    private int rear;     //尾指针 
    private int size;     //有效元素个数

    public ArrayQueueLoop(){
        data= (E[]) (new Object[11]);//因为有一个空的空间，有效能存储的空间有10个
        front=0;    //初始化
        rear=0;
        size=0;
    }

    @Override
    public int getSize() {
        return size;    //获取有效元素个数，直接返回size
    }

    @Override
    public boolean isEmpty() {
        return size==0&&front==rear;    //循环队列为空的条件
    }

    @Override
    public void enqueue(E e) {
        if((rear+1)%data.length==front){       //队列满时
            resize(2*data.length-1);    //扩容，扩二倍
        }
        data[rear]=e;     //把e从队尾入队列，rear角标处是空的空间
        rear=(rear+1)%data.length;  //更新尾指针，rear重新指向空地址
        size++;   //有效元素+1
    }

    @Override
    public E dequeue() {
        if(isEmpty()){  //队列空时不可出队，抛异常
            throw new IllegalArgumentException("队列空");
        }
        E ret=data[front];  //变量ret存头指针的元素，用于返回
        front=(front+1)%data.length;   //更新头指针
        size--;     //有效元素-1
        //当有效元素小于等于能存储的数组长度，同时缩容后长度的大于等于10，方可进行缩容操作
        if(size<=(data.length-1)/4&&(data.length-1)/2>=10){
            resize((data.length-1)/2+1);   //缩容缩一半
        }
        return ret;    //返回被删除的元素
    }
    //扩缩容函数
    private void resize(int newLen){
        E[] newData= (E[]) (new Object[newLen]);    //创新数组，即缩容后的数组
        int p=front;    //用指针p遍历原数组
        int i=0;        //用指针i遍历新数组
        while(true){
            newData[i]=data[p];    //把原数组中的元素复制给新数组
            i++;
            p=(p+1)%data.length;
            if(p==rear){    //p指针遍历的尾指针处结束循环
                break;
            }
        }
        front=0;    //把头指针指向扩容后数组表头位置
        rear=size;  //尾指针指向有效元素长度角标
        data=newData;   //把新数组给元素组，偷梁换柱
    }

    @Override
    public E getFront() {
        if(isEmpty()){
            throw new IllegalArgumentException("队列为空");
        }
        return data[front];    //获取队头，队头就是头指针处
    }

    @Override
    public E getRear() {
        if(isEmpty()){
            throw new IllegalArgumentException("队列为空");
        }
        return data[(rear-1+data.length)%data.length]; 
         //获取队尾，队尾是尾指针的前一个，尾指针始终指向空
    }

    //清空队列元素，把构造函数里的代码拿过来(初始化状态)
    @Override
    public void clear() {
        data= (E[]) (new Object[11]);//因为有一个空的空间
        front=0;
        rear=0;
        size=0;
    }

    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder();  
         //创建StringBuilder对象，可以直接在原字符串上添加字符，不许要每次改变都创新字符串
        /*
        输出这样的格式
            ArrayQueueLoop: 15/20
            [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
         */
        sb.append(String.format("ArrayQueueLoop: %d/%d\n",size,data.length-1));
        sb.append('[');
        if(isEmpty()){
            sb.append(']');
        }else{
            for(int i=front;i!=rear;i=(i+1)%data.length){ 
              //打印元素，从头指针处开始，到达指针结束
                sb.append(data[i]); 
                if((i+1)%data.length==rear){   
                 //当遍历到指针i下一个位置是尾指针处时，此时i在最后一个元素处，打印']'
                    sb.append(']');
                }else{                      //否则在元素间打印','
                    sb.append(',');
                }
            }
        }
        return sb.toString();   //返回sb对象，调用toString方法
    }

    @Override
    public Iterator<E> iterator() {
        return new ArrayQueueLoopIterator();    //创建内部类对象
    }
    //迭代器 内部类(就是打印表内元素，并让其支持foreach循环)
    private class ArrayQueueLoopIterator implements Iterator{
        int p=front;      //从头指针处开始
        @Override
        public boolean hasNext() { 
            return p!=rear;     //继续条件：p指针不指向尾指针处
        }

        @Override
        public Object next() {  
            E ret=data[p];      //ret输出元素
            p=(p+1)%data.length;    //p递增
            return ret;
        }
    }
}

如果有什么问题或者不懂，欢迎私信博主，博主会尽我最大能力帮助你哦！