排序算法：冒泡排序（代碼優化）

http://blog.csdn.net/morewindows/article/details/6657829是必看的

例：長度為N的數組

從0開始進行兩兩左右交換，那麼必然可以把最大數放到最右端。

第二次隻需要從第1個到N-1個進行同樣的操作就可以了。

是以你隻需要開兩層循環：

外層：僅僅記錄下這是第幾次操作，每進行一次操作，我們需要周遊的長度都要減1

内層：進行一個周遊，周遊到N-i即可

代碼1：

1. //冒泡排序1  
2. void BubbleSort1(int a[], int n)  
3. {  
4.        int i, j;  
5.        for (i = 0; i < n; i++)  
6.               for (j = 1; j < n - i; j++)  
7.                      if (a[j - 1] > a[j])  
8.                             Swap(a[j - 1], a[j]);  
9. }  

代碼2：

1. //冒泡排序2  
2. void BubbleSort2(int a[], int n)  
3. {  
4.        int j, k;  
5.        bool flag;  
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. }  

假如突然發現某一趟走下來，沒有進行兩兩交換，你懂的。

代碼3：

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

這裡更精确了一點，試着去發現尾巴一截的有序，如果發小了，下次你周遊到尾巴前面一點就可以了。