进阶 Java冒泡排序递归法有点难度哦

南极Ou

已于 2024-08-21 10:57:02 修改

阅读量1.3k

点赞数 46

分类专栏：你好，算法文章标签： java 开发语言

于 2024-08-14 16:55:36 首次发布

南极

本文链接：https://blog.csdn.net/ouhexie/article/details/141194409

版权

你好，算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

简介

这里有用到递归的冒泡排序思路，难度对新手很大，不明白递归和冒泡排序的小伙子可以先看看我的其他两个文章。

连接在这里：

案例

我们来详细解析这段代码的每一部分。

首先呢，是我们的main方法哈：

public static void main(String[] args) {
    int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
    randomOrder(arr);
    System.out.println("打乱后的数组顺序");
    System.out.println(Arrays.toString(arr));

    bubbleSort(arr, arr.length - 1);
    System.out.println("递归后的数组顺序：");
    System.out.println(Arrays.toString(arr));
}

定义数组：初始化一个长度为20的整型数组，元素按顺序从1到20。
打乱数组：调用 randomOrder 方法，将数组元素的顺序打乱。
打印打乱后的数组：显示打乱后的数组内容。
递归冒泡排序：调用 bubbleSort 方法，对打乱后的数组进行排序。
打印排序后的数组：显示排序后的数组内容。

紧接着，是randomOrder(int [] arr)方法

private static void randomOrder(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        int randomIndex = (int) (Math.random() * arr.length);
        int temp = arr[i];
        arr[i] = arr[randomIndex];
        arr[randomIndex] = temp;
    }
}

获取数组长度内的随机索引

Math.random()：生成一个范围在 [0.0, 1.0) 之间的随机浮点数。
Math.random() * arr.length：将这个随机数乘以数组的长度，得到一个范围在 [0.0, arr.length) 之间的浮点数。
(int)：强制转换为整数，取整以获得数组中的有效索引值。

交换元素

int temp = arr[i]：将当前元素 arr[i] 存储在临时变量 temp 中。
arr[i] = arr[randomIndex]：将随机索引位置的元素赋值给当前索引 i。
arr[randomIndex] = temp：将临时变量 temp 的值（原 arr[i] 的值）赋值给随机索引位置arr[randomIndex]。

然后嘞，是bubbleSort(int [] arr, int maxIndex)方法

private static void bubbleSort(int[] arr, int maxIndex) {
    // 递归结束条件
    if (maxIndex < 1) {
        return;
    }
    // 每次递归只会执行一次循环
    for (int j = 0; j < maxIndex; j++) {
        if (arr[j] > arr[j + 1]) {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    // 反复递归直到传入的下标小于0结束递归
    bubbleSort(arr, maxIndex - 1);
}

递归结束条件：当 maxIndex 小于1时，递归终止。这是因为数组已经排序好，或者只剩下一个元素时无需再排序。

冒泡排序逻辑：
- 外层循环：控制比较的轮次，每轮将一个最大元素移动到当前未排序部分的末端。
- 内层循环：在当前范围内比较相邻元素，并在必要时交换它们的位置。
递归调用：每轮排序后，调用 bubbleSort 方法递归处理剩余的部分（maxIndex - 1）。

源码哦：

import java.util.Arrays;

/**
 * @version 1.0
 * @ClassName BubbleSort
 * @Description 冒泡排序
 * @Author NanJi
 * @Date 2024/7/12 - 10:37
 */
public class BubbleSort {
    public static void main(String[] args) {
        // 定义一个长度为 20 的整形数组
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
        // 打乱数组的元素
        randomOrder(arr);
        System.out.println("打乱后的数组顺序");
        System.out.println(Arrays.toString(arr));

        // 递归冒泡排序
        bubbleSort(arr, arr.length - 1);
        System.out.println("递归后的数组顺序：");
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡排序
     *
     * @param arr 要排序的数组
     */
    private static void bubbleSort(int[] arr) {
        // 循环遍历数组元素，比较相邻的元素，交换位置
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 如果前一个元素大于后一个元素，则交换位置
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    /**
     * 递归冒泡排序
     *
     * @param arr      传入的数组
     * @param maxIndex 数组的最大下标
     */
    private static void bubbleSort(int[] arr, int maxIndex) {
        // 递归的结束条件
        if (maxIndex < 1) {
            return;
        }
        // 标记数组是否已经排好序
        boolean flag = false;
        // 循环遍历数组元素，比较相邻的元素，交换位置
        for (int j = 0; j < maxIndex; j++) {
            // 如果前一个元素大于后一个元素，则交换位置
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        // 优化冒泡排序，如果数组元素已经排好序，则直接返回
        if (!flag) {
            return;
        }
        // 递归调用自身
        bubbleSort(arr, maxIndex - 1);
    }

    /**
     * 打乱数组元素的顺序
     *
     * @param arr 要打乱的数组
     */
    private static void randomOrder(int[] arr) {
        // 循环打乱数组元素
        for (int i = 0; i < arr.length; i++) {
            // 获取数组的索引值
            int randomIndex = (int) (Math.random() * arr.length);
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
    }
}

欧了，到这里我应该解释的差不多啦，我是南极，大胆做自己，活出精彩的人生👊👊👊