冒泡排序总结

在开发中，对一组数据进行有序地排列是经常需要做的事情，所以掌握几种甚至更多的排序算法是绝对有必要的

本文章介绍的是排序算法中较简单的一种算法：冒泡排序

题外话：在深入学习更多排序算法后和在实际使用情况中，冒泡排序的使用还是极少的。它适合数据规模很小的时候，而且它的效率也比较低，但是作为入门的排序算法，还是值得学习的

先尝试用最简单的想法去实现排序，以此来比较学习冒泡排序

问题：设有一数组，其大小为10个元素（int   str[10]）数组内的数据是无序。现在要求我们通过编程将这个无序的数组变成一个从小到大排序的数组（从下标为0开始）

思路：按照题目的要求，毫无疑问，正确的结果应该就像这样： 1 2 3 4 5 6 7 8 9 10   要做到这样，最简单和最直接想到的方法就是进行对比交换。

• 首先，把10个数里最小的个数放到下标为0的位置上（str[0]）
• 通过将下标为0的数（str[0]）与剩下其余9个数进行对比交换（将较少者放置在下标为0的位置上），就可以得到这10个数最小的那个
• 10个数最小的那位确定后，接下来就要找剩下9个数最小的那个。
• 因为已经确定出一个最小的数，所以就不要动str[0]，直接从str[1]开始，与剩下的8个数对比交换，找出9个数中最小的那位放到下标为1（str[1]）的位置上
• 继续按照这个思路就可以将这十个数变成有序的（从小到大）的数组

代码：

[cpp] view plain copy

 print?

1. #include <stdio.h>  
2.   
3. void swap(int *a, int *b); //交换两个数  
4.   
5. int main()  
6. {  
7.     int     str[10];  
8.     int     i, j;  
9.     //初始化数组为10 9 8 7 6 5 4 3 2 1  
10.     for (i = 0; i < 10; i++)  
11.     {  
12.         str[i] = 10 - i;  
13.     }  
14.     //排序，从a[0]开始排，从小到大  
15.     for (i = 0; i < 10; i++)  
16.     {  
17.         for (j = i + 1; j < 10; j++)  
18.         {  
19.             if (str[i] > str[j])  
20.             {  
21.                 swap(&str[i], &str[j]);  
22.             }  
23.         }  
24.     }  
25.         //将十个数输出  
26.     for (i = 0; i < 10; i++)  
27.         printf("%d\n", str[i]);  
28.     return    0;  
29. }  
30. void swap(int *a, int *b)  
31. {  
32.     int     c;  
33.      c = *a;  
34.     *a = *b;  
35.     *b =  c;  
36. }  

这个方法是比较容易想到的实现方法。但存在不足：就是本来位于前面的较小数被交换到后面

演示：

开始：9 4 5 6 8 3 2 7 10 1  （下标从左到右分别是0~9）按照上面的程序进行对比交换

第一次：4 9 5 6 8 3 2 7 10 1 

第二次：4 9 5 6 8 3 2 7 10 1 

。。。：（没有交换）

第五次：3 9 5 6 8 4 2 7 10 1 

第六次：2 9 5 6 8 3 4 7 10 1 

。。。：（没有交换）

第十次：1 9 5 6 8 3 4 7 10 2 

可以看出，原来较小的数是在前面的，经过一轮的交换后放到后面了

那么怎样解决这个不足呢？可以使用冒泡排序

什么是冒泡排序呢？

你可以这样理解：（从小到大排序）存在10个不同大小的气泡，由底至上地把较少的气泡逐步地向上升，这样经过遍历一次后，最小的气泡就会被上升到顶（下标为0），然后再从底至上地这样升，循环直至十个气泡大小有序。

在冒泡排序中，最重要的思想是两两比较，将两者较少的升上去

冒泡排序最坏情况的时间复杂度是O(n²)

代码：

[cpp] view plain copy

 print?

1. #include <stdio.h>  
2. void swap(int *a, int *b);  
3. int main()  
4. {  
5.     int    array[10] = {15, 225, 34, 42, 52, 6, 7856, 865, 954, 10};  
6.     int    i, j;  
7.     for (i = 0; i < 10; i++)  
8.     {  
9.         //每一次由底至上地上升  
10.         for (j = 9; j > i; j--)  
11.         {  
12.             if (array[j] < array[j-1])  
13.             {  
14.                     swap(&array[j], &array[j-1]);  
15.             }  
16.         }  
17.     }  
18.     for (i = 0; i < 10; i++)  
19.     {  
20.         printf("%d\n", array[i]);  
21.     }  
22.     return    0;  
23. }  
24. void swap(int *a, int *b)  
25. {  
26.     int    temp;  
27.     temp = *a;  
28.       *a = *b;  
29.       *b = temp;  
30. }  

冒泡排序算法只会将较少的逐步向上推，不会造成文章前面所说的不足，这里就不给予演示。

有些追求完美的人就会思考，冒泡排序能不能优化呢？

答案是能的。

先来说说，冒泡排序哪些地方需要优化：

根据上一篇文章的内容，可以知道冒泡排序的核心是两两对比进行交换。如果有一个无序数列（2，1，3，4，5，6，7，8，9，10）

按照上一篇文章的代码，从第一次循环交换后的操作，可以说都是没必要的。所以，这些操作就是我们需要优化的地方。

那么如何优化？

通过观察可以看到，造成没必要的操作主要原因是后面8个数的顺序都已经是有序。所以，我们可以通过设置一个标记变量，标记数列中的数是否在循环结束前就已经排好序

代码：

[cpp] view plain copy

 print?

1. #include <stdio.h>  
2. void swap(int *a, int *b);  
3. int main()  
4. {  
5.     int    array[10] = {2, 1, 3, 4, 5, 6, 7, 8, 9, 10};  
6.     int    i, j;  
7.     int    flag = 1;   //设置标记变量  
8.     for (i = 0; i < 10 && flag; i++)  
9.     {  
10.         flag = 0;      //只要flag在下一次外循环条件检测的时候值为0，就说明已经排好序，不用继续循环  
11.         for (j = 9; j > i; j--)  
12.         {  
13.             if (array[j] < array[j-1])  
14.             {  
15.                 swap(&array[j], &array[j-1]);  
16.                 flag = 1;   //如果有交换，就将标记变量赋1  
17.             }  
18.         }  
19.     }  
20.   
21.     for (i = 0; i < 10; i++)  
22.     {  
23.         printf("%d\n", array[i]);  
24.     }  
25.     return    0;  
26. }  
27. void swap(int *a, int *b)  
28. {  
29.     int    temp;  
30.     temp = *a;  
31.       *a = *b;  
32.       *b = temp;  
33. }  

根据优化过的代码，当最好情况的时候，冒泡排序的时间复杂度是O(n)