内部排序-交换式排序-冒泡排序法

冒泡排序法，很简单的一个方法，将相邻的两个数据加以比较，并按照规则交换位置，重复此动作，直到比较到最后一个值结束。

该方法的优点是：若数据已经有部分排好序，则使用该方法可以很快的完成排序。

缺点：该方法会反复扫描数据，比较相邻的两个数据，速度不快并且也没有效率。

该方法是稳定性排序方法。空间复杂度是O(1), 时间复杂度是O(n^2)

[cpp]   view plain copy

1. void bubble_sort2(void *in_data, int len)  
2. {  
3.     int i = 0, j = 0, k = 0;  
4.     int change = 0, temp = 0;  
5.     int *data = (int *)in_data;  
6.       
7.     for(j = len - 1; j > 0; j--)  
8.     {  
9.         for(i = 0; i < j - 1; i++)  
10.         {  
11.             if(data[j] > data[i] )  
12.             {  
13.                 temp = data[i];  
14.                 data[i] = data[j];  
15.                 data[j] = temp;  
16.               
17.                 printf("\n current sorting result:");  
18.                 for(k = 0; k < len; k++)  
19.                     printf("%d ", data[k]);  
20.             }  
21.         }  
22.     }  
23.       
24. }  

[cpp]   view plain copy

1. void bubble_sort2(void *in_data, int len)  
2. {  
3.     int i = 0, j = 0, k = 0;  
4.     int change = 0, temp = 0;  
5.     int *data = (int *)in_data;  
6.       
7.     for(j = len - 1; j > 0; j--)  
8.     {  
9.         for(i = 0; i < j - 1; i++)  
10.         {  
11.             if(data[j] > data[i] )  
12.             {  
13.                 temp = data[i];  
14.                 data[i] = data[j];  
15.                 data[j] = temp;  
16.               
17.                 printf("\n current sorting result:");  
18.                 for(k = 0; k < len; k++)  
19.                     printf("%d ", data[k]);  
20.             }  
21.         }  
22.     }  
23.       
24. }  

传统冒泡排序中每一次排序只能找到一个最大值或者最小值，可以考虑在每次排序中进行正向和反向两次冒泡，一次可以找到两个最值(最大值和最小值)，从而使排序次数减少。

[cpp]   view plain copy

1. void bubble_sort3(void *in_data, int len)  
2. {    
3.     int *data = (int *)in_data;  
4.     int low = 0;     
5.         int high= len - 1;  
6.         int temp, i, j;    
7.         while (low < high)  
8.     {    
9.         for (j = low; j < high; ++j) //正向冒泡,找到最大者     
10.                     if (data[j] > data[j+1]) {    
11.                         temp = data[j];   
12.             data[j]=data[j+1];  
13.             data[j+1]=temp;    
14.                     }     
15.                 --high;           //修改high值, 前移一位     
16.                 for ( j = high; j > low; --j) //反向冒泡,找到最小者     
17.                     if (data[j] < data[j-1]) {    
18.                         temp = data[j];  
19.             data[j] = data[j-1];  
20.             data[j-1] = temp;    
21.                 }    
22.                 ++low;                  //修改low值,后移一位     
23.         printf("\n current sorting result:");  
24.         for(i = 0; i < len; i++)  
25.             printf("%d ", data[i]);  
26.         }     
27. }     

[cpp]   view plain copy

1. void bubble_sort3(void *in_data, int len)  
2. {    
3.     int *data = (int *)in_data;  
4.     int low = 0;     
5.         int high= len - 1;  
6.         int temp, i, j;    
7.         while (low < high)  
8.     {    
9.         for (j = low; j < high; ++j) //正向冒泡,找到最大者    
10.                     if (data[j] > data[j+1]) {    
11.                         temp = data[j];   
12.             data[j]=data[j+1];  
13.             data[j+1]=temp;    
14.                     }     
15.                 --high;           //修改high值, 前移一位    
16.                 for ( j = high; j > low; --j) //反向冒泡,找到最小者    
17.                     if (data[j] < data[j-1]) {    
18.                         temp = data[j];  
19.             data[j] = data[j-1];  
20.             data[j-1] = temp;    
21.                 }    
22.                 ++low;                  //修改low值,后移一位    
23.         printf("\n current sorting result:");  
24.         for(i = 0; i < len; i++)  
25.             printf("%d ", data[i]);  
26.         }     
27. }