数据结构：队列（下）【Java】

前言

前一篇我们用数组进行模拟队列的入队和出队，最后我们发现出队列并不是真正意义上的出队列，只是遍历方法没有进行打印

取模改进

对于前面的数组模拟队列的优化，为了充分利用数组，我们可以将数组看做一个环形数组(取模)

front 和 rear

front变量的含义做一个调整，front就指向队列的第一个元素，即arr[front] 就是第一个元素， front初始化为0
rear变量的含义：rear指向队列最后一个元素后一个位置，空出一个空间作为约定，初始化为0
maxSize：设置数值并不是实际上的队列长度，实际上要-1才是最大队列长度
因为rear指向最后一个元素的后一个元素作为了约定空间

	private int[] arr; // 模拟队列
    private int maxSize; // maxSize-1表示队列的最大容量
    private int front; // 表示队列的头部，指向队列中的第一个元素
    private int rear; // 表示队列的尾部，指向队列中的最后一个元素的后一个位置

得到队列的有效数据

(rear + maxSize - front) % maxSize
下面是解释
在循环队列中，rear 表示队尾元素的下标，而 front 表示队头元素的下标。maxSize 是队列的最大容量。要理解 (rear + maxSize - front) % maxSize 为何表示队列中的有效元素数量，我们需要考虑循环队列的特性以及如何计算其实际长度：
1.循环队列特性： 循环队列是一种特殊的队列实现，它利用固定大小的数组来模拟无限长的队列。当队列的前端达到数组边界时，它会“绕回”数组的起始位置继续存储元素。同样，当队尾元素到达数组末尾时，新加入的元素会从数组的起始位置开始存放。这样，队列中的元素始终在一个连续的、首尾相接的逻辑区间内。
2.队列有效元素数量的计算： 在循环队列中，队列的有效元素可能分布在数组的两端，甚至跨越整个数组。为了准确计算有效元素的数量，我们需要处理以下两种情况：
（1） 队头在前，队尾在后：
当队头和队尾都在数组范围内且队头在队尾之前，有效元素数就是简单的队尾下标减去队头下标，即 rear - front。但这种情况仅适用于队尾未“绕回”到队头之前的情况。
（2）队尾已“绕回”到队头之前：
当队尾“绕回”到队头之前，即队尾下标小于队头下标时，数组中的一部分空间被有效元素占据，另一部分为空。此时，若直接计算 rear - front 会得到负数或较小的非期望值。为解决这个问题，我们可以加上 maxSize 来确保计算出正确的有效元素数量。即 rear + maxSize - front 表示了从队头到队尾绕过数组边界的实际距离。
3. 取模操作确保结果在数组范围内：
上述计算结果可能会超过数组的实际长度。因此，我们对结果取模 (% maxSize) 来确保得到的值始终表示队列在数组中的实际有效元素数量。取模操作确保了无论队头和队尾如何分布，计算结果都能正确反映队列中的有效元素数量，且不会超出数组容量范围。

综上所述，表达式 (rear + maxSize - front) % maxSize 正确地计算了循环队列中有效元素的数量，充分考虑了队列头尾可能“交错”和“绕回”的情况，以及数组容量的限制。

方法实现

队列为空

rear == front，不做过多解释

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

队列满

尾索引的下一个为头索引表示队列满
(rear + 1) % maxSize == front (队列是一个环形的，取模后两个索引就在同一圈上，进行rear + 1 == front ? 满 ： 没满)

/**
     * 判断队列是否满
     * @return 队列是否满
     */
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
        // 尾索引下一个位置为头索引则队列为满
    }

入队列

	/**
     * 添加数据到队列
     * @param n 要添加到队列的数据
     */
    public void addQueue(int n) {
        if (isFull()) {
            System.out.println("队列满，不能添加数据");
            return;
        }
        // 直接将数据加入
        arr[rear] = n;
        // 将rear后移，需要考虑取模（环形数组）
        rear = (rear + 1) % maxSize;
    }

出队列

	/**
     * 获取队列的数据，出队列
     * @return 队列中的第一个元素
     * @throws RuntimeException 当队列为空时抛出异常
     */
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，无法获取数据");
        }
        // front指向队列的第一个元素
        // 1. 先把front对应的值保存到一个临时变量（如果不保存就没办法返回了）
        // 将front后移，考虑取模
        // 将临时保存的变量返回
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

显示队列

	/**
     * 显示队列里面的数据
     */
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空，没有数据");
        }
        // 从front开始遍历
        for (int i = front; i < front + getSize(); i++) {
            System.out.printf("arr[%d] = %d\n", i % maxSize, arr[i % maxSize]);
        }
    }

显示头元素

/**
     * 显示头元素数据
     * @return 队列的第一个元素
     * @throws RuntimeException 当队列为空时抛出异常
     */
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据");
        }
        return arr[front];
    }

测试方法

public static void main(String[] args) {


        CircleArray circleArray = new CircleArray(4);//设置为4，实际上最大数据存储为3
        char key = ' ';// 用户输入
        Scanner scanner = new Scanner(System.in);
        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':
                    circleArray.showQueue();
                    break;
                case 'a':
                    try {
                        System.out.println("输入一个数");
                        int value = scanner.nextInt();
                        circleArray.addQueue(value);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'g':
                    try {
                        int res = circleArray.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res = circleArray.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }