引言

大家好！欢迎来到我的排序算法系列第二篇。今天，我们将学习另一种非常基础且广为人知的排序算法——冒泡排序 (Bubble Sort)。

冒泡排序的名字非常形象，它模拟了水中气泡上升的过程：较小（或较大）的元素会像气泡一样，通过不断交换，逐渐“浮”到数组的一端。

---

什么是冒泡排序？

冒泡排序的核心思想是：重复地遍历待排序的序列，每次遍历比较相邻的两个元素，如果它们的顺序错误（例如，在升序排序中，前面的元素大于后面的元素），就交换它们的位置。

这个过程会一直重复，直到在某一次遍历中没有发生任何元素交换，这意味着整个序列已经排序完成。

想象一下：

1. 第一轮： 从第一个元素开始，依次比较相邻的两个元素。如果顺序不对就交换。这一轮结束后，最大的元素会被移动到数组的末尾。
2. 第二轮： 再次从第一个元素开始，比较相邻元素并交换（如果需要），但这次只需要比较到倒数第二个元素，因为最后一个元素已经是最大的了。这一轮结束后，第二大的元素会被移动到倒数第二的位置。
3. 重复这个过程： 每一轮都将当前未排序部分的最大元素“冒泡”到其最终位置。比较的范围也逐渐缩小。

---

算法步骤详解 (以升序为例)

假设我们有数组 [5, 1, 4, 2, 8]

1. 第 1 轮 (比较 n-1 次 = 4次):

   • 比较 5 和 1 -> 1 > 5? 否 -> 5 > 1? 是 -> 交换 -> [1, 5, 4, 2, 8]
   • 比较 5 和 4 -> 5 > 4? 是 -> 交换 -> [1, 4, 5, 2, 8]
   • 比较 5 和 2 -> 5 > 2? 是 -> 交换 -> [1, 4, 2, 5, 8]
   • 比较 5 和 8 -> 5 > 8? 否 -> 不交换 -> [1, 4, 2, 5, 8]
   • 结果： 最大元素 8 已就位。下次只需比较前 4 个。

2. 第 2 轮 (比较 n-2 次 = 3次):

   • 比较 1 和 4 -> 1 > 4? 否 -> 不交换 -> [1, 4, 2, 5, 8]
   • 比较 4 和 2 -> 4 > 2? 是 -> 交换 -> [1, 2, 4, 5, 8]
   • 比较 4 和 5 -> 4 > 5? 否 -> 不交换 -> [1, 2, 4, 5, 8]
   • 结果： 第二大元素 5 已就位。下次只需比较前 3 个。

3. 第 3 轮 (比较 n-3 次 = 2次):

   • 比较 1 和 2 -> 1 > 2? 否 -> 不交换 -> [1, 2, 4, 5, 8]
   • 比较 2 和 4 -> 2 > 4? 否 -> 不交换 -> [1, 2, 4, 5, 8]
   • 结果： 第三大元素 4 已就位。下次只需比较前 2 个。

4. 第 4 轮 (比较 n-4 次 = 1次):

   • 比较 1 和 2 -> 1 > 2? 否 -> 不交换 -> [1, 2, 4, 5, 8]
   • 结果： 第四（小）大元素 2 已就位。数组排序完成。

---

Java 代码实现

下面提供了两种冒泡排序的 Java 实现：基础版和优化版。

1. 基础冒泡排序 (bubbleSort1)

这是最经典的冒泡排序实现。

import java.util.Arrays;

public class BubbleSort {
    // 类名建议大写开头

    public static void main(String[] args) {
   
        int[] arr = {
   31, 25, 18, 16, 19, 82, 71