一、引言
冒泡排序是一种基础的比较排序算法，它的思想很简单：重复地遍历待排序的元素列表，比较相邻元素，如果它们的顺序不正确，则交换它们。这个过程不断重复，直到整个数组都排序好。冒泡排序的时间复杂度为O(n^2)，因此不适用于大规模数据集，但对于小型数据集是一个很好的算法。
二、算法步骤
冒泡排序的基本步骤如下：
1.从数组的第一个元素开始，依次比较相邻的两个元素。
2.如果前一个元素大于后一个元素，交换它们。
3.继续向数组的下一对元素执行相同的操作，直到达到数组末尾。
4.重复步骤1-3，直到没有任何交换发生，这时数组已经排序完成。
三、原理演示
假设我们有以下整数数组：
[5, 3, 1, 4, 2]
- 第一轮：
在第一轮中，算法将比较相邻的元素并进行交换，使较大的元素 “冒泡” 到数组的末尾。
比较 5 和 3，交换它们，数组变为： [3, 5, 1, 4, 2]
比较 5 和 1，交换它们，数组变为： [3, 1, 5, 4, 2]
比较 5 和 4，交换它们，数组变为： [3, 1, 4, 5, 2]
比较 5 和 2，交换它们，数组变为： [3, 1, 4, 2, 5]
在第一轮结束时，最大的元素 5 已经被移动到数组的最后。- 第二轮：
在第二轮中，算法再次遍历数组，比较相邻元素并进行交换。
比较 3 和 1，交换它们，数组变为： [1, 3, 4, 2, 5]
比较 3 和 4，不交换。
比较 4 和 2，交换它们，数组变为： [1, 3, 2, 4, 5]
比较 4 和 5，不交换。
在第二轮结束时，第二大的元素 4 已经被移动到数组的倒数第二位。- 第三轮：
继续相同的过程。
比较 1 和 3，不交换。
比较 3 和 2，交换它们，数组变为： [1, 2, 3, 4, 5]
比较 3 和 4，不交换。
在第三轮结束时，第三大的元素 3 已经被移动到数组的倒数第三位。- 第四轮：
比较 1 和 2，不交换。
在第四轮结束时，第四大的元素 2 已经被移动到数组的倒数第四位。- 第五轮：
比较 1 和 2，不交换。
在第五轮结束时，数组已经完全排序。最终，冒泡排序算法完成了对整数数组的排序。
冒泡排序算法会在每一轮中将一个最大的元素 “冒泡” 到数组的末尾，这就是为什么它被称为冒泡排序。算法不断重复这个过程，直到没有需要交换的元素，这时数组已经排好序。冒泡排序虽然不是最高效的排序算法，但它对于理解排序算法的基本概念是非常有帮助的。
四、代码实战
以下是两种冒泡排序的实现代码，大家看看哪种更适合你，易于理解。
public class BubbleSort {
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);
}
// 冒泡排序实现
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 - i - 1; 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;
swapped = true;
}
}
// 如果在一轮循环中没有发生交换，数组已经排序完成
if (!swapped) {
break;
}
}
}
// 辅助方法，用于打印数组
public static void printArray(int[] arr) {
for (int value : arr) {
System.out.print(value + " ");
}
System.out.println();
}
}
上述代码演示了冒泡排序的实现。它首先定义了一个包含整数数组的示例，然后调用 bubbleSort 方法来对数组进行排序。bubbleSort 方法使用两个嵌套的循环来比较相邻元素并交换它们，直到整个数组都排好序。在每一轮循环结束后，检查是否发生了交换，如果没有交换发生，表示数组已经排序好，可以提前退出循环。
public class BubbleSort {
public static void main(String[] args) {
int[] array = {64, 34, 25, 12, 22, 11, 90};
System.out.println("Unsorted array: ");
printArray(array);
bubbleSort(array);
System.out.println("Sorted array: ");
printArray(array);
}
static void bubbleSort(int[] array) {
int n = array.length;
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < n-i-1; j++) {
if (array[j] > array[j+1]) {
// swap array[j+1] and array[j]
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
static void printArray(int[] array) {
int n = array.length;
for (int i = 0; i < n; ++i) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
在上述代码中，我们定义了一个bubbleSort方法来实现冒泡排序算法。该算法采用嵌套的for循环，外层循环用于遍历整个数组，内层循环用于比较相邻的元素并进行交换，直到整个数组都被排序完成。printArray方法用于打印未排序和已排序的数组。文章来源：https://www.toymoban.com/news/detail-713780.html
五、结论
我们一起来总结一下冒泡排序：文章来源地址https://www.toymoban.com/news/detail-713780.html
- 冒泡排序的基本思想是将相邻的元素进行比较和交换，将较大的元素逐渐“冒泡”到数列的末尾，从而实现升序或降序排列。
- 冒泡排序的时间复杂度为O(n^2)，其中n表示要排序的元素个数。这是因为在最坏情况下，冒泡排序需要遍历数列两次，每次遍历都需要进行n-1次比较和交换操作。
- 冒泡排序的空间复杂度为O(1)，因为它只需要使用一个额外的变量来交换相邻元素的位置。
- 冒泡排序是一种稳定的排序算法，即相同元素的相对位置在排序后不会改变。
- 冒泡排序对于小规模数据集来说表现尚可，但是对于较大规模数据集来说效率较低。因此，在实际应用中，通常会优先考虑使用其他更高效的排序算法，如快速排序、归并排序等。
- 可以通过对冒泡排序进行优化，如使用标志变量来记录数列是否已经完成排序，从而减少不必要的比较和交换操作，提高算法效率。但是这并不会改变冒泡排序的时间复杂度。
点赞收藏，富婆包养✋✋
到了这里，关于数据结构-冒泡排序Java实现的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
![[ 数据结构 -- 手撕排序算法第二篇 ] 冒泡排序](https://imgs.yssmx.com/Uploads/2024/02/501879-1.png)
