冒泡排序

      冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

      先声明一个用于排序用的顺序表结构

#define MAXSIZE 10          /* 用于要排序数组个数最大值 */

typedf struct
{
    int r[MAXSIZE];         /* 用于存储要排序数组 */
    int length;             /* 用于记录顺序表的长度 */
}SqList;

另外，由于排序最常用到的操作是数组元素的交换，我们将它写成函数

void swap(SqList *L, int i, int j)
{
    int temp = 0;

    temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp;
}

/* 对顺序表L作交换排序 */
void BubbleSort0(SqList *L)
{
    int i,j;

    for(i=0; i<L->length; i++)
    {
            for(j=i+1; j<=L->length; j++)
            {
                if(L->r[i] > L->r[j])
                {
                    swap(L,i,j);        /* 交换L->r[i]与L->r[j]的值*/
                }
            }
    }
}

      这段代码严格意义上说，不算是标准的冒泡排序算法，因为它不满足“两两比较相邻记录”的冒泡排序思想，它更应该是最简单的交换排序而已。它的思路就是让每一个关键字，都和它后面的每一个关键字比较，如果大则交换，这样第一位置的关键字在一次循环后一定变成最小值。后面的数字依次类推。

修改后的冒泡算法

/* 对顺序表L作冒泡排序 */
void BubbleSort(SqList *L)
{
    int i,j;

    for(i=0; i<L->length; i++)
    {
        for(j=L->length-1; j>=i; j--)  //j从后向前循环
        {
            if(L->r[j]>L->r[j+1])
            {
                swap(L, j, j+1);
            }
        }
    }
}

      上面的冒泡还可以优化，当带排序的序列是{2,1,3,4,5,6,7,8,9}，除了第一和第二的关键字需要交换外，别的都是正常的顺序。当i=0时，交换了2和1，此时序列已经有序，但是算法仍然将i=1到8以及每个循环中的j循环都执行了一遍，尽管没有数据交换，但是之后大量的比较还是多余。

      当i=1时，我们已经对9与8,8与7，...，3与2作了比较，没有任何数据交换，这就说明此序列已经有序·，不需要再继续后面的循环判断工作。为了实现这个想法，我们需要改进一下代码，增加一个标记变量flag来实现这一算法的改进。

/* 对顺序表L作改进冒泡算法 */
void BubbleSort2(SqList *L)
{
    int i,j;
    int flag=1;

    for(i=0; (i<L->length)&&flag; i++)
    {
        flag=0;                        //初始化为0
        for(j=L->length-1; j>=i; j--)
        {
            if(L->r[j]>L->[j+1])
            {
                swap(L,j,j+1);
                flag=1;               //如果有数据交换，则flag为1
            }
        }
    }
}

      分析一下冒泡时间复杂度。当最好的情况，也就是要排序的表本身就是有序的，根据最后改进的代码，可以推断出就是n-1次的比较，没有数据交换，时间复杂度为O{n}。当最坏的情况，即待排序表是反序，此时需要比较n(n-1)/2次。因此，总的时间复杂度为O{n2}。