怎么使用冒泡排序算法（冒泡排序图文讲解）
怎么使用冒泡排序算法（冒泡排序图文讲解）迭代后，如果没有交换，则值 flag 为 false，这意味着元素已经排序，不需要执行进一步的迭代，这将减少执行时间并有助于优化冒泡排序。为了解决这个问题，我们可以引入一个额外的变量 flag 默认值为 false，如果发生元素交换，则设置为 true；否则，它被设置为 false。在每次迭代中，比较进行到最后一个未排序的元素。当所有未排序的元素都放在正确的位置时，数组就被排序了。bubbleSort(array) for i <- 1 to indexOfLastUnsortedElement-1 if leftElement > rightElement swap leftElement and rightElement end bubbleSortJava 实现冒泡排序/** * 冒泡排序 * * @className: BubbleSort
世界上只有少数人能够最终达到自己的理想。———— 毛姆《月亮与六便士》
一、算法思想冒泡排序，有时也称为下沉排序，是一种简单的排序算法，它重复遍历要排序的列表，比较每对相邻的元素，如果它们的顺序错误（升序或降序排列），则交换它们。 重复遍历列表直到不需要交换，这表明列表已排序。
二、工作流程假设我们试图按升序对元素进行排序。
- 从第一个索引开始，比较第一个和第二个元素。
- 如果第一个元素大于第二个元素，则交换它们。
- 现在，比较第二个和第三个元素。如果它们不满足条件则交换它们。
- 上述过程一直持续到最后一个元素。
对剩余的迭代进行相同的过程，每次迭代后，将未排序元素中最大的元素放在最后。
在每次迭代中，比较进行到最后一个未排序的元素。
当所有未排序的元素都放在正确的位置时，数组就被排序了。
bubbleSort(array)
for i <- 1 to indexOfLastUnsortedElement-1
if leftElement > rightElement
swap leftElement and rightElement
end bubbleSortJava 实现冒泡排序
/**
* 冒泡排序
*
* @className: BubbleSort
* @date: 2021/6/22 14:19
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {-2 45 0 11 -9};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
/**
* 冒泡排序
* 算法思想：比较相邻两个元素，如果第一个元素比第二个大，则交换位置
*
* @param arr
*/
public static void bubbleSort(int[] arr) {
int length = arr.length;
// 循环的轮数为：length - 1
for (int i = 0; i < length - 1; i ) {
// 每一轮需要比较的次数：length - i - 1
for (int j = 0; j < length - i - 1; j ) {
// 比较相邻两个元素，如果第一个元素比第二个大，则交换位置
if (arr[j] > arr[j 1]) {
int temp = arr[j];
arr[j] = arr[j 1];
arr[j 1] = temp;
}
}
}
}
}
优化冒泡排序算法
在上述算法中，即使数组已经排序，也会进行所有比较，这会增加执行时间。
为了解决这个问题，我们可以引入一个额外的变量 flag 默认值为 false，如果发生元素交换，则设置为 true；否则，它被设置为 false。
迭代后，如果没有交换，则值 flag 为 false，这意味着元素已经排序，不需要执行进一步的迭代，这将减少执行时间并有助于优化冒泡排序。
bubbleSort(array)
flag <- false
for i <- 1 to indexOfLastUnsortedElement-1
if leftElement > rightElement
swap leftElement and rightElement
flag <- true
end bubbleSort优化冒泡排序实现
import java.util.Arrays;
/**
* 冒泡排序优化
*
* @className: BubbleSort
* @date: 2021/6/22 14:19
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {-2 45 0 11 -9};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
/**
* 冒泡排序
* 算法思想：比较相邻两个元素，如果第一个元素比第二个大，则交换位置
*
* @param arr
*/
public static void bubbleSort(int[] arr) {
int length = arr.length;
// 循环的轮数为：length - 1
for (int i = 0; i < length - 1; i ) {
// 检查是否发生交换，默认为 false
boolean flag = false;
// 每一轮需要比较的次数：length - i - 1
for (int j = 0; j < length - i - 1; j ) {
// 比较相邻两个元素，如果第一个元素比第二个大，则交换位置
if (arr[j] > arr[j 1]) {
int temp = arr[j];
arr[j] = arr[j 1];
arr[j 1] = temp;
// 发生交换修改标识
flag = true;
}
}
// 如果没有发生交换，则说明数组是有序的，直接结束后续循环比较
if (!flag) {
break;
}
}
}
}四、冒泡排序的复杂度
|
时间复杂度 | |
|
最好 |
O(n) |
|
最差 |
O(n2 ) |
|
平均 |
O(n2 ) |
|
空间复杂度 |
O(1) |
|
稳定 |
是 |
冒泡排序比较相邻元素。
|
循环 |
比较次数 |
|
第一 |
(n - 1) |
|
第二 |
(n - 2) |
|
第三 |
(n - 3) |
|
... |
... |
|
最后 |
1 |
因此，比较的次数是：(n-1) (n-2) (n-3) ..... 1 = n(n-1)/2 ，几乎等于 n2，因此复杂性：O(n2)。此外，如果我们观察代码，冒泡排序需要两个循环，因此复杂度为 n*n = n2
- 最坏情况复杂度 O(n2)： 如果我们想将一个有序数组倒序排列，那么最坏的情况就会发生。
- 最佳案例复杂度 O(n)：如果数组已经排序，则不需要排序。
- 平均案例复杂度 O(n2)： 当数组的元素处于混乱的顺序（既不升也不降）时，就会发生这种情况。
- 空间复杂度是O(1)因为额外的变量用于交换。
- 在优化的冒泡排序算法中，使用了两个额外的变量。因此，空间复杂度为O(2)。
使用冒泡排序
- 复杂性无关紧要
- 排序的数据量较小
参考文章：
https://www.programiz.com/dsa/bubble-sort
