【转载】一看就懂的冒泡排序和【3】步深度优化法

最新推荐文章于 2022-08-20 20:29:02 发布

或许对了

最新推荐文章于 2022-08-20 20:29:02 发布

阅读量112

点赞数

分类专栏：数据结构与算法

原文链接：https://juejin.im/post/5d20abe3f265da1ba9159f48

版权

数据结构与算法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

如需转载，请标明地址
前言：各位小伙伴们，冒泡排序作为我入门编程第一个遇到的算法，对我来说意义非凡。今天闲来重新拾起了这个算法，发现它竟然还有这么大的优化空间，惊讶。那我们就来优化一下它吧！写这篇文章呢主要是想和在座的各位小伙伴分享一下我的优化历程，二来还可以方便以后复习。废话不多说。我们直接开始吧！

相比大家对冒泡排序法还是不陌生的，如果你是刚刚接触编程也没关系，请看我慢慢给你解答！
基础比较好的小伙伴可以直接略过

什么是冒泡排序？
冒泡排序（Bubble Sort）是一种较简单的排序算法。
通过比较两个相邻数组元素来达到由大(xiao)到小(da)排序数组的目的
我这么说是不是能明白一点呢？不明白也没关系，就让我们一起来看代码吧！

int[] array = {
9, 8, 7, 6, 5, 4, 3, 2, 1, 0
};
复制代码
这是一个0-9的倒序排列的数组，我们通过相邻元素的下标比对然后互换来完成从小到大的排序，如图：

这样我们就完成了将9放到了数组的最后。完成了一次排序。

怎么样，你是不是能明白了呢？
说到这里，那我们如何用代码来实现呢？

int[] array = {
9, 8, 7, 6, 5, 4, 3, 2, 1, 0
};
// 一次遍历，将相对最大的数放到数组底部
for (int j = 0; j < array.length - 1; j++) {
if (array[j] > array[j + 1]) {
int max = array[j];
array[j] = array[j + 1];
array[j + 1] = max;
}
}
复制代码
输出的结果： [8, 7, 6, 5, 4, 3, 2, 1, 0, 9]

那怎么完成所有元素的排序呢？
那就太好办了！再加一个循环吧！

int[] array = {
9, 8, 7, 6, 5, 4, 3, 2, 1, 0
};
int max = 0;

// 一次遍历，在倒序情况下最少遍历的次数
for (int i = 0; i < arrays.length - 1; i++) {
// 二次遍历，将相对最大的数放到数组底部
for (int j = 0; j < array.length - 1; j++) {
if (array[j] > array[j + 1]) {
max = array[j];
array[j] = array[j + 1];
array[j + 1] = max;
}
}
}
复制代码
输出结果： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

做到这里，我们发现了，这样的写法并不完美，有很多纰漏。大大影响了程序的性能。那我们应该怎么去优化呢？
我们的目的：

增加循环效率
减少无用的循环遍历和判断
最有用的办法就是观察算法的有效遍历数和实际遍历数

第一步优化
那我们就想办法先为程序减少一些循环吧！

我发现在执行二次遍历时，程序越运行到后面，所做的排序就越少，因为数组后面的元素都已排序完成，无需再进行循环判断

这样一想，我们的优化方案就有了！
一次遍历的计数（i）就相当于我们数组已经排好元素的个数

减去（i），就可以减少循环次数

int[] array = {
9, 8, 7, 6, 5, 4, 3, 2, 1, 0
};
// 程序有效运行的次数
int runCount = 0;
// 一共遍历的次数
int allCount = 0;
int max = 0;

// 一次遍历，在倒序情况下最少遍历的次数
for (int i = 0; i < array.length - 1; i++) {
// 二次遍历，将相对最大的数放到数组底部
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
max = array[j];
array[j] = array[j + 1];
array[j + 1] = max;
runCount += 1;
}
allCount += 1;
}
}
System.out.println("runCount = " + runCount);
System.out.println("allCount = " + allCount);
System.out.println(Arrays.toString(array));
复制代码
输出结果：

runCount = 45
allCount = 45
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
复制代码
从结果来看，有效遍历和实际遍历次数相同。
但是这是在极端情况下（完全倒序），我们拿到的数组大多数情况都是无序散乱的。这样的优化明显不能满足我们的要求。这又为第二次优化提供了思路…

第二步优化
往往散乱的数组实际所需的遍历次数是远小于极端情况（完全倒序）的，然而我们程序还是会进行循环遍历.

那我们不如做个判断，判断它是否需要进行实际遍历，如果不需要了。那数组肯定是排序完成了！那我们就可以跳出循环了。

这样一想，我们的优化方案又有了！
我们用无序数组进行测试
int[] array = {
3, 6, 2, 7, 9, 5, 0, 1, 4, 8
};
// 程序有效运行的次数
int runCount = 0;
// 一共遍历的次数
int allCount = 0;
int max = 0;
// flag判断排序是否完成 true-完成；false-未完成
boolean flag;

// 一次遍历，在倒序情况下最少遍历的次数
for (int i = 0; i < array.length - 1; i++) {
// 每次循环重置flag为true
flag = true;
// 二次遍历，将相对最大的数放到数组底部
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
max = array[j];
array[j] = array[j + 1];
array[j + 1] = max;
runCount += 1;
// 进入循环表示数组未排序完成，需再次循环
flag = false;
}
allCount += 1;
}
// 如果已经完成排序，则跳出循环
if (flag) {
break;
}

}
System.out.println("runCount = " + runCount);
System.out.println("allCount = " + allCount);
System.out.println(Arrays.toString(array));
复制代码
输出结果：

runCount = 22
allCount = 42
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
复制代码
未加判断输出结果：

runCount = 22
allCount = 45
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
复制代码
从结果可以看出来，比未加判断的实际遍历次数少了3次。

但是优化到此为止好像还是缺了点什么，如果数组天生有一部分就是无需排序的，那我们又会浪费很多次的循环，这么一想，第三步优化就有了方向。

第三步优化
如图：

后面的 5 6 7 8 9 本来就是排序完成的，那按照我们的代码还要去对后面的代码进行循环遍历，那样是很不科学的！

这样一想，我们的优化方案就完美了！
我用几个变量来动态记录数组所需遍历的次数就可以解决问题了。

int[] array = {
3, 6, 2, 7, 9, 5, 0, 1, 4, 8
};
// 程序有效运行的次数
int runCount = 0;
// 一共遍历的次数
int allCount = 0;
int max = 0;
// flag判断排序是否完成 true-完成；false-未完成
boolean flag;
// 无序数组循环边界，默认为数组长度array.length - 1
int sortBorder = array.length - 1;
// 记录数组最后进行排序的位置
int lastChange = 0;

// 一次遍历，在倒序情况下最少遍历的次数
for (int i = 0; i < array.length - 1; i++) {
// 每次循环重置flag为true
flag = true;
// 二次遍历，将相对最大的数放到数组底部
for (int j = 0; j < sortBorder; j++) {
if (array[j] > array[j + 1]) {
max = array[j];
array[j] = array[j + 1];
array[j + 1] = max;
runCount += 1;
// 进入循环表示数组未排序完成，需再次循环
flag = false;
// 记录数组最后进行排序的位置
lastChange = j;
}
allCount += 1;
}
// 动态设置无序数组循环边界
sortBorder = lastChange;
// 如果已经完成排序，则跳出循环
if (flag) {
break;
}
}
System.out.println("runCount = " + runCount);
System.out.println("allCount = " + allCount);
System.out.println(Arrays.toString(array));
复制代码
输出结果：