冒泡

BubbleSort

     冒泡排序是许多人接触的第一种排序方式，由于这种方式比较简单，所以大部分人也没有深入研究，所以写出的代码是这样的：

[cpp] view plain copy

1. void BubbleSort(int *arr, int len)  
2. {  
3.     assert(arr);  
4.     int i = 0;  
5.     int j = 0;  
6.     int tmp = 0;  
7.     for (i = 0; i < len - 1; i++)  
8.     {  
9.         for (j = 0; j < len -i- 1; j++)       //每排序一趟，则必然后面有一个已经有序，可以减少循环缩小排序的范围  
10.         {  
11.             if (arr[j]>arr[j + 1])  
12.             {  
13.                 tmp = arr[j];  
14.                 arr[j] = arr[j + 1];  
15.                 arr[j + 1] = tmp;  
16.             }  
17.         }  
18.     }  
19. }  

其实我想告诉你的是冒泡排序还有三种优化方式：（以下都是以升序为例）

例如要排序下面这组数据： 1   2   3   4   5   6   7   8   10  9

    按照上面的排序方式，第一趟将10 与 9交换后已经就有序了，所以接下来的8趟都是多余的。这时我们可以加一个标记来判断每一趟排序时是否交换过数据，如果哪一趟排序没有交换数据，则这时就已经有序了。

[cpp] view plain copy

1. void BubbleSort(int *arr, int len)  
2. {  
3.     assert(arr);  
4.     int i = 0;  
5.     int j = 0;  
6.     int flag = 0;  
7.     int tmp = 0;  
8.     for (i = 0; i < len - 1; i++)  
9.     {  
10.         flag = 1;                              //flag初始时为1  
11.         for (j = 0; j < len - i - 1; j++)       //每排序一趟，则必然后面有一个已经有序，可以缩小排序的范围  
12.         {  
13.             if (arr[j]>arr[j + 1])             //只要要交换数据，则flag就会被修改  
14.             {  
15.                 tmp = arr[j];  
16.                 arr[j] = arr[j + 1];  
17.                 arr[j + 1] = tmp;  
18.                 flag = 0;                    //只要这组数还未完全有序，则一定会修改flag为0  
19.             }  
20.         }  
21.         if (flag)                             //如果排序一趟，发现已经有序，则不进入if,flag没被修改  
22.         {  
23.             break;  
24.         }  
25.     }  
26. }  

 这样修改之后虽然提高了冒泡排序的效率，但是还是不是最理想的！！！

例如现在要排序下面这组数据：1  2  5  7  4   3   6   8  9  10

根据上面的算法我们可以写出如下代码：

[cpp] view plain copy

1. void BubbleSort(int *arr, int len)  
2. {  
3.     assert(arr);  
4.     int i = 0;  
5.     int j = 0;  
6.     int flag = 0;  
7.     int tmp = 0;  
8.     int m = 0;                  //用来记录最后一次交换的位置  
9.     int k = len-1;  
10.     for (i = 0; i < len - 1; i++)  
11.     {  
12.         m = 0;  
13.         flag = 1;  
14.         for (j = 0; j < k; j++)       //无序区的范围只从第一个元素，到上一趟最后一次交换的位置k  
15.         {  
16.             if (arr[j]>arr[j + 1])  
17.             {  
18.                 tmp = arr[j];  
19.                 arr[j] = arr[j + 1];  
20.                 arr[j + 1] = tmp;  
21.                 flag = 0;                    //只要这组数还未完全有序，则一定会修改flag为0  
22.                 m = j;  
23.             }  
24.         }  
25.         if (flag)                             //如果排序一趟，发现已经有序，则不进入if,flag没被修改  
26.         {  
27.             break;  
28.         }  
29.         k = m;                             //将k置成最后一次交换的位置  
30.     }  
31. }  

写成上面这种方式 ，冒泡排序的效率已经得到了极大的提升，下面我们再来介绍第三种优化的方法！！！

    对下面这组这组数进行排序：2  3  4  5  6  7  8  9  10  1

根据上面的算法，我们可以写出如下代码：

[cpp] view plain copy

1. void BubbleSort(int *arr, int len)  
2. {  
3.     assert(arr);  
4.     int i = 0;  
5.     int j = 0;  
6.     int flag = 0;  
7.     int m = 0;       //记录最后一次交换的位置  
8.     int n = 0;  
9.     int k = len - 1;  
10.     for (i = 0; i < len - 1; i++)  
11.     {  
12.         m = 0;  
13.         flag = 1;  
14.         //正序扫描找最大值  
15.         for (j = n; j < k; j++)       //无序区的范围只从第一个元素，到上一趟最后一次交换的位置k  
16.         {  
17.             if (arr[j]>arr[j + 1])  
18.             {  
19.   
20.                 int tmp = arr[j];  
21.                 arr[j] = arr[j + 1];  
22.                 arr[j + 1] = tmp;  
23.                 flag = 0;                    //只要这组数还未完全有序，则一定会修改flag为0  
24.                 m = j;  
25.             }  
26.         }  
27.         k = m;  
28.         if (flag)                    //如果排序一趟，发现已经有序，则不进入if,flag没被修改  
29.         {  
30.             break;  
31.         }  
32.         //反序扫描找最小值  
33.         for (j = k; j>n; j--)       //无序区的范围只从第一个元素，到上一趟最后一次交换的位置k  
34.         {  
35.             if (arr[j]<arr[j - 1])  
36.             {  
37.                 int tmp = arr[j];  
38.                 arr[j] = arr[j - 1];  
39.                 arr[j - 1] = tmp;  
40.                 flag = 0;                    //只要这组数还未完全有序，则一定会修改flag为0  
41.             }  
42.         }  
43.         n++;  
44.         if (flag)                    //如果排序一趟，发现已经有序，则不进入if,flag没被修改  
45.         {  
46.             break;  
47.         }                           //将k置成最后一次交换的位置  
48.     }  
49. }