冒泡程序的优化问题

1.普通冒泡程序 

1. void popsort(int* a, size_t n)  
2. {  
3.     int i = 0;  
4.     int j = 0;;  
5.     int tmp = 0;  
6.   
7.     for (i  = 0; i < n - 1; i++)  
8.     {  
9.         for (j = 0; j < n - i - 1; j++)  
10.         {  
11.             if (a[j] > a[j + 1])  
12.             {  
13.                 tmp = a[j];  
14.                 a[j] = a[j + 1];  
15.                 a[j + 1] = tmp;  
16.             }  
17.         }  
18.     }  
19. }  

2.设置POS当排序完成之后不进行排序

1. //外循环优化->  
2. void popsort1(int* a, size_t n)  
3. {  
4.     int i = 0;  
5.     int j = 0;;  
6.     int tmp = 0;  
7.     int Pos = 1;  
8.   
9.     for (i = 0; i < n - 1; i++)  
10.     {  
11.         if (Pos == 0)  
12.             break;  
13.   
14.         Pos = 0;  
15.   
16.         for (j = 0; j < n - i - 1; j++)  
17.         {  
18.             if (a[j] > a[j + 1])  
19.             {  
20.                 Pos = 1;  
21.                 tmp = a[j];  
22.                 a[j] = a[j + 1];  
23.                 a[j + 1] = tmp;  
24.             }  
25.         }  
26.     }  
27. } 

3.再次优化：记录冒泡排序的最后一次的位置当排序结束直接结束 ：

序的.如果你好好思考一下，看看这个道理到底对不对. 想不来没关系，我还有图！！！ 

那么优化就很简单了，只需要改变内层for循环判断条件. 每次记录最后一次交换数据的位置K，然后for (j = 0; j < K; j++)这样改变for循环条件即

可.这样我们的优化就完毕了~  这个时候你的冒泡排序法的效率将会大大提高.你已经很尽力的优化它了. 由于这个优化效果没有办法直观展示.直接

代码实现了:

1. //内循环优化->  
2. void popsort3(int* a, size_t n)  
3. {  
4.     int i = 0;  
5.     int j = 0;;  
6.     int tmp = 0;  
7.     int Pos = 1;  
8.     int K = n-1;  
9.     int M = 0;  
10.   
11.     for (i = 0; i < n - 1; i++)  
12.     {  
13.         if (Pos == 0)  
14.             break;  
15.   
16.         Pos = 0;  
17.   
18.         for (j = 0; j < K; j++)  
19.         {  
20.             if (a[j] > a[j + 1])  
21.             {  
22.                 Pos = 1;  
23.                 tmp = a[j];  
24.                 a[j] = a[j + 1];  
25.                 a[j + 1] = tmp;  
26.                 M = j;  
27.             }  
28.         }  
29.         K = M;  
30.     }  
31. }