排序算法之冒泡排序详细解读（附带Java代码解读）

冒泡排序（Bubble Sort）是一种简单的排序算法，主要通过比较相邻元素并交换它们的位置来逐步将最大的元素“冒泡”到列表的末尾。它的工作过程如下：

算法思想

冒泡排序通过多次遍历要排序的数组，从数组的头部开始，两两比较相邻的元素。如果前一个元素比后一个元素大，则交换它们的位置。这样，每一轮遍历后，都会把当前未排序部分中最大的元素移动到它应该在的位置。这个过程会一直重复，直到没有需要交换的元素为止。

过程示例

假设有一个待排序的数组：[5, 2, 9, 1, 5, 6]

1. 第一次遍历:

   • 比较第1个和第2个元素 (5, 2)，由于5 > 2，交换位置：[2, 5, 9, 1, 5, 6]
   • 比较第2个和第3个元素 (5, 9)，无需交换：[2, 5, 9, 1, 5, 6]
   • 比较第3个和第4个元素 (9, 1)，由于9 > 1，交换位置：[2, 5, 1, 9, 5, 6]
   • 比较第4个和第5个元素 (9, 5)，由于9 > 5，交换位置：[2, 5, 1, 5, 9, 6]
   • 比较第5个和第6个元素 (9, 6)，由于9 > 6，交换位置：[2, 5, 1, 5, 6, 9]

   第一次遍历后，最大元素9已经排在最后一位。

2. 第二次遍历:

   • 比较第1个和第2个元素 (2, 5)，无需交换：[2, 5, 1, 5, 6, 9]
   • 比较第2个和第3个元素 (5, 1)，由于5 > 1，交换位置：[2, 1, 5, 5, 6, 9]
   • 比较第3个和第4个元素 (5, 5)，无需交换：[2, 1, 5, 5, 6, 9]
   • 比较第4个和第5个元素 (5, 6)，无需交换：[2, 1, 5, 5, 6, 9]

   第二次遍历后，第二大元素6已经排在倒数第二位。

3. 第三次遍历:

   • 比较第1个和第2个元素 (2, 1)，由于2 > 1，交换位置：[1, 2, 5, 5, 6, 9]
   • 比较第2个和第3个元素 (2, 5)，无需交换：[1, 2, 5, 5, 6, 9]
   • 比较第3个和第4个元素 (5, 5)，无需交换：[1, 2, 5, 5, 6, 9]

   第三次遍历后，前3个元素 [1, 2, 5] 已经有序。

4. 第四次遍历:

   • 比较第1个和第2个元素 (1, 2)，无需交换：[1, 2, 5, 5, 6, 9]
   • 比较第2个和第3个元素 (2, 5)，无需交换：[1, 2, 5, 5, 6, 9]

   第四次遍历后，前4个元素 [1, 2, 5, 5] 已经有序。

5. 第五次遍历:

   • 比较第1个和第2个元素 (1, 2)，无需交换：[1, 2, 5, 5, 6, 9]

   第五次遍历后，整个数组已经有序。

算法复杂度

• 时间复杂度:

  • 最坏情况: O(n^2)（数组是逆序排列）
  • 平均情况: O(n^2)
  • 最佳情况: O(n)（数组已经有序，只需一趟遍历）

• 空间复杂度: O(1)（只需常量级的额外空间）

优点

1. 简单易懂，容易实现。
2. 对于小规模数据集，冒泡排序的性能尚可。

缺点

1. 效率低，特别是在大规模数据集上的表现不佳。
2. 由于每次比较都涉及交换，冒泡排序的交换操作频繁，不适合处理大型数据。

冒泡排序虽不是最优的排序算法，但作为学习算法思想的入门工具，它有助于理解排序算法的基本概念和数据处理方式。

Java代码解读

public class BubbleSort {

    public static void bubbleSort(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;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};
        System.out.println("排序前的数组:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();

        bubbleSort(arr);

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

代码说明

1. bubbleSort方法:

   • n 表示数组的长度。
   • 外层循环控制排序轮数，每一轮的目标是将当前未排序部分的最大元素移到末尾。
   • 内层循环负责在未排序部分内比较和交换相邻的元素。
   • 使用 swapped 标志来判断当前轮次是否发生了交换，如果没有发生交换，则表示数组已经有序，可以提前结束排序。

2. main方法:

   • 创建一个待排序的数组 arr。
   • 调用 bubbleSort 方法对数组进行排序。
   • 输出排序前和排序后的数组。