排序算法：冒泡排序（代码优化）

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.   
7.        k = n;  
8.        flag = true;  
9.        while (flag)  
10.        {  
11.               flag = false;  
12.               for (j = 1; j < k; j++)  
13.                      if (a[j - 1] > a[j])  
14.                      {  
15.                             Swap(a[j - 1], a[j]);  
16.                             flag = true;  
17.                      }  
18.               k--;  
19.        }  
20. }  

假如突然发现某一趟走下来，没有进行两两交换，你懂的。

代码3：

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. } 

这里更精确了一点，试着去发现尾巴一截的有序，如果发小了，下次你遍历到尾巴前面一点就可以了。