冒泡排序

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

运行示例：

/* 对顺序表L作交换排序 （冒泡排序的初级版）*/

#include <stdio.h>
#define MAXSIZE 10
typedef struct
{
    int r[MAXSIZE];
    int length;
}SqList;

void swap(SqList *L, int i, int j)
{
    int temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp;
}
void BubbleSort0(SqList *L)
{
    int i ,j;
    for(i = 1; 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]的值
            }
        }
    }
}
int main()
{
    SqList H;
    int n;
    scanf("%d",&n);
    H.length = n;
    for(int i = 1; i <= n; i++)
    {
        scanf("%d",&H.r[i]);
    }
    BubbleSort0(&H);
     for(int i = 1; i <= n; i++)
    {
        printf("%d ",H.r[i]);
    }
}
/*
------------------
程序运行示例：
9 
9 1 5 8 3 7 4 6 2
1 2 3 4 5 6 7 8 9 %  
------------------
*/

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

这个简单易懂的代码，却是有缺陷的，观察后发现，在排序好1和2的位置后，对其余关键字的排序没有什么帮助（数字3反而还被换到了最后一位）。也就是说，这个算法的效率是非常低的。

/* 对顺序表L作交换排序 （冒泡排序的正宗版）*/
void BubbleSort1(SqList *L)
{
    int i ,j;
    for(i = 1; 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);  //交换L->r[i] L->r[j]的值
            }
        }
    }
}    

事实上，在不断循环的过程中，除了将关键字1放到第一的位置，我们还将关键字2从第九位置提到了第三的位置，显然这一算法比前面的要有进步。较小的数字如同气泡般慢慢浮到上面，因此就将此算法命名为冒泡排序。

/* 对顺序表L作交换排序 （冒泡排序的优化版）*/
void BubbleSort2(SqList *L)
{
    int i ,j;
    int flag = 1;  //flag用来作为标记
    for(i = 1; i < L->length && flag; i++) //若flag 为false则退出循环
    {
        flag = 0;       //初始化为false
        for(j = L->length-1; j >= i; j--)  //注意j是从后往前循环
        {
            if(L->r[j] > L->r[j+1])  /* 若前者大于后者（注意此处与上一个的不同）*/
            {
                swap(L, j, j+1);  //交换L->r[i] L->r[j]的值
                flag = 1;  //如果有数据交换，则flag为true；
            }
        }
    }
}      

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

代码改动的关键就是在i变量的for循环中，增加了对flag是否为true的判断。经过这样的改进，冒泡排序在性能上就有了一些提升。可以避免因已经有序的情况下的无意义的循环判断。

冒泡排序复杂度分析

分析一下它的复杂度。当最好的情况下，也就是要排序的表本身就是有序的，那么我们比较的次数，根据最后改进的代码，可以推断出就是n-1次的比较，没有数据交换，时间复杂度为O(n)。当最坏的情况，即待排序是逆序的情况，此时需要比较 $\sum_{i=2}^n {(i-1)}$ = $\frac{n(n-1)}{2}$

次，并作等数量级的记录移动。因此，时间复杂度为O( $n^2$)。