Java编程：队列

队列：先进先出

1. 队列是一个有序列表，可以用数组实现或者链表实现。
2. 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入队列的数据，要后取出。

顺序队列

思路：

1. maxSize是该队列的对大容量。front和rear分别记录队列的前后端下标，front会随着数据的输出而改变，rear随着数据输入而改变。
2. rear指向最后一个数据，添加数据的时候需要先rear++再添加数据。
3. front指向第一个数据的上一个位置，输出数据的时候需要先front++再输出数据。
4. 初始：front = -1 rear = -1
5. 队列为空条件：front = rear
6. 队列已满条件：rear = maxSize - 1

代码实现：

package queue;

import java.text.ParseException;
import java.text.SimpleDateFormat;
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(quit)：退出程序");
            System.out.println("a(add)：添加数据");
            System.out.println("g(get)：取出数据");
            System.out.println("h(head)：查看队列头数据");
            key = scanner.next().charAt(0); // 接收一个字符
            switch (key) {
    
    
                case 's':   // 显示队列
                    arrayQueue.showQueue();
                    break;
                case 'e':   // 退出
                    scanner.close();
                    loop = false;
                    break;
                case 'a':   // 添加一个数据
                    System.out.println("请输入一个数据：");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':   // 取出一个数据
                    try {
    
    
                        int get = arrayQueue.getQueue();
                        System.out.printf("取出的数据为：%d", get);
                    } catch (Exception e) {
    
    
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':   // 取出头数据
                    try {
    
    
                        int get = arrayQueue.headQueue();
                        System.out.printf("取出的头数据为：%d", get);
                    } catch (Exception e) {
    
    
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序已退出");
    }


}

// 使用数组模拟队列——使用数组编写一个ArrayQueue类
class ArrayQueue {
    
    
    private final int maxSize;    // 表示数组最大容量
    private int front;  // 队列头
    private int rear;   // 队列尾
    private int[] arr;  // 该数组用于存放数据，模拟队列

    // 创建队列构造器
    public ArrayQueue(int arrMaxSize) {
    
    
        this.maxSize = arrMaxSize;
        this.arr = new int[maxSize];
        this.front = -1;    // 指向队列头部，分析出front指向队列头的前一个位置
        this.rear = -1;     // 指向队列尾，分析出rear指向队列尾的数据（即就是队列最后一个数据）
    }

    // 判断队列是否已满
    public boolean isFull() {
    
    
        // maxSize是数组长度
        return this.rear == this.maxSize - 1;
    }

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

    // 添加数据到队列
    public void addQueue(int data) {
    
    
        if (this.isFull()) {
    
    
            System.out.println("队列已满，无法添加新数据！");
            return;
        }
        this.arr[++this.rear] = data;    // 先让rear后移，然后存入数据
    }

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

    // 显示队列数据
    public void showQueue() {
    
    
        if (isEmpty()) {
    
    
            System.out.println("队列为空！");
            return;
        }
//        for (int n : this.arr){
    
    
//            System.out.printf("%d ",n);
//        }
        for (int i = 0; i < this.arr.length; i++) {
    
    
            System.out.printf("arr[%d]:%d\n", i, this.arr[i]);
        }
    }

    // 显示队列头数据
    public int headQueue() {
    
    
        // 判断
        if (isEmpty()) {
    
    
            throw new RuntimeException("数列为空！");
        }
        return this.arr[front + 1];
    }

    // 显示队列长度
    public int queueLen() {
    
    
        return this.arr.length;
    }
}

问题：

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

代码实现：

package queue;

import java.util.Scanner;

public class CircleArrayQueueDemo {
    
    
    // 测试
    public static void main(String[] args) {
    
    
        // 创建一个队列
        CircleArrayQueue arrayQueue = new CircleArrayQueue(3);
        char key = ' '; // 接收用户输入
        Scanner scanner = new Scanner(System.in);   // 接收输入
        boolean loop = true;
        while (loop) {
    
    
            System.out.println("s(show)：显示队列");
            System.out.println("e(quit)：退出程序");
            System.out.println("a(add)：添加数据");
            System.out.println("g(get)：取出数据");
            System.out.println("h(head)：查看队列头数据");
            key = scanner.next().charAt(0); // 接收一个字符
            switch (key) {
    
    
                case 's':   // 显示队列
                    arrayQueue.showQueue();
                    break;
                case 'e':   // 退出
                    scanner.close();
                    loop = false;
                    break;
                case 'a':   // 添加一个数据
                    System.out.println("请输入一个数据：");
                    int value = scanner.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':   // 取出一个数据
                    try {
    
    
                        int get = arrayQueue.getQueue();
                        System.out.printf("取出的数据为：%d", get);
                    } catch (Exception e) {
    
    
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':   // 取出头数据
                    try {
    
    
                        int get = arrayQueue.headQueue();
                        System.out.printf("取出的头数据为：%d", get);
                    } catch (Exception e) {
    
    
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序已退出");
    }
}

// 使用数组模拟队列——使用数组编写一个ArrayQueue类
class CircleArrayQueue {
    
    
    private final int maxSize;    // 表示数组最大容量
    private int front;  // 队列头：指向队列头
    private int rear;   // 队列尾：指向队列尾下一个位置
    private int[] arr;  // 该数组用于存放数据，模拟队列

    // 创建队列构造器
    public CircleArrayQueue(int arrMaxSize) {
    
    
        this.maxSize = arrMaxSize;
        this.arr = new int[maxSize];
    }

    // 判断队列是否已满
    public boolean isFull() {
    
    
        // maxSize是数组长度
        return (this.rear + 1) % this.maxSize == this.front;
    }

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

    // 添加数据到队列
    public void addQueue(int data) {
    
    
        if (this.isFull()) {
    
    
            System.out.println("队列已满，无法添加新数据！");
            return;
        }
        this.arr[this.rear] = data;    // 先让rear后移，然后存入数据
        this.rear = (this.rear + 1) % this.maxSize;    // rear后移，考虑取模
    }

    // 数据出队列
    public int getQueue() {
    
    
        if (this.isEmpty()) {
    
    
            // 抛出异常
            throw new RuntimeException("队列为空，无法取出数据！");
        }
        // 这里需要分析出front是指向队列第一个元素
        // 1. 先把front对应的值保存在一个临时变量
        // 2. 将front后移
        // 3. 将临时保存的变量返回
        int value = arr[this.front];
        this.front = (this.front + 1) % this.maxSize;
        return value;
    }

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

    //  求出当前队列有效数据个数
    public int size() {
    
    
        return (this.rear + this.maxSize - this.front) % this.maxSize;
    }

    // 显示队列头数据
    public int headQueue() {
    
    
        // 判断
        if (isEmpty()) {
    
    
            throw new RuntimeException("数列为空！");
        }
        return this.arr[this.front];
    }

    // 显示队列长度
    public int queueLen() {
    
    
        return this.arr.length;
    }
}