当前位置：首页 > news >正文

冒泡排序专栏

news 2025/8/15 20:02:14

在算法的世界里，排序算法是基础中的基础，而冒泡排序作为最经典的排序算法之一，因其思路简单、易于理解而被广泛学习。尽管它在效率上并非最优，但掌握冒泡排序的原理和优化方法，能帮助我们建立对排序算法的基本认知，为学习更复杂的算法打下坚实基础。本文将带您全面了解冒泡排序，从基本概念到实际应用，一步步揭开它的面纱。

一、冒泡排序的基本概念

冒泡排序（Bubble Sort）是一种简单的交换排序算法，它的核心思想是重复地走访要排序的数列，一次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。这个过程就像水中的气泡不断向上浮动一样，越大的元素会经由交换慢慢 “浮” 到数列的顶端，因此得名 “冒泡排序”。

冒泡排序的特点十分鲜明：它是一种稳定的排序算法，在排序过程中不会改变相等元素的相对顺序；它也是一种原地排序算法，排序过程中不需要额外的存储空间，仅通过交换元素的位置就能完成排序操作。

二、冒泡排序的工作原理

要理解冒泡排序的工作原理，我们可以通过一个具体的例子来直观感受。假设我们有一个无序数组：[5, 2, 9, 3, 6]，我们希望通过冒泡排序将其按升序排列。

第一轮排序时，我们从数组的第一个元素开始，依次比较相邻的两个元素：

比较 5 和 2，由于 5>2，交换它们的位置，数组变为 [2, 5, 9, 3, 6]；

比较 5 和 9，5<9，顺序正确，不交换；

比较 9 和 3，9>3，交换位置，数组变为 [2, 5, 3, 9, 6]；

比较 9 和 6，9>6，交换位置，数组变为 [2, 5, 3, 6, 9]。

经过第一轮排序，最大的元素 9 已经 “浮” 到了数组的末尾。

第二轮排序时，我们只需要对前 4 个元素进行比较（因为最后一个元素已经是最大的了）：

比较 2 和 5，2<5，顺序正确，不交换；

比较 5 和 3，5>3，交换位置，数组变为 [2, 3, 5, 6, 9]；

比较 5 和 6，5<6，顺序正确，不交换。

第二轮排序结束后，第二大的元素 6 也到位了。

第三轮排序只需对前 3 个元素进行比较：

比较 2 和 3，2<3，顺序正确，不交换；

比较 3 和 5，3<5，顺序正确，不交换。

此时数组已经完全有序，但按照冒泡排序的常规流程，还会进行第四轮排序，不过这一轮不会有任何元素交换。

通过这个例子可以看出，冒泡排序每一轮都会将当前未排序部分的最大元素 “浮” 到正确的位置，排序的轮数等于数组的长度减一。

三、冒泡排序的实现步骤

用代码实现冒泡排序并不复杂，以下是具体的实现步骤：

确定排序的轮数：对于长度为 n 的数组，需要进行 n-1 轮排序。
每轮排序中，从数组的第一个元素开始，依次比较相邻的两个元素。
如果前一个元素大于后一个元素（升序排序），则交换它们的位置。
每轮排序结束后，最大的元素会被移动到当前未排序部分的末尾。
重复上述步骤，直到所有元素都排序完成。

public class BubbleSort {// 基本冒泡排序实现public static void bubbleSort(int[] arr) {if (arr == null || arr.length <= 1) {return; // 数组为空或长度为1时无需排序}int n = arr.length;// 进行n-1轮排序for (int i = 0; i < n - 1; i++) {// 每轮排序比较到未排序部分的末尾for (int j = 0; j < n - i - 1; j++) {// 如果前一个元素大于后一个元素，交换它们if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}// 测试方法public static void main(String[] args) {int[] arr = {5, 2, 9, 3, 6};System.out.println("排序前的数组：");for (int num : arr) {System.out.print(num + " ");}bubbleSort(arr);System.out.println("\n排序后的数组：");for (int num : arr) {System.out.print(num + " ");}}
}

四、冒泡排序的时间复杂度和空间复杂度

时间复杂度

冒泡排序的时间复杂度主要取决于比较和交换操作的次数。在最坏情况下，即数组完全逆序时，每一轮排序都需要进行大量的比较和交换。对于长度为 n 的数组，第一轮需要比较 n-1 次，第二轮需要比较 n-2 次…… 第 n-1 轮需要比较 1 次，总的比较次数为 (n-1)+(n-2)+…+1 = n (n-1)/2，交换次数也与比较次数相当，因此最坏时间复杂度为 O (n²)。

在最好情况下，即数组已经有序时，如果不进行优化，冒泡排序仍然会进行 n-1 轮排序，每轮比较 n-i-1 次，总的比较次数还是 n (n-1)/2，时间复杂度为 O (n²)。但如果进行优化（如添加标志位），在最好情况下可以让时间复杂度优化到 O (n)。

在平均情况下，冒泡排序的时间复杂度也是 O (n²)。

空间复杂度

由于冒泡排序是原地排序算法，排序过程中只需要一个临时变量用于交换元素，不需要额外的存储空间，因此空间复杂度为 O (1)。

五、冒泡排序的优化方法

虽然冒泡排序的时间复杂度较高，但我们可以通过一些优化方法来提高它的效率。

优化一：添加标志位

在实际排序过程中，数组可能在未完成所有轮次排序时就已经有序了。如果我们能检测到这种情况并提前结束排序，就能节省大量的时间。我们可以添加一个标志位，用于记录每轮排序中是否发生了元素交换。如果某一轮排序中没有发生交换，说明数组已经有序，就可以提前退出循环。

优化后的代码如下：

public class OptimizedBubbleSort1 {// 添加标志位优化的冒泡排序public static void optimizedBubbleSortWithFlag(int[] arr) {if (arr == null || arr.length <= 1) {return;}int n = arr.length;for (int i = 0; i < n - 1; i++) {boolean swapped = false; // 标志位，初始化为falsefor (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;swapped = true; // 发生交换，将标志位置为true}}// 如果没有发生交换，说明数组已经有序，提前退出if (!swapped) {break;}}}// 测试方法public static void main(String[] args) {int[] arr = {5, 2, 9, 3, 6};System.out.println("排序前的数组：");for (int num : arr) {System.out.print(num + " ");}optimizedBubbleSortWithFlag(arr);System.out.println("\n排序后的数组：");for (int num : arr) {System.out.print(num + " ");}}
}

优化二：记录最后一次交换的位置

在每轮排序中，最后一次交换元素的位置之后的元素都是已经有序的，下一轮排序时就不需要再比较这些元素了。我们可以记录下每轮最后一次交换的位置，作为下一轮排序的终点，从而减少比较的次数。

进一步优化后的代码如下：

public class OptimizedBubbleSort2 {// 记录最后一次交换位置优化的冒泡排序public static void furtherOptimizedBubbleSort(int[] arr) {if (arr == null || arr.length <= 1) {return;}int n = arr.length;int end = n - 1; // 初始的排序终点为数组末尾while (end > 0) {int lastSwap = 0; // 记录最后一次交换的位置for (int j = 0; j < end; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;lastSwap = j; // 更新最后一次交换的位置}}end = lastSwap; // 更新排序终点}}// 测试方法public static void main(String[] args) {int[] arr = {5, 2, 9, 3, 6};System.out.println("排序前的数组：");for (int num : arr) {System.out.print(num + " ");}furtherOptimizedBubbleSort(arr);System.out.println("\n排序后的数组：");for (int num : arr) {System.out.print(num + " ");}}
}