Bubble Sort

冒泡排序(Bubble Sort)是一种简单的比较排序算法。

基本思想

依次比较两个相邻记录的关键字，如果顺序错误就进行交换，直到没有逆序的记录。

外层需要n-1次循环，可以将n-1个元素冒泡到右边，内层循环从0到n-2，因为要比较i和i+1的值。

最简单的实现：

#include <stdio.h>

#define MAXSIZE 100    //最大元素个数

typedef struct
{
    int a[MAXSIZE + 1];    //a[0]来存储其他信息,a[1]-a[MAXSIZE]
    int length;       //顺序表长度
}Sqlist;

void swap(Sqlist* L, int i, int j)
{
    int temp = L->a[i];
    L->a[i] = L->a[j];
    L->a[j] = temp;
}

/*升序排列*/
void Bubble_sort(Sqlist* L)
{
    int i,j;
    for(i = 1;i < L->length;i++)
    {
        for(j = i + 1;j <= L->length;j++)
        {
            if(L->a[i] > L->a[j])
                swap(L,i,j);
        }
    }
}

int main(int argc, char** argv)
{
    Sqlist L;

    scanf("%d",&(L.length));
    for(int i = 1;i <= L.length;i++)
        scanf("%d",&(L.a[i]));

    Bubble_sort(&L);

    for(int i = 1;i <= L.length;i++)
        printf("%d ",L.a[i]);
    printf("
");

    return 0;
}

这种方法是让每个关键字都与其后的每个关键字比较，保证每轮循环结束总是有一个最小值放在前面。效率巨低，时间复杂度O(n^2)，空间复杂度O(1)。

稍微优化下：

/*升序排列*/
void Bubble_sort(Sqlist* L)
{
    int i,j;
    for(i = 1;i < L->length;i++)  //j从后向前
    {
        for(j = L->length - 1;j >= i;j--)
        {
            if(L->a[j] > L->a[j + 1])
                swap(L,j,j + 1);  //若逆序，交换相邻的2个关键字
        }
    }
}

这种方法的优化在于：除了方法一中把最小的元素提到第一个位置，还把位置靠后的小元素也提到了前面，后续交换的次数会减少。

进一步的优化：

试想如果序列是{2,1,3,4,5}，其实我们只需交换前两个元素，也就是说：当i=2时，我们发现没有数据的交换时，就可以断定后面的序列已经有序，无需重复比较。

/*升序排列*/
void Bubble_sort(Sqlist* L)
{
    int i,j;
    int flag = 1;
    for(i = 1;i < L->length && flag;i++)  //flag为假就退出
    {
        flag = 0;   //初始化flag为假
        for(j = L->length - 1;j >= i;j--)
        {
            if(L->a[j] > L->a[j + 1])
            {
                swap(L,j,j + 1);
                flag = 1;  //如果有数据交换，将flag变为真
            }
        }
    }
}

这样的话，就可以避免部分序列有序的情况下，对其做没有必要的比较。

复杂度

对于最后优化的代码，可以看到：
最好的情况就是待排序列已经全部有序，这样要进行n-1次比较，时间复杂度O(n)；
最坏的情况就是待排序列全部逆序，需要进行n(n-1)/2次比较，并且还有等数量级的交换，时间复杂度O(n^2)。