数据结构与算法（二）：队列

一、队列简介

1. 队列是一个有序列表，可以用数组或链表来实现
2. 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列
3. 队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表
4. 顺序队列是队列的顺序存储结构，顺序队列实际上是运算受限的顺序表
5. 循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环，成为循环队列。

二、顺序队列的数组实现

实现思路

1. 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中 maxSize 是该队列的最大容量

2. 因为队列的输入、输出是分别从前后端来处理，因此需要两个变量 front 和 rear 分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear 则随着数据输入而改变，如图所示：
   

3. 当我们将数据存入队列时使用方法 addQueue ，addQueue 的处理需要有两个步骤：

   (1)将尾指针往后移：rear+1

   (2)若尾指针 rear 小于队列的最大下标 maxSize-1 ，则将数据存入 rear 所指的数组元素中，否则无法存入数据

4. 判断队列是否为空：front == rear

5. 判断队列是否满：rear == maxSize - 1

实现代码

public class ArrayQueueDemo {

    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(3);
        Scanner scanner = new Scanner(System.in);
        char key = ' '; // 用于接收用户输入
        boolean loop = true;
        while (loop) {
            System.out.println("s(show)：显示队列");
            System.out.println("a(add)：添加数据到队列");
            System.out.println("g(get)：从队列取出数据");
            System.out.println("h(head)：产看队列头的数据");
            System.out.println("e(exit)：退出程序");
            key = scanner.next().charAt(0);
            switch (key) {
                case 's':
                    arrayQueue.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入一个数：");
                    int inputData = scanner.nextInt();
                    arrayQueue.addQueue(inputData);
                    break;
                case 'g':
                    try {
                        int data = arrayQueue.getQueue();
                        System.out.println("取出数据：" + data);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int data = arrayQueue.headQueue();
                        System.out.println("队列头数据：" + data);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
    }
}

class ArrayQueue {
    private int maxSize; // 数组的最大容量
    private int front;   // 队列头下标
    private int rear;    // 队列尾下标
    private int[] arr;   // 用于存放数据，模拟队列

    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        this.arr = new int[maxSize];
        front = -1; // 指向队列头的前一个位置
        rear = -1;  // 指向队列尾的数据
    }

    /**
     * 判断队列是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return rear == front;
    }

    /**
     * 判断队列是否满
     *
     * @return
     */
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    public void addQueue(int data) {
        if (isFull()) {
            System.out.println("队列已满~~~");
            return;
        }
        arr[++rear] = data;
    }

    /**
     * 出队列
     * @return
     */
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法取出数据");
        }
        return arr[++front];
    }

    /**
     * 显示有效数据
     */
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空~~~");
            return;
        }
        for (int i = front + 1; i <= rear; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }

    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法取出数据");
        }
        return arr[front + 1];
    }
}

问题分析并优化

1. 目前顺序队列使用一次就不能用了，没有达到复用的效果
2. 将这个顺序队列使用算法，改进成一个环形的队列，使用取模：%

三、环形队列的数组实现

对前面的顺序队列进行优化，充分利用数组，因此将数组看做是一个环形的。（通过取模的方式来实现）

实现思路

1. front 变量的含义做了调整：front 指向队列的第一个元素，也就是说 arr[front] 就是队列的第一个元素，front 的初始值为 0
2. rear 变量的含义也做了调整：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定，rear的初始值为 0
3. 判断队列是否满：尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意 ，（rear + 1）% maxSize == front [队列满]
4. 判断队列是否为空：rear == front
5. 队列中有效的数据个数：(rear + maxSize - front) % maxSize

实现代码

public class CircleArrayQueueDemo {

    public static void main(String[] args) {
        CircleArray queue = new CircleArray(4);
        Scanner scanner = new Scanner(System.in);
        char key = ' '; // 用于接收用户输入
        boolean loop = true;
        while (loop) {
            System.out.println("s(show)：显示队列");
            System.out.println("a(add)：添加数据到队列");
            System.out.println("g(get)：从队列取出数据");
            System.out.println("h(head)：产看队列头的数据");
            System.out.println("e(exit)：退出程序");
            key = scanner.next().charAt(0);
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入一个数：");
                    int inputData = scanner.nextInt();
                    queue.addQueue(inputData);
                    break;
                case 'g':
                    try {
                        int data = queue.getQueue();
                        System.out.println("取出数据：" + data);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int data = queue.headQueue();
                        System.out.println("队列头数据：" + data);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
    }
}

class CircleArray {
    private int maxSize; // 数组的最大容量
    private int front; // 队列头下标 初始值=0
    private int rear; // 队列尾下标 初始值=0
    private int[] arr; // 用于存放数据，模拟队列

    public CircleArray(int maxSize) {
        // 设置最大容量，并给数组分配空间
        this.maxSize = maxSize;
        this.arr = new int[maxSize];
    }

    /**
     * 判断队列是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return rear == front;
    }

    /**
     * 判断队列是否满
     *
     * @return
     */
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    /**
     * 添加数据
     * @param data
     */
    public void addQueue(int data) {
        if (isFull()) {
            System.out.println("队列已满~~~");
            return;
        }
        // 直接将数据加入
        arr[rear] = data;
        // 将rear后移，这里必须考虑取模
        rear = (rear + 1) % maxSize;
    }

    /**
     * 出队列
     * @return
     */
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法取出数据");
        }
        // 临时保存取出下标
        int index = front;
        // 将front前进一位
        front = (front+1) % maxSize;
        return arr[index];
    }

    /**
     * 显示有效数据
     */
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空~~~");
            return;
        }
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n", i%maxSize, arr[i%maxSize]);
        }
    }

    /**
     * 显示队列的头数据， 注意不是取出数据
     * @return
     */
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法取出数据");
        }
        return arr[front];
    }

    /**
     * 求出当前队列有效数据的个数
     * @return
     */
    private int size() {
        return (rear + maxSize - front) % maxSize;
    }
}