递归冒泡排序：理解参数策略与基线条件优化

public class RecursiveBubbleSort {

    /**
     * 递归实现冒泡排序 (经典方法：n递减)
     * @param arr 待排序数组
     * @param n 当前未排序部分的长度
     */
    public static void sortingRecursion(int[] arr, int n) {
        // 基线条件：如果未排序部分的长度为1，则数组已排序完毕
        if (n == 1) {
            return;
        }

        // 执行一趟冒泡排序，将当前未排序部分的最大元素放到末尾
        for (int i = 0; i < n - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        // 递归调用，处理剩余的 n-1 个元素
        sortingRecursion(arr, n - 1);
    }

    public static void main(String[] args) {
        int[] array = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("原始数组: " + java.util.Arrays.toString(array));
        sortingRecursion(array, array.length);
        System.out.println("排序后数组: " + java.util.Arrays.toString(array));
    }
}

import java.util.Arrays;

public class RecursiveBubbleSortUserStyle {

    /**
     * 递归实现冒泡排序 (用户风格：n递增)
     * @param arr 待排序数组
     * @param n 已排序的元素数量（从数组末尾开始计数）
     */
    public static void bubbleRecursion(int arr[], int n) {
        // 基线条件：如果已排序的元素数量等于数组长度，则排序完成
        // 优化建议：当 n 等于 arr.length - 1 时，最后一个元素已就位，即可结束
        if (n == arr.length) { // 原始基线条件
            System.out.println("排序完成 (n=" + n + "): " + Arrays.toString(arr));
            return;
        }

        // 执行一趟冒泡排序，将当前未排序部分的最大元素放到末尾
        // 未排序部分的范围是 [0, arr.length - 1 - n]
        for (int i = 0; i < arr.length - 1 - n; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp;
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        // 递归调用，已排序元素数量 n 递增
        bubbleRecursion(arr, n + 1);
    }

    public static void main(String[] args) {
        int[] array = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("原始数组: " + Arrays.toString(array));
        bubbleRecursion(array, 0); // 从 n=0 开始，表示初始没有已排序元素
    }
}

    public static void bubbleRecursionOptimized(int arr[], int n) {
        // 优化后的基线条件：当已排序的元素数量达到 arr.length - 1 时，排序完成
        if (n == arr.length - 1) {
            System.out.println("排序完成 (优化后基线条件 n=" + n + "): " + Arrays.toString(arr));
            return;
        }
        // ... (内层循环及后续递归调用保持不变)
    }