数据结构与算法-队列

数据结构与算法之队列

基本介绍

队列是一种有序的线性表，可以用数组和链表实现，只允许在队头和队尾进行操作，特点是先进先出的原则。

用数组声明一个简单的队列
具体方法，声明一个数组容器，两个指针，一个添加的指针，一个获取的指针，
添加时，添加指针后移，获取时，获取指针后移

数组队列代码示例

class ArrayQueue{
    /**
     * 最大容量
     */
    private final int maxSize;
    /**
     * 队列头的前一个位置
     */
    private int front;
    /**
     * 队列尾部
     */
    private int rear;
    /**
     * 容器实体
     */
    private int[] arr;

    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
        front = -1;
        rear = -1;
    }

    public boolean isFull(){
        return rear == maxSize - 1;
    }

    public boolean isEmpty(){
        return rear == front;
    }

    public void add(int n){
        if(isFull()){
            throw new RuntimeException();
        }
        arr[++rear] = n;
    }

    public int get(){
        if(isEmpty()){
            throw new RuntimeException();
        }
        return arr[++front];
    }

    public void showList(){
        System.out.println(Arrays.toString(arr));
    }

    public int first(){
        if(isEmpty()){
            throw new RuntimeException();
        }
        return arr[front+1];
    }
}

上面的代码做到了队列的基本要求，但是不难发现它有很大弊端，它能存储的长度最大为maxSize，达到上限之后，无论如何操作都无法进行添加了，已经获取完的地方没有做到复用性。

我们是不是可以用数组模拟一个环形队列，这样就可以复用已经获取完的地方了。
思路：

1. front指向数组队列的第一个元素，初始值0
2. rear指向队列的最后一个元素的后一个位置，需要预留一个空间，rear初始值0
3. 当队列满时，条件（rear +1）% maxSize == front 就是满了
4. 当队列是空的时候，rear == front
5. 队列有效的数据个数（rear + maxSize - front）% maxSize

这里说明为什么要预留一个空间，就是为了要区分容器已满还是空的，如果不预留一个空间，那么他们满足的条件将是一样的，也就无法进行区分了。

环形数组队列代码示例

class ArrayQueue2{
    /**
     * 最大容量
     */
    private final int maxSize;
    /**
     * 队列头的位置
     */
    private int front;
    /**
     * 队列尾部的后一个位置
     */
    private int rear;
    /**
     * 容器实体
     */
    private int[] arr;

    public ArrayQueue2(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
    }

    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

    public boolean isEmpty(){
        return rear == front;
    }

    public void add(int n){
        if(isFull()){
            throw new RuntimeException();
        }
        arr[rear] = n;
        rear = (rear + 1) % maxSize;
    }

    public int get(){
        if(isEmpty()){
            throw new RuntimeException();
        }
        int i = arr[front];
        front = (front + 1) % maxSize;
        return i;
    }

    public void showList(){
        //从front开始遍历，遍历多少个元素
        for(int i = front ; i < front + size();i++){
            System.out.printf("%d\t",arr[i % maxSize]);
        }
        System.out.println();
    }

    public int size(){
        return (rear + maxSize - front) % maxSize;
    }

    public int first(){
        if(isEmpty()){
            throw new RuntimeException();
        }
        return arr[front];
    }
}