JAVA数据结构：队列

队列

队列是一个有序列表，可以用数组或是链表来实现。

遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出

数组模拟队列

示意图：(使用数组模拟队列示意图)

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

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

数据队列设计思路

这里是rear 队列最后[含]，front 是队列最前元素[不含]。当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：

1. 将尾指针往后移：rear+1
2. 若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。

特殊条件

1. 队列为空：当front == rear
2. 队列为满：rear == maxSize - 1

ArrayQueue类

/**
 * 使用数组模拟一个类——编写ArrayQueue类
 */

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

    /**
     * 创建队列的构造器
     *
     * @param maxSize
     */
    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
        //指向队列头部，指向队列头的前一个位置
        front = -1;
        //指向队列尾，指向队列的尾部的数据
        rear = -1;
    }

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

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

    /**
     * 添加数据到队列
     *
     * @param number
     */
    public void addQueue(int number) {
        //判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据");
            return;
        }
        rear++;
        arr[rear] = number;
    }

    /**
     * 获取队列的数据，出队列
     *
     * @return
     */
    public int getQueue() {
        if (isEmpty()) {
            //throw 会返回
            throw new RuntimeException("队列为空，不能取出数据");
        }
        front++;
        return arr[front];
    }

    /**
     * 显示队列的所有数据
     */
    public void show() {
        //遍历
        if (isEmpty()) {
            System.out.println("队列为空，没有数据");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }

    /**
     * 显示队列的头数据，并不是取出数据
     *
     * @return
     */
    public int peakQueue() {
        //判断
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据");
        }
        return arr[front + 1];
    }
}

ArrayQueueDemo类：用于测试

/**
 * Copyright (C), 2020-2020, 人生无限公司
 * FileName: ArrayQueue
 * Description:
 * 使用数组模拟队列
 *
 * @create: 2020/9/1 11:10
 * @author Reanon
 * @version JDK 1.8.0_251
 */
package queue;

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(3);
        //接受用户输入
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        //输出一个菜单
        while (loop) {
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列中取出数据");
            System.out.println("p(peak):查看队列头的数据");
            //接受一个字符
            key = scanner.next().charAt(0);
            switch (key) {
                case 's':
                    arrayQueue.show();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'p':
                    try {
                        int res=arrayQueue.peakQueue();
                        System.out.println();
                    }catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop=false;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

数组模拟环形队列

由于上述的数组模拟队列，front只能够依次向后移动，不可重复利用，但front移动到队列尾部时，即使前面为空，也依然显示为队列满，利用效率太低。于是对前面的数组模拟队列的优化，充分利用数组。因此将数组看做是一个环形的。(通过取模的方式来实现即可)

环形队列设计思想

尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定。需要对front和rear做一个调整：

• front：指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素，front初始值为0
• rear：指向队列的最后一个元素的后一个位置，希望空出一个位置作为约定，rear初始值也为0.

特殊条件：

• 队列为空：rear == front [空]
• 队列满：(rear + 1) % maxSize == front
• 有效元素个数 n=(rear+maxSize-front) % maxSize

CircleArray类

/**
 * 数组实现环形队列
 */
class CircleArray {
    /**
     * @maxsize 表示数组最大容量
     */
    private int maxSize;
    /**
     * 指向队列的第一个位置，起始位置就是front=0
     */
    private int front;
    /**
     * 指向队列尾部的后一个位置，并且空出一个位置，初始值rear=0
     */
    private int rear;
    /**
     * 用该数组存放数据，模拟队列
     */
    private int[] arr;

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

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

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

    /**
     * 添加数据到队列
     *
     * @param number
     */
    public void addQueue(int number) {
        //判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据");
            return;
        }
        arr[rear] = number;
        //将rear后移，需要考虑取模
        rear = (rear + 1) % maxSize;
    }

    /**
     * 获取队列的数据，出队列
     *
     * @return
     */
    public int getQueue() {
        if (isEmpty()) {
            //throw 会返回
            throw new RuntimeException("队列为空，不能取出数据");
        }
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    /**
     * 得到当前队列的有效数据的个数
     *
     * @return
     */
    public int getsize() {
        return (rear + maxSize - front) % maxSize;
    }

    /**
     * 显示队列的所有数据
     * 从front开始遍历，遍历多少个元素
     * 有效元素个数 n=(rear+maxSize-front)%maxSize
     */
    public void showQueue() {
        //遍历
        if (isEmpty()) {
            System.out.println("队列为空，没有数据");
            return;
        }
        for (int i = front; i < front + getsize(); i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }

    /**
     * 显示队列的头数据，并不是取出数据
     *
     * @return
     */
    public int peakQueue() {
        //判断
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据");
        }
        return arr[front % maxSize];
    }
}

CircleArrayQueueDemo类

/**
 * Copyright (C), 2020-2020, 人生无限公司
 * FileName: CircleArrayQueueDemo
 * Description: 使用数组实现环形队列
 * 尾索引的下一个为头索引时表示队列满，
 * 即将队列容量空出一个作为约定,
 * 这个在做判断队列满的时候需要注意
 * * (rear + 1) % maxSize == front 满]
 * * rear == front [空]
 * * 有效数据个数 n = (rear+maxSize-front)%maxSize
 *
 * @create: 2020/9/1 14:26
 * @author Reanon
 * @version JDK 1.8.0_251
 */
package queue;

import java.util.Scanner;

public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        CircleArray circleArray = new CircleArray(3);
        //接受用户输入
        char key;
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        //输出一个菜单
        while (loop) {
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列中取出数据");
            System.out.println("p(peak):查看队列头的数据");
            //接受一个字符
            key = scanner.next().charAt(0);
            switch (key) {
                case 's':
                    circleArray.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    circleArray.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = circleArray.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'p':
                    try {
                        int res = circleArray.peakQueue();
                        System.out.printf("头部数据为：%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}