一步步教你搞定冒泡排序，快速提升编程技能

大家好！我是小欧！
今天我要和大家聊聊一个基础但非常重要的排序算法——冒泡排序。冒泡排序是入门排序算法的好帮手，不仅逻辑简单，而且有助于理解排序算法的基本思想。废话不多说，我们开始吧！

什么是冒泡排序？

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访要排序的元素列，依次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。这个过程会持续重复直到没有需要交换的元素为止，这样我们就得到了一个有序的数组。

冒泡排序的基本原理

冒泡排序之所以叫“冒泡”，是因为每一轮排序操作后，总会有一个“最大的”元素被交换到未排序部分的最右端，就像水中的气泡一样不断上升。听上去有点抽象，咱们用一个具体例子来解释。

假设我们有一个数组：[5, 3, 8, 4, 2]

第一轮：

1. 比较第一个元素和第二个元素，如果第一个元素比第二个大，则交换它们。5 > 3，交换，得到：[3, 5, 8, 4, 2]
2. 比较第二个元素和第三个元素，5 < 8，不交换。
3. 比较第三个元素和第四个元素，8 > 4，交换，得到：[3, 5, 4, 8, 2]
4. 比较第四个元素和第五个元素，8 > 2，交换，得到：[3, 5, 4, 2, 8]

第一轮结束，最大的元素8已经被“冒”到了最右边。

第二轮：

1. 比较第一个元素和第二个元素，3 < 5，不交换。
2. 比较第二个元素和第三个元素，5 > 4，交换，得到：[3, 4, 5, 2, 8]
3. 比较第三个元素和第四个元素，5 > 2，交换，得到：[3, 4, 2, 5, 8]

第二轮结束，第二大的元素5也被“冒”到了倒数第二个位置。

以此类推，直到整个数组有序。

冒泡排序的代码实现

我们来看一下冒泡排序的Java代码实现。这个实现分为两个嵌套的循环，外层循环控制遍历的轮数，内层循环用于比较和交换相邻的元素。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        bubbleSort(arr);
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换 arr[j] 和 arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

运行上面的代码，输出结果为：

排序后的数组：
2 3 4 5 8

代码解读

1. bubbleSort 方法接收一个整数数组 arr 作为参数。
2. 外层循环 for (int i = 0; i < n - 1; i++) 控制遍历的轮数。每一轮结束，最大的元素会被放到正确的位置，所以无需再比较已经排序好的部分。
3. 内层循环 for (int j = 0; j < n - 1 - i; j++) 负责比较和交换相邻的元素。
4. 如果 arr[j] > arr[j + 1]，则交换它们的位置。

优化冒泡排序

尽管冒泡排序的逻辑简单，但它并不是效率最高的排序算法。我们可以对其进行一些优化，比如在每一轮遍历中如果没有发生任何交换，则说明数组已经是有序的，可以提前结束排序。

public static void bubbleSortOptimized(int[] arr) {
    int n = arr.length;
    boolean swapped;
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        // 如果内层循环没有发生交换，说明数组已排序
        if (!swapped) break;
    }
}

这个优化版的冒泡排序在每一轮结束后，检查是否发生了交换，如果没有发生交换，则提前结束排序，减少不必要的比较。

实战练习

为了加深理解，我们再来看一个稍微复杂一点的例子。假设有一个包含10个随机数的数组，我们需要对其进行排序。

import java.util.Random;

public class BubbleSortExample {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(100); // 生成0到99之间的随机数
        }

        System.out.println("排序前的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        bubbleSortOptimized(arr);

        System.out.println("\n排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    public static void bubbleSortOptimized(int[] arr) {
        int n = arr.length;
        boolean swapped;
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) break;
        }
    }
}

运行以上代码，输出如下（具体数值会因随机数而异）：

排序前的数组：
67 45 89 24 56 12 78 34 23 90 
排序后的数组：
12 23 24 34 45 56 67 78 89 90 

总结

冒泡排序作为一个基础的排序算法，简单易懂，但效率并不高。通过代码实现和优化，你可以更好地理解排序算法的原理和优化思路。希望通过这篇文章，大家能够掌握冒泡排序，并为进一步学习更复杂的排序算法打下坚实的基础。赶快动手实践一下吧！
如果你有任何问题或建议，欢迎在评论区留言，关注+订阅我们下次再见！