排序算法之五--冒泡排序及其改进

冒泡排序

冒泡排序是非常好理解的一种排序，每一次排序都可以确定一个元素最终的位置

排序算法（从小到大）：

        1.对序列从第一个元素到最后一个元素遍历，如果当前元素小于下一个元素，则交换位置

        2.第 i 次遍历，从第一个元素到最后 n-i 个元素,如果当前元素小于下一个元素，则交换位置

        3.重复2直至第n-1次遍历，输出序列

排序算法演示（从小到大）：

       原序列                      9   8   7   4   3    1   2   5    6     

       第一次遍历结束        8   7   4   3   1    2   5   6  9

      第二次遍历结束        7   4   3   1    2   5   6    8  9

      第三次遍历结束        4   3   1    2   5   6  7   8   9

      第四次遍历结束        3   1    2   4   5   6   7    8   9  

      第五次遍历结束        1   2   3    4  5   6   7    8   9

     。。。

      最后的序列               1   2   3    4   5   6   7    8   9

冒泡排序c语言实现：

冒泡排序最原始代码：

                void BubbleSort(int a[], int n) {

                       for (int i=0; i<n; i++) {

                             for(int j=0; j<n; j++) {

                                   if(a[j-1] < a[j]) {

                                           Swap(a[j-1], a[j]);

                                   }

                             }

                       }

                 }

冒泡排序改进1：对于上面排序算法的演示中，当第五次遍历结束时，第二次遍历就没有发生任何的元素交换，那么则表示说明 排序

已经完成，则后面的遍历就不需要再做了，因此可以设置一个标志，当某一次遍历没有发生元素交换的时候，就不需要继续排序了。

冒泡排序改进代码：

1. void BubbleSort2(int a[], int n)  
2. {  
3.        int j, k;  
4.        bool flag;  
5.   
6.        k = n;  
7.        flag = true;  
8.        while (flag)  
9.        {  
10.               flag = false;  
11.               for (j = 1; j < k; j++)  
12.                      if (a[j - 1] > a[j])  
13.                      {  
14.                             Swap(a[j - 1], a[j]);  
15.                             flag = true;  
16.                      }  
17.               k--;  
18.        }  
19. }  

冒泡排序改进2：如果一个数组在0-i是需要交换的，但是后面i+1-n是有序的不需要交换的（大于前面十个数），此时只需要前面十个数之间交换即可

1. //冒泡排序3  
2. void BubbleSort3(int a[], int n)  
3. {  
4.     int j, k;  
5.     int flag;  
6.       
7.     flag = n;  
8.     while (flag > 0)  
9.     {  
10.         k = flag;  
11.         flag = 0;  
12.         for (j = 1; j < k; j++)  
13.             if (a[j - 1] > a[j])  
14.             {  
15.                 Swap(a[j - 1], a[j]);  
16.                 flag = j;  
17.             }  
18.     }  
19. }  

冒泡排序毕竟是一种效率低下的排序方法，在数据规模很小时，可以采用。数据规模比较大时，最好用其它排序方法。

（代码借鉴http://blog.csdn.net/morewindows/article/details/6657829）

时间复杂度：

       最好情况：序列本身就是有序的，一次遍历即可，时间复杂度O(n)

       最差情况：序列完全是反序的，需要n次遍历，时间复杂度O(n2)

       平均情况：O(n2)

空间复杂度：只需要一个存储空间中转即可，为O(1)

稳定性：稳定