冒泡排序
1、基本介绍
-
思路：
通过对待排序序列从前向后（从小标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒
-
原理：
比较两个相邻的元素，将值大的元素交换至右端。
-
性能
1.如果我们的数据正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，即：Cmin=n-1;Mmin=0;所以，冒泡排序最好的时间复杂度为O(n)。
2.如果很不幸我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
冒泡排序的最坏时间复杂度为：O(n2) 。综上所述：冒泡排序总的平均时间复杂度为：O(n2)
2、举例
排序数组：int[] arr={6,3,8,2,9,1};
第一趟排序：
第一次排序：6和3比较，6大于3，交换位置： 3 6 8 2 9 1
第二次排序：6和8比较，6小于8，不交换位置：3 6 8 2 9 1
第三次排序：8和2比较，8大于2，交换位置： 3 6 2 8 9 1
第四次排序：8和9比较，8小于9，不交换位置：3 6 2 8 9 1
第五次排序：9和1比较：9大于1，交换位置： 3 6 2 8 1 9
第一趟总共进行了5次比较， 排序结果： 3 6 2 8 1 9
---------------------------------------------------------------------
第二趟排序：
第一次排序：3和6比较，3小于6，不交换位置：3 6 2 8 1 9
第二次排序：6和2比较，6大于2，交换位置： 3 2 6 8 1 9
第三次排序：6和8比较，6大于8，不交换位置：3 2 6 8 1 9
第四次排序：8和1比较，8大于1，交换位置： 3 2 6 1 8 9
第二趟总共进行了4次比较， 排序结果： 3 2 6 1 8 9
---------------------------------------------------------------------
第三趟排序：
第一次排序：3和2比较，3大于2，交换位置： 2 3 6 1 8 9
第二次排序：3和6比较，3小于6，不交换位置：2 3 6 1 8 9
第三次排序：6和1比较，6大于1，交换位置： 2 3 1 6 8 9
第二趟总共进行了3次比较， 排序结果： 2 3 1 6 8 9
---------------------------------------------------------------------
第四趟排序：
第一次排序：2和3比较，2小于3，不交换位置：2 3 1 6 8 9
第二次排序：3和1比较，3大于1，交换位置： 2 1 3 6 8 9
第二趟总共进行了2次比较， 排序结果： 2 1 3 6 8 9
---------------------------------------------------------------------
第五趟排序：
第一次排序：2和1比较，2大于1，交换位置： 1 2 3 6 8 9
第二趟总共进行了1次比较， 排序结果： 1 2 3 6 8 9
---------------------------------------------------------------------
最终结果：1 2 3 6 8 9
---------------------------------------------------------------------
3、代码实现
第一版
public class BubbleSortNormal {
6 public static void main(String[] args) {
7 int[] list = {3,4,1,5,2};
8 int temp = 0; // 开辟一个临时空间, 存放交换的中间值
9 // 要遍历的次数
10 for (int i = 0; i < list.length-1; i++) {
11 System.out.format("第 %d 遍：\n", i+1);
12 //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
13 for (int j = 0; j < list.length-1-i; j++) {
14 // 比较相邻的元素，如果前面的数小于后面的数，就交换
15 if (list[j] < list[j+1]) {
16 temp = list[j+1];
17 list[j+1] = list[j];
18 list[j] = temp;
19 }
20 System.out.format("第 %d 遍的第%d 次交换：", i+1,j+1);
21 for(int count:list) {
22 System.out.print(count);
23 }
24 System.out.println("");
25 }
26 System.out.format("第 %d 遍最终结果：", i+1);
27 for(int count:list) {
28 System.out.print(count);
29 }
30 System.out.println("\n#########################");
31 }
32 }
33 }
思路
外层循环：即主循环，需要辅助我们找到当前第 i 小的元素来让它归位。所以我们会一直遍历 n-2 次，这样可以保证前 n-1 个元素都在正确的位置上，那么最后一个也可以落在正确的位置上了。
内层循环：即副循环，需要辅助我们进行相邻元素之间的比较和换位，把大的或者小的浮到水面上。所以我们会一直遍历 n-1-i 次这样可以保证没有归位的尽量归位，而归位的就不用再比较了。
而上面的问题，出现的原因也来源于这两次无脑的循环，正是因为循环不顾一切的向下执行，所以会导致在一些特殊情况下得多余。例如 5，4，3，1，2 的情况下，常规版会进行四次循环，但实际上第一次就已经完成排序了。
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q7cCwWoD-1616402033671)(https://t-images-1304141946.cos.ap-hongkong.myqcloud.com/blog/1378215-20190726141202260-350678717.png)]
优化一
public class BubbleSoerOpt1 {
6 public static void main(String[] args) {
7 int[] list = {5,4,3,1,2};
8 int temp = 0; // 开辟一个临时空间, 存放交换的中间值
9 // 要遍历的次数
10 for (int i = 0; i < list.length-1; i++) {
11 int flag = 1; //设置一个标志位
12 //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
13 for (int j = 0; j < list.length-1-i; j++) {
14 // 比较相邻的元素，如果前面的数小于后面的数，交换
15 if (list[j] < list[j+1]) {
16 temp = list[j+1];
17 list[j+1] = list[j];
18 list[j] = temp;
19 flag = 0; //发生交换，标志位置0
20 }
21 }
22 System.out.format("第 %d 遍最终结果：", i+1);
23 for(int count:list) {
24 System.out.print(count);
25 }
26 System.out.println("");
27 if (flag == 1) {//如果没有交换过元素，则已经有序
28 return;
29 }
30
31 }
32 }
33 }
运行结果：可以看到优化效果非常明显，比正常情况下少了两次的循环。
这个时候我们就来讨论一下上面留下的一个小地方！没错就是最优时间复杂度为O(n)的问题，我们在进行了这一次算法优化之后，就可以做到了。
当给我们一个数列，5，4，3，2，1，让我们从大到小排序。没错，这是已经排好序的啊，也就是说因为标志位的存在，上面的循环只会进行一遍，flag没有变成1，整个算法就结束了，这也就是 O(n) 的来历了！
优化二
在冒泡排序中还有一个问题存在，就是第 i 趟排的第 i 小或者大的元素已经在第 i 位上了，甚至可能第 i-1 位也已经归位了，那么在内层循环的时候，有这种情况出现就会导致多余的比较出现。例如：6，4，7，5，1，3，2，当我们进行第一次排序的时候，结果为6，7，5，4，3，2，1，实际上后面有很多次交换比较都是多余的，因为没有产生交换操作。
解决：
我们可以想到，利用一个标志位，记录一下当前第 i 趟所交换的最后一个位置的下标，在进行第 i+1 趟的时候，只需要内循环到这个下标的位置就可以了，因为后面位置上的元素在上一趟中没有换位，这一次也不可能会换位置了。基于这个原因，我们可以进一步优化我们的代码。
public class BubbleSoerOpt2 {
6 public static void main(String[] args) {
7 int[] list = {6,4,7,5,1,3,2};
8 int len = list.length-1;
9 int temp = 0; // 开辟一个临时空间, 存放交换的中间值
10 int tempPostion = 0; // 记录最后一次交换的位置
11 // 要遍历的次数
12 for (int i = 0; i < list.length-1; i++) {
13 int flag = 1; //设置一个标志位
14 //依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
15 for (int j = 0; j < len; j++) {
16 // 比较相邻的元素，如果前面的数小于后面的数，交换
17 if (list[j] < list[j+1]) {
18 temp = list[j+1];
19 list[j+1] = list[j];
20 list[j] = temp;
21 flag = 0; //发生交换，标志位置0
22 tempPostion = j; //记录交换的位置
23 }
24 System.out.format("第 %d 遍第%d 趟结果：", i+1, j+1);
25 for(int count:list) {
26 System.out.print(count);
27 }
28 System.out.println("");
29 }
30 len = tempPostion; //把最后一次交换的位置给len，来缩减内循环的次数
31 System.out.format("第 %d 遍最终结果：", i+1);
32 for(int count:list) {
33 System.out.print(count);
34 }
35 System.out.println("");
36 if (flag == 1) {//如果没有交换过元素，则已经有序
37 return;
38 }
39
40 }
41 }
42 }
扫一扫
585
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
