01玩转数据结构_03_栈和队列

栈Stack：

栈的概述：

虽然看起来它只是数组的子集，但是栈的这种结构对于计算机中组建逻辑有这非常非常大的作用。

入栈 出栈：

栈是一种先进后出（FILO First in Last Out ）的结构。

栈的应用01：撤销操作：

栈的应用02：程序调用的系统栈：

了解它有助于我们更加理解递归！！！ 

此时的系统栈中会记录下：

A2的意思是执行到A函数的第二行了。

同样系统栈中会继续压入！！！

当C 函数执行完毕之后，我们的计算机就不知道该执行谁了，

它此时会看系统栈中的内容，

发现是B2 ,所以开始从B2继续执行。（同时会弹出B2）

当B函数也执行完毕时候，计算机又会看下系统栈，发现是A2

所以，它就会从A2开始执行。（同时会弹出A2）

当A函数也执行完毕的时候，系统栈中为空。所以函数执行完毕！！！

这个过程对理解递归有很大的帮助，后面会有关于递归的内容。 

栈的实现：

栈基本的五种操作：

其中peek () 有的 语言中 喜欢叫它top()  !

这里说一种 栈的底层实现（另外一种后面会说）：

后面的队列会说两种不同的底层实现。

代码设计方式：

先设计一个接口，然后用ArrayStack 去实现它。

具体代码如下：

从头写一个自己的栈出来（主要利用数组，将数组封装成一个栈。）！！！注：数组也是我们自定义的可以动态改变长度的数组！

package cn.zcb.demo03;

public interface MyInterface<T> {
    /*接口也是支持泛型的*/
    public abstract void push(T a);
    public abstract T pop();
    public abstract T peek();
    public abstract int getSize();
    public abstract boolean isEmpty();
}

package cn.zcb.demo03;

public class MyStack<T> implements MyInterface<T> {
    /*
    * 我们自己的栈  。
    * */
    //它的内部用 我们之前自己写的数组 来做 。
    private MyArray <T> array;  //MyArray 是我们自己写的数组类。
    //构造函数
    public MyStack(int capacity){
        array = new MyArray<>(capacity);
    }
    public MyStack(){
        array = new MyArray<>();
    }

    public void push(T a){
        array.addLast(a);
    }
    public T pop(){
        return array.removeLast();
    }
    public T peek(){
        return array.getByIndex(array.getSize()-1); //栈顶元素
    }
    public  int getSize(){
        return array.getSize();
    }
    public  boolean isEmpty(){
        return array.isEmpty();
    }
    //下面的方法不是  接口中的方法 ！！！
    public int getCapacity(){
        return array.getCapacity();
    }

    //为了打印方便 ，这里重写Object 中的toString
    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        builder.append("Stack's data is below : 
");
        builder.append("[");
        for (int i=0;i< array.getSize();i++){
            builder.append(array.getByIndex(i));
            if(i != array.getSize()-1){
                builder.append(" ,");
            }
        }
        builder.append("] top");
        return builder.toString();
    }


}

package cn.zcb.demo03;

public class MyArray<T> {
    private T[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
//        this.data  = new int[capacity];
//        this.data  = new T[capacity];  //不支持这样
        this.data =  (T[]) new Object[capacity];  //先new 出个 Object[]  类的，然后转为 T[]
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

    //获取数组的容量
    public int getCapacity(){
        return this.data.length;
    }

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }
/////////////////////增////////////////////////////
    //向 数组的末尾添加一个新元素
    public void addLast(T num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }
    // 向数组头添加元素 （直接复用  向指定位置添加元素的函数 ）
    public void addFirst(T num){
        insert(0,num);
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,T num){
        if(this.size == this.data.length){
//            throw new IllegalArgumentException("数组已经放满了");
            /*此时对其扩容*/
            resize(2*this.data.length);


        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }

//////////////////////删///////////////////////////////////////
    //删除第一个
    public T removeFirst(){
        return remove(0);  //删除并将之返回出去
    }

    //删除最后一个
    public T removeLast(){
        return remove(this.size-1);
    }

    //删除指定位置  的元素
    public T remove(int idx){  //返回 删除的元素
        if(idx < 0 || idx > this.size -1)
            throw new IllegalArgumentException("idx错误！");
        T temp = this.data[idx];
        for (int i =idx;i<this.size - 1;i++){
            this.data[i] = this.data[i+1];
        }
        this.size -- ;

        //动态减少   当数组中的元素少于空间的四分之一的时候，缩减空间为原来的一半（这样可以有效的防止 复杂度震荡问题）。
        if(this.size == this.data.length / 4 && this.data.length/2 != 0 ){  //第二个条件是防止 length =1 的时候
            resize(this.data.length/2);
        }
        return temp;
    }

    //删除 某个元素 不根据其位置  //它之所以返回void 是因为调用着已经知道的element ，所以没必要再返回出来了。
    public void removeElement(T element){
        //首先要 寻找是否有 element
        int idx = find(element);
        if(idx == -1){
            throw new IllegalArgumentException("没有该元素");
        }else{
            remove(idx);
        }
    }

//////////////////////改///////////////////////////////////////
    //修改索引为 idx 的元素为 num
    public void setByIndex(int idx,T num){
        if(idx <0 || idx > this.size)
            throw new IllegalArgumentException("idx 错误！");

        this.data[idx] = num;
    }


//////////////////////查///////////////////////////////////////
    //获取整个数组的概括
    //重写 toString()  当打印arr 时候，就会调用该方法！
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %d 
",this.size,this.data.length));
        res.append('[');
        for (int i =0 ;i<this.size;i++){
            res.append(data[i]);
            if(i != this.size -1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }
    //获取idx 索引位置的 元素
    public T getByIndex(int idx){
        if (idx < 0 || idx >this.size) {
            throw new IllegalArgumentException("索引传入错误！");
        }
        return this.data[idx];
    }

//////////////////////包含///////////////////////////////////////
    public boolean contains(T num){
        for (int i=0;i<this.size;i++){
            if(this.data[i] == num){
                return true;
            }
        }
        return false;
    }
//////////////////////寻找////////////////////////////////////
    public int find(T num){
        //寻找数组中是否有 num  ,如果有返回其索引，反之 返回-1
        for (int i =0;i<this.size;i++){
            if(this.data[i] == num){
                return i;
            }
        }
        return -1;
    }
//////////////////////实现动态数组  resize()////////////////////////////////////
    private void resize(int new_capacity){  //之所以  用 private 是不让用户调用， 数组如果空间不足会自己扩展的。
        T[] new_data =(T[]) new Object[new_capacity];

        for (int i =0;i<this.size;i++){
            new_data[i] = this.data[i];
        }
        //
        this.data = new_data;  //此时新数组的size 不变 ， 新数组的length 也不用变
    }
}

package cn.zcb.demo03;

public class Test {
    public static void main(String[] args) {
        MyStack<Integer> stk = new MyStack();  //也可以给定容量 new MyStack(20);
        for (int i = 0;i<5;i++){
            //模拟5次入栈操作
            stk.push(i);
            System.out.println(stk);
        }
        //一次出栈操作
        stk.pop();
        System.out.println(stk);
    }
}

  

这样我们就写了一个基于动态数组而实现的栈！！！

（封装动态数组使之成为一个栈！）

栈的另一个应用：括号匹配：

通过Leetcode 中的第20题来说，

package cn.zcb.demo04;

import java.util.Stack;

public class Test {
    public boolean isValid(String s){
        if(s.length() == 0) return true;
        char c_1 = s.charAt(0);
        if(c_1 ==']' || c_1 =='}' || c_1 ==')'){
            return false;
        }
        Stack<Character> stk = new Stack<>();
        for (int i =0;i<s.length();i++){
            char c = s.charAt(i);
            if(c == '{' || c =='[' || c=='('){
                stk.push(c);
            }
            if(c =='}'){
                if(!stk.isEmpty() && stk.peek() =='{') {
                    stk.pop();
                }else{
                    return false;
                }
            }
            if(c ==']'){
                if(!stk.isEmpty() && stk.peek() =='[') {
                    stk.pop();
                }else{
                    return false;
                }
            }
            if(c ==')'){
                if(!stk.isEmpty() && stk.peek() =='(') {
                    stk.pop();
                }else{
                    return false;
                }
            }
        }
        return stk.isEmpty();
    }

}

class Solution {
    public boolean isValid(String s){
        // if(s.length() == 0) return true;  这行用没必要有！！！
        Stack<Character> stk = new Stack<>();
        for (int i =0;i<s.length();i++){
            char c = s.charAt(i);
            if(c == '{' || c =='[' || c=='('){
                stk.push(c);
            }else{
                if(stk.isEmpty()) return false;
                char topChar = stk.pop();  //正常匹配的时候，每次都要弹出一个的。
                if(c == ']' && topChar !='['){
                    return false;
                }
                if(c == '}' && topChar !='{'){
                    return false;
                }
                if(c == ')' && topChar !='('){
                    return false;
                }
            }
        }
        return stk.isEmpty();
    }
}

队列Queue：

队列概述：

FIFO  First In First Out

下面我们将写一个基于 我们自己的数组MyArray 的队列！

代码如下：

队列也是要支持泛型！

package cn.zcb.demo04;

public class MyArray<T> {
    private T[] data; //数组
    private int size;  //数组实际大小，
    //容量不用写，可以由data.length()得知

    //满参构造函数
    public MyArray(int capacity){
//        this.data  = new int[capacity];
//        this.data  = new T[capacity];  //不支持这样
        this.data =  (T[]) new Object[capacity];  //先new 出个 Object[]  类的，然后转为 T[]
        this.size = 0; //开始时 实际大小size =0
    }
    //空参构造器
    public MyArray(){
        this(10);  //如果是空参的话，调用有参构造器。默认是10
    }

    //获取数组中的元素的个数
    public int getSize(){
        return this.size;
    }

    //获取数组的容量
    public int getCapacity(){
        return this.data.length;
    }

    //数组中是否为空
    public boolean isEmpty(){
        return this.size ==0;
    }
    /////////////////////增////////////////////////////
    //向 数组的末尾添加一个新元素
    public void addLast(T num){
        /*
        if(size == this.data.length){
            //此时开辟的空间已经满了
            //这里先抛出一个异常
            throw new IllegalArgumentException("addLast failed.数组已经满了");
        }
        this.data[size] = num;
        size ++;  //要维持数组  指针。 size 是当前数组中的个数。
        */
        //此时其实可以直接复用 insert ()函数
        insert(this.size,num);
    }
    // 向数组头添加元素 （直接复用  向指定位置添加元素的函数 ）
    public void addFirst(T num){
        insert(0,num);
    }

    //向 指定数组位置添加一个新元素
    public void insert(int idx,T num){
        if(this.size == this.data.length){
//            throw new IllegalArgumentException("数组已经放满了");
            /*此时对其扩容*/
            resize(2*this.data.length);


        }
        if(idx <0 || idx > this.size )
            throw new IllegalArgumentException("索引非法");

        for(int i=this.size-1;i >= idx;--i){
            this.data[i+1] = this.data[i];
        }
        this.data[idx] = num;
        //更新size
        this.size ++;
    }

    //////////////////////删///////////////////////////////////////
    //删除第一个
    public T removeFirst(){
        return remove(0);  //删除并将之返回出去
    }

    //删除最后一个
    public T removeLast(){
        return remove(this.size-1);
    }

    //删除指定位置  的元素
    public T remove(int idx){  //返回 删除的元素
        if(idx < 0 || idx > this.size -1)
            throw new IllegalArgumentException("idx错误！");
        T temp = this.data[idx];
        for (int i =idx;i<this.size - 1;i++){
            this.data[i] = this.data[i+1];
        }
        this.size -- ;

        //动态减少   当数组中的元素少于空间的四分之一的时候，缩减空间为原来的一半（这样可以有效的防止 复杂度震荡问题）。
        if(this.size == this.data.length / 4 && this.data.length/2 != 0 ){  //第二个条件是防止 length =1 的时候
            resize(this.data.length/2);
        }
        return temp;
    }

    //删除 某个元素 不根据其位置  //它之所以返回void 是因为调用着已经知道的element ，所以没必要再返回出来了。
    public void removeElement(T element){
        //首先要 寻找是否有 element
        int idx = find(element);
        if(idx == -1){
            throw new IllegalArgumentException("没有该元素");
        }else{
            remove(idx);
        }
    }

    //////////////////////改///////////////////////////////////////
    //修改索引为 idx 的元素为 num
    public void setByIndex(int idx,T num){
        if(idx <0 || idx > this.size)
            throw new IllegalArgumentException("idx 错误！");

        this.data[idx] = num;
    }


    //////////////////////查///////////////////////////////////////
    //获取整个数组的概括
    //重写 toString()  当打印arr 时候，就会调用该方法！
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %d 
",this.size,this.data.length));
        res.append('[');
        for (int i =0 ;i<this.size;i++){
            res.append(data[i]);
            if(i != this.size -1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }
    //获取idx 索引位置的 元素
    public T getByIndex(int idx){
        if (idx < 0 || idx >this.size) {
            throw new IllegalArgumentException("索引传入错误！");
        }
        return this.data[idx];
    }

    //////////////////////包含///////////////////////////////////////
    public boolean contains(T num){
        for (int i=0;i<this.size;i++){
            if(this.data[i] == num){
                return true;
            }
        }
        return false;
    }
    //////////////////////寻找////////////////////////////////////
    public int find(T num){
        //寻找数组中是否有 num  ,如果有返回其索引，反之 返回-1
        for (int i =0;i<this.size;i++){
            if(this.data[i] == num){
                return i;
            }
        }
        return -1;
    }
    //////////////////////实现动态数组  resize()////////////////////////////////////
    private void resize(int new_capacity){  //之所以  用 private 是不让用户调用， 数组如果空间不足会自己扩展的。
        T[] new_data =(T[]) new Object[new_capacity];

        for (int i =0;i<this.size;i++){
            new_data[i] = this.data[i];
        }
        //
        this.data = new_data;  //此时新数组的size 不变 ， 新数组的length 也不用变
    }
}

package cn.zcb.demo04;

public interface MyInterface_Queue <T> {
    public abstract void enqueue(T a);  //入队
    public abstract T dequeue();  //出队
    public abstract T getFront();  //队头
    public abstract int getSize();  //得到队列中的实际长度
    public abstract boolean isEmpty();  //是否为空。
}

package cn.zcb.demo04;
public class MyQueue <T> implements MyInterface_Queue <T> {

    //我们自己的 队列，实际内部的结构还是数组（我们自己写的数组MyArray）
    private MyArray <T> array;
    //构造函数
    public MyQueue(int capacity){
        array = new MyArray<>(capacity);
    }
    public MyQueue(){
        array = new MyArray<>();
    }

    public void enqueue(T a){
        array.addLast(a);
    }
    public T dequeue(){
        return array.removeFirst();
    }
    public T getFront(){
        return array.getByIndex(0);
    }
    public int getSize(){
        return array.getSize();
    }
    public boolean isEmpty(){
        return array.isEmpty();
    }
    public int getCapacity(){
        return array.getCapacity();
    }
    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        builder.append("Queue's data is below: 
[");
        for (int i =0;i<array.getSize();i++){
            builder.append(array.getByIndex(i));
            if(i != array.getSize() -1){
                builder.append(" ,");
            }
        }
        builder.append("] 队尾");
        return builder.toString();
    }
}

package cn.zcb.demo04;
public class Test {
    public static void main(String[] args) {
        MyQueue<Integer> quu = new MyQueue<>(24); //队列中有 24 个元素
        for (int i =0;i<10;i++){
            quu.enqueue(i);
        }
        System.out.println(quu);
        for (int i =0;i<5;i++){
            quu.dequeue(); //出队 五个。
            System.out.println(quu);
        }
        quu.enqueue(90); //新入队 一个
        System.out.println(quu);
    }
}

时间复杂度分析：

入队受到 MyArray 的动态变化长度的影响，所以 是均摊！

出队就不是了，我们每次将第一个拿出后，后面的都要往前移动一个位置，所以是O（n）

那么这种出队的高复杂度的情况如何优化呢？

下节的循环队列会解决这个问题！

循环队列：

循环队列概述：

上面是数组队列 下面看循环队列

基于这样的想法，就有了循环队列的实现方式！

当队列为空的时候（此时的front 不知道指向谁（本应指第一个），只好和tail 一样）：

当队列不为空的时候：

五个元素，现在出队一个，只需要将a弹出，front 向后移动一个！

 

此时如果后面一直push() 元素的话，此时tail就不能++了。

其实此时可以把它看做是个环，0-7 形成一个环，7之后就是0了。

队列可以插入直到tail 比 front 小一个，即上图所示，就不能插入了（之所以不能继续插入，是因为front==tail 代表的是空队列！）。

综上给出如下定义：

当tail +1 = front 的时候就可以进行扩容了。（其实我们要知道，这里我们是有意识的浪费了一个空间！！！）

还有上述的tail +1  == front 是不准确的， 其实应该是 (tail +1 )% c == front%c  ， c是队列的容量！ 。   因为front 和tail 是一直可以增加的。

总结：front 是当前第一个元素。tail 是指向下一个插入的地方！

代码如下：

package cn.zcb.demo05;

public interface MyInterface_Queue <T> {
    public abstract void enqueue(T a);  //入队
    public abstract T dequeue();  //出队
    public abstract T getFront();  //队头
    public abstract int getSize();  //得到队列中的实际长度
    public abstract boolean isEmpty();  //是否为空。
}

package cn.zcb.demo05;

public class MyLoopQueue <T> implements MyInterface_Queue<T>  {
    private T[] data;
    private int front,tail;
    private int size; //其实不用它，也可以，是可以直接由front 和 tail 推出的，但是加上它会使得逻辑变得简单。

    //构造函数
    public MyLoopQueue(int capacity){
        data =(T[] ) new Object[capacity +1] ;//因为循环队列会浪费一个空间， 所以开辟的时候要多开辟一个
        this.front = 0;
        this.tail = 0;
        this.size = 0;
    }
    public MyLoopQueue(){
        this(10);   //用户所认为的是 10  ，但是实际上是 11
    }
    private void resize(int newCapacity){
        T[] newData = (T[]) new Object[newCapacity +1];
        for (int i =0;i<this.size ;i++){  //将旧的队列的 front 放到新的队列中的0号位置。
            newData[i] = this.data[(i+front)%this.data.length]; //取余是为了防止越界！
        }
        data = newData ;
        front = 0;
        tail = this.size;
        //size不需要变
    }
    public  void enqueue(T a){
        if( (tail +1)%this.data.length == front ){ //看是否队列 满了。（其实没有满，浪费了一个）
            this.resize(this.getCapacity() *2); //注意这里不能是 this.data.length ,它们是有一个的差距的。
        }
        data[tail] = a;
        tail = (tail +1)%this.data.length;  //取余是为了防止越界！
        this.size ++;
    }
    public  T dequeue(){
        if(this.isEmpty()){
            throw new IllegalArgumentException("队列为空！！！");
        }
        T ret =this.data[front];
        this.data[front] = null;  //出队！
        front = (front+1)%this.data.length;  //维护front
        this.size --;
        //出队之后，也可以进行缩容。
        if(this.size  == this.getCapacity() /4 && this.getCapacity()/2 !=0 ){  //当 size == 容量的1/4 时候，就将容量缩小为 1/2  这样做的目的是为了防止震荡的出现
            this.resize(this.getCapacity()/2);  //缩容的值不应该等于0  ！！！
        }

        return ret;
    }
    public  T getFront(){
        if(this.isEmpty())
            throw new IllegalArgumentException("队列为空！！！");
        return this.data[front];
    }
    public  int getSize(){
        return this.size;
    }
    public  boolean isEmpty(){
        return front == tail;
    }

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

    @Override
    public String toString(){  //遍历队列的另一种方式，  resize的方式是其中的一种，这是另外一种！
        StringBuilder builder = new StringBuilder();
        builder.append("LoopQueue's data is below: 
front[");
        for (int i =front ;i != tail ; i = (i+1)%this.data.length){
            builder.append(this.data[i]);
            if( (i+1)%this.data.length != tail )
                builder.append(" ,");
        }
        builder.append(String.format("] 队尾 Capacity: %d Size :%d", this.getCapacity(),this.size ));
        return builder.toString();
    }
}

package cn.zcb.demo05;

public class Test {
    public static void main(String[] args) {
        MyLoopQueue <Integer> loopQueue = new MyLoopQueue<>(5);
        for (int i =0;i<7;i++){
            loopQueue.enqueue(i);
            System.out.println(loopQueue);
        }
        loopQueue.dequeue();
        System.out.println(loopQueue);
        loopQueue.dequeue();
        System.out.println(loopQueue);

        for (int i =0;i<20;i++){
            loopQueue.enqueue(i);//再入队 20个元素
            System.out.println(loopQueue);
        }
    }



}
/*  输出：   我们也可以看出，从用户的角度来看，循环队列 一侧是队首，一侧是队尾，包括里面的capacity 是比真实空间小一个的，用户都不用关心。
LoopQueue's data is below:
front[0] 队尾 Capacity: 5 Size :1
LoopQueue's data is below:
front[0 ,1] 队尾 Capacity: 5 Size :2
LoopQueue's data is below:
front[0 ,1 ,2] 队尾 Capacity: 5 Size :3
LoopQueue's data is below:
front[0 ,1 ,2 ,3] 队尾 Capacity: 5 Size :4
LoopQueue's data is below:
front[0 ,1 ,2 ,3 ,4] 队尾 Capacity: 5 Size :5
LoopQueue's data is below:
front[0 ,1 ,2 ,3 ,4 ,5] 队尾 Capacity: 10 Size :6
LoopQueue's data is below:
front[0 ,1 ,2 ,3 ,4 ,5 ,6] 队尾 Capacity: 10 Size :7
LoopQueue's data is below:
front[1 ,2 ,3 ,4 ,5 ,6] 队尾 Capacity: 10 Size :6
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6] 队尾 Capacity: 10 Size :5
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0] 队尾 Capacity: 10 Size :6
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1] 队尾 Capacity: 10 Size :7
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2] 队尾 Capacity: 10 Size :8
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3] 队尾 Capacity: 10 Size :9
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4] 队尾 Capacity: 10 Size :10
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5] 队尾 Capacity: 20 Size :11
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6] 队尾 Capacity: 20 Size :12
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7] 队尾 Capacity: 20 Size :13
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8] 队尾 Capacity: 20 Size :14
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9] 队尾 Capacity: 20 Size :15
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10] 队尾 Capacity: 20 Size :16
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11] 队尾 Capacity: 20 Size :17
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12] 队尾 Capacity: 20 Size :18
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13] 队尾 Capacity: 20 Size :19
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14] 队尾 Capacity: 20 Size :20
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15] 队尾 Capacity: 40 Size :21
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16] 队尾 Capacity: 40 Size :22
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16 ,17] 队尾 Capacity: 40 Size :23
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16 ,17 ,18] 队尾 Capacity: 40 Size :24
LoopQueue's data is below:
front[2 ,3 ,4 ,5 ,6 ,0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16 ,17 ,18 ,19] 队尾 Capacity: 40 Size :25
* */

数组队列和循环队列的复杂度分析：

循环队列的时间复杂度分析：

下面我们看O(n) 的时间复杂度比 O(1) 的时间复杂度到底有多快。实际证明我们在数据结构中设计低的时间复杂度是有意义的。

下面用程序测试 数组队列和 循环队列的效率！

package cn.zcb.demo05;

import java.util.Random;
public class Test {
    private static double getRuntime(MyLoopQueue queue,int opCount){
        long startTime = System.nanoTime(); //以纳秒为单位！

        Random random = new Random();
        for (int i =0;i<opCount; i++){
            queue.enqueue(random.nextInt(Integer.MAX_VALUE));
        }
        for (int i =0;i<opCount; i++){
            queue.dequeue();
        }
        long endTime = System.nanoTime();
        return (endTime -startTime)/1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;
        MyLoopQueue<Integer> loopQueue = new MyLoopQueue<>();
        double time = getRuntime(loopQueue,opCount);
        System.out.println("循环队列所消耗的时间是： "+time);
    }
}
/*  输出：循环队列所消耗的时间是： 0.0291362
* */

上述十万次操作：

数组队列用了 8.42s
循环对类用了 0.06s

它们相差100多倍，所以分析时间复杂度是很有必要的。