深入解析冒泡排序算法：原理、优化与实现_冒泡排序的实现和优化-CSDN博客

本文链接：https://blog.csdn.net/u012372850/article/details/144717041

冒泡排序（Bubble Sort）是一种简单的排序算法，通过重复遍历待排序的元素，逐步将最大（或最小）元素“冒泡”到序列的末端（或前端）。尽管它在实践中的效率较低，但因其算法简单，易于理解，仍然是学习排序算法的一个经典例子。

一. 冒泡排序的工作原理

冒泡排序的基本思想是：通过相邻元素的比较与交换，使得较大的元素逐渐向序列的末尾“冒泡”，而较小的元素则逐渐向序列的前端移动。
详细步骤：
（1）从序列的第一个元素开始，依次比较相邻的两个元素。
（2）如果当前元素大于下一个元素，则交换它们的位置；否则，不做任何操作。
（3）一轮比较完成后，最大的元素被“冒泡”到了序列的末尾。
（4）重复上述步骤，忽略已排好序的部分，每一轮都会减少比较的范围。
（5）当一轮比较没有发生任何交换时，说明排序已经完成，可以提前终止。

二. 冒泡排序的时间复杂度

（1）最坏时间复杂度： O(n²)，发生在输入数据是逆序的情况下。
（2）最优时间复杂度： O(n)，发生在输入数据已经有序时（可以通过加入标志位优化）。
（3）空间复杂度： O(1)，冒泡排序是原地排序算法，不需要额外的存储空间。

三. 冒泡排序的稳定性

冒泡排序是一种稳定的排序算法。原因是如果两个元素相等，它们的相对位置不会发生改变。因此，在排序过程中不会打乱相等元素的相对顺序。

四. 冒泡排序的Java实现

下面是一个基本的冒泡排序的Java实现：

public class BubbleSort {

// 冒泡排序方法
public static void bubbleSort(int[] arr) {
int n = arr.length;
boolean swapped;

// 外层循环，控制排序的次数
for (int i = 0; i &lt; n - 1; i++) {
swapped = false; // 用来标记是否发生了交换

// 内层循环，进行相邻元素的比较和交换
for (int j = 0; j &lt; n - 1 - i; j++) {
if (arr[j] &gt; arr[j + 1]) {
// 交换相邻元素
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;

// 标记有交换发生
swapped = true;
}
}

// 如果没有发生交换，提前退出
if (!swapped) {
break;
}
}
}

// 打印数组
public static void printArray(int[] arr) {
for (int i = 0; i &lt; arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}

public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};

System.out.println("原始数组：");
printArray(arr);

bubbleSort(arr);

System.out.println("排序后的数组：");
printArray(arr);
}
}

代码解析：

（2）外层循环：控制排序的轮数，从第一个元素到倒数第二个元素，每完成一轮，最大的元素被冒泡到数组的末尾，因此内层循环范围逐渐缩小。
（2）内层循环：进行相邻元素的比较，如果前一个元素大于后一个元素，则交换它们的位置。
（3）优化：通过引入 swapped 变量来检测每一轮是否发生了交换，如果没有交换，说明数组已经有序，可以提前结束排序。
（4）printArray 方法：用于打印数组，帮助验证排序结果。

输出示例：
原始数组：
64 34 25 12 22 11 90
排序后的数组：
11 12 22 25 34 64 90

五. 冒泡排序的优化

冒泡排序的基本实现已经在上面提供了，但我们可以做一些优化来提升其性能：
（1）提前退出：在每一轮排序后，如果没有发生任何交换，说明数组已经有序，我们可以提前结束排序。
（2）缩小排序范围：每完成一轮排序，最大的元素已经被正确放置在了末尾，因此下一轮排序的范围可以缩小。

优化后的Java代码：
public class OptimizedBubbleSort {

// 优化后的冒泡排序方法
public static void bubbleSort(int[] arr) {
int n = arr.length;
boolean swapped;

// 外层循环，控制排序的次数
for (int i = 0; i &lt; n - 1; i++) {
swapped = false; // 用来标记是否发生了交换

// 内层循环，进行相邻元素的比较和交换
for (int j = 0; j &lt; n - 1 - i; j++) {
if (arr[j] &gt; arr[j + 1]) {
// 交换相邻元素
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;

// 标记有交换发生
swapped = true;
}
}

// 如果没有发生交换，提前退出
if (!swapped) {
break;
}
}
}

// 打印数组
public static void printArray(int[] arr) {
for (int i = 0; i &lt; arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}

public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};

System.out.println("原始数组：");
printArray(arr);

bubbleSort(arr);

System.out.println("排序后的数组：");
printArray(arr);
}
}

主要优化：

（1）在每一轮排序中，如果没有发生交换，就立即跳出排序过程。
（2）每完成一轮排序，排序的范围就可以缩小。