改进的冒泡排序算法

http://student.zjzk.cn/course_ware/data_structure/web/paixu/paixu8.1.1.1.htm

http://www.cnblogs.com/lanxuezaipiao/archive/2013/03/16/2963928.html

冒泡排序算法，是最基本的排序算法， 它属于交换排序。

冒泡排序过程

设想被排序的数组R[1..N]垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"（交换位置），如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。

性能分析

若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为"逆序"，则需进行n(n-1）/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n)。

冒泡排序实现

根据扫描方向不同，实现略有不同。

代码如下：

[cpp]  view plain  copy

1. void BubbleSort_1(int a[], int size)  
2. {  
3.     for (int i = 0; i < size -1; i++)  
4.     {  
5.         for (int j = size - 1; j > i ; j--)  
6.         {  
7.             if (a[j-1] > a[j])  
8.             {  
9.                 int temp = a[j-1];  
10.                 a[j-1] = a[j];  
11.                 a[j] = temp;  
12.             }  
13.         }  
14.     }  
15. }  

第一步优化

如果上面代码中，里面一层循环在某次扫描中没有执行交换，则说明此时数组已经全部有序列，无需再扫描了。因此，增加一个标记，每次发生交换，就标记，如果某次循环完没有标记，则说明已经完成排序。

[cpp]  view plain  copy

1. void BubbleSort_2(int a[], int size)  
2. {  
3.     bool bSwaped = true;  
4.     for (int i = 0; i < size -1; i++)  
5.     {  
6.         // 每次先重置为false  
7.         bSwaped = false;  
8.         for (int j = size - 1; j > i ; j--)  
9.         {  
10.             if (a[j-1] > a[j])  
11.             {  
12.                 int temp = a[j-1];  
13.                 a[j-1] = a[j];  
14.                 a[j] = temp;  
15.   
16.                 bSwaped = true;  
17.             }  
18.         }  
19.         // 如果上一次扫描没有发生交换，则说明数组已经全部有序，退出循环  
20.         if (!bSwaped)  
21.             break;  
22.     }  
23. }  

第二步优化

在第一步优化的基础上发进一步思考：如果R[0..i]已是有序区间，上次的扫描区间是R[i..n]，记上次扫描时最后 一次执行交换的位置为lastSwapPos，则lastSwapPos在i与n之间，不难发现R[i..lastSwapPos]区间也是有序的，否则这个区间也会发生交换；所以下次扫描区间就可以由R[i..n] 缩减到[lastSwapPos..n]。

[cpp]  view plain  copy

1. </pre><p><pre name="code" class="cpp">void BubbleSort_3(int a[], int size)  
2. {  
3.     int lastSwapPos = 0,lastSwapPosTemp = 0;  
4.     for (int i = 0; i < size - 1; i++)  
5.     {  
6.         lastSwapPos = lastSwapPosTemp;  
7.         for (int j = size - 1; j >lastSwapPos; j--)  
8.         {  
9.             if (a[j - 1] > a[j])  
10.             {  
11.                 int temp = a[j - 1];  
12.                 a[j - 1] = a[j];  
13.                 a[j] = temp;  
14.   
15.                 lastSwapPosTemp = j;  
16.             }  
17.         }  
18.         if (lastSwapPos == lastSwapPosTemp)  
19.             break;  
20.           
21.     }  
22. }  

下面是两种一般冒泡算法和双向冒泡算法的对比：

#include "stdafx.h" #include <stdio.h> #include <stdlib.h>   //一般的冒泡排序 void  bubbleSort( int  a[], int  n) {      int  i, j, k;      int  temp;        for  (i = 0; i < n; i++){    //最多做n-1趟排序          for (j = 0 ;j < n - i - 1; j++){                if (a[j] > a[j + 1]){    //把大的值交换到后面                  temp = a[j];                  a[j] = a[j + 1];                  a[j + 1] = temp;              }          }                     printf( "第%d次排序结果：" , i + 1);          for (k = 0; k < n; k++){              printf( "%d\t" , a[k]);          }          //printf("\n");      }      printf( "最终排序结果： " );      for (k = 0; k < n; k++){          printf( "%d\t" , a[k]);      } }   //改进版的冒泡排序(双向冒泡) void  bidBubbleSort( int  a[], int  n) {      int  left, right, t, l, r, j, i = 0;        left =0;      right = n -1;        //双向冒泡算法，极大的减少了循环排序的次数      while (left < right)      {          //必须要给l和r赋值，否则若数组一开始就有序，则right=r中的r未赋值，即报错          l = left + 1;          r = right -1;            //第一次循环将最大的值放到末尾          for (j = left; j < right; j++)          {              if (a[j] > a[j + 1])              {                  t = a[j];                  a[j] = a[j + 1];                  a[j + 1] = t;                  r = j;              }          }          right = r;            //第二次循环将最小的值放到了开头          for (j = right; j > left; j--)          {              if (a[j] < a[j - 1])              {                  t = a[j];                  a[j] = a[j - 1];                  a[j - 1] = t;                  l = j;              }          }          left = l;            printf( "第%d次排序结果：" , i + 1);          i++;          for (j = 0; j < n; j++){              printf( "%d\t" , a[j]);          }      }       printf( "最终排序结果： " );      for (j = 0; j < n; j++){          printf( "%d\t" , a[j]);      } }   int  _tmain( int  argc, _TCHAR* argv[]) {      int  score1[] = {98, 69, 75, 47, 89, 90, 100, 70};      bubbleSort(score1, 8);      printf( "\n" );      int  score2[] = {98, 69, 75, 47, 89, 90, 100, 70};      bidBubbleSort(score2, 8);        system( "pause" );      return  0; }

 下面是运行效果：

可见，双向冒泡排序能大大减少排序的次数，值得借鉴！！！