排序算法总结：冒泡排序

基本思想

冒泡排序是非常容易理解和实现，以从小到大排序举例： 设数组长度为N。
1. 比较相邻的前后两个数据，如果前面数据大于后面的数据，就将两个数据交换。
2. 这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就 “沉”到数组第N-1个位置。
3. N=N-1，如果N不为0就重复前面二步，否则排序完成。

据此，可以容易的写出如下代码。

void BubbleSort(int a[], int n)
{
    int i, j;
    for (i = 0; i < n - 1; i++)
    { //比较n-1趟
        for (j = 0; j < n - 1 - i; j++)
        {
            if (a[j] > a[j+1])
            { //交换
                int tmp;
                tmp = a[j+1];
                a[j+1] = a[j];
                a[j] = tmp;
            }
        }
    }
}

优化

我们可以对冒泡排序进行简单的改进，设置一个标志位flag，如果这一趟发生了交换，则为true，否则为 false。如果有一趟没有发生交换，说明排序已经完成，则可以退出循环避免多余的比较。

void BubbleSort(int a[], int n)
{
    int i, pass, tmp;
    for (pass = 0; pass < n - 1; pass++)
    {//比较n-1趟
        int flag = 0;
        for (i = 0; i < n - 1 - pass; i++)
        {//逐次减少比较的次数
            if (a[i] > a[i + 1])
            {//交换两个数位置
                tmp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = tmp;
                flag = 1;
            }
        }
        if (flag == 0) //没有发生交换，已经排好序
            break; //退出循环
    }
}

进一步优化

再做进一步的优化。如果有100个数的数组，仅前面10个无序，后面90个都已排好序且都大于前面10个数字，那么在第一趟遍历后，最后发生交换的位置必定小于10，且这个位置之后的数据必定已经有序了，记录下这位置，第二次只要从数组头部遍历到这个位置就可以了。

void BubbleSort(int a[], int n)
{
    int m = n - 1;
    int LastChange;
    int j, tmp;
    while (m > 0)
    {
        //LastChange在这里初始化，如果没有交换一次，则LastChange=0
        LastChange = 0;
        for (j = 0; j < m; j++)
        {
            if (a[j] > a[j + 1])
            {//交换两个数的位置
                tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
                LastChange = j; //记录每次交换的位置
            }
        }
        m = LastChange; //记录最后一次交换的位置
    }
}