队列：数组队列

队列：Queue 也是一种线性结构。相比数组，队列对应的操作是数组的子集。只能从一端（队尾）添加元素，从另一端队首取出元素。

是一种先进先出的数据结构 FIrst In First Out （FIFO）

package com.dapeng.Queue;
public interface Queue<E> {

    int getSize();
    boolean isEmpty();
    void enqueue(E e);
    E dequeue();
    E getFront();
}

package com.dapeng.Queue;
import com.dapeng.Array.Array;
/**
 * @author gdp
 * @date 2020/4/1 17:23
 *   队列是 先进先出  First in First out   栈是先进后出   First in Last out
 */
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 E getFront() { return array.getFirst(); }

    public int getCapacity(){return array.getCapacity();}
    //排队  添加元素
    @Override
    public void enqueue(E e){array.addLast(e);}
    //出列  拿出元素
    @Override
    public E dequeue(){ return array.removeFirst();}

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Queue: ");
        res.append("front [");
        for(int i = 0; i< array.getSize() ; i++ ){
            res.append(array.get(i));
            if(i!= array.getSize() - 1){
                res.append(", ");
            }
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {
        ArrayQueue<Integer> queue = new ArrayQueue<>();
        for(int i = 0 ; i < 10 ; i++ ){
            queue.enqueue(i);
            System.out.println(queue);
            System.out.println(i+"i % 3:==="+i % 3);
            if(i % 3 == 2){
                System.out.println(i);
                 queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

这个循环队列有一个问题，就是当数据量大的时候出队的时间复杂度会变大，消耗的时间会大幅度增长。比如100万的数据你把第一位挪走了后面每一位都要挪一下！！！

猜你喜欢