冒泡排序(bubble sort)

冒泡排序是最基本的排序算法，常被做为内部排序的第一个排序算法进行讲解。它的原理非常简单，只是一
个两层循环，每次将最大或最小的放到数组最后。
算法如下(b为数组的起始位置， e为数组的结果位置）：
int bubble(int data[], int b, int e)
{
    int i, j, n = 0;
    for(i = e; i > b; i--)
        for(j = b; j < i; j++)
        {
            n++;
            if(data[j] < data[j + 1])
            {
                swap(&data[j], &data[j + 1]);
                n++;
            }
        }
    return n;
}

这个函数返回两个整数比较以及进行交换的次数。如将序列5, 3, 1, 665, 77, 66, 44, 11, 10, 9, 8, 6
进行排序，bubble返回93。
这个算法的时间复杂度为 O(n^2)。
而时间复杂度由两部分组成：比较和交换
比较：
最好     平均      最差
O(n^2)   O(n^2)    O(n^2)

交换
最好     平均      最差
 0       O(n^2)    O(n^2)
 
也就是说bubble在最好的情况不需要进行交换，那还要做复杂度为O(n^2)的比较不是太浪费了吗？
下面给出一个bubble sort的改良版本，这个算法在数据基本有序时的时间复杂度为 O(n)。最差情况
和bubble函数一样，也是O(n^2)。
这个算法的主要思想是在两个整数最后一次交换后，在前一个整数后面的所有整数都是排序的，因此在
第一层循环的i变化时，无需减1，而只需将i置成这个整数所在的位置。从而第一层循环的次数就不一定是
n - 1，当待排序数组已经是有序时，第一层循环只循环一次。算法实现如下。
int bubble_new(int data[], int b, int e)
{
    int i, j, n = 0, k;
    for(i = e; i > b; i = k)
    {
        k = b;
        for(j = b; j < i; j++)
        {
            n++;                            
            if(data[j] < data[j + 1])
            {
                k = j;
                swap(&data[j], &data[j + 1]);
                n++;
            }
        }
    }
    return n;
}

再用序列5, 3, 1, 665, 77, 66, 44, 11, 10, 9, 8, 6试一试，bubble_new返回65，比bubble快了30%。

完整的代码如下：
#include <stdio.h>

void output_array(int data[], int n)
{
    int i;
    for(i = 0; i < n; i++)
        printf("%d ", data[i]);
    printf("/n");
}

void swap(int *a, int *b)
{
    int x;
    x = *a;
    *a = *b;
    *b = x;
}

int bubble(int data[], int b, int e)
{
    int i, j, n = 0;
    for(i = e; i > b; i--)
        for(j = b; j < i; j++)
        {
            n++;
            if(data[j] < data[j + 1])
            {
                swap(&data[j], &data[j + 1]);
                n++;
            }
        }
    return n;
}
int bubble_new(int data[], int b, int e)
{
    int i, j, n = 0, k;
    for(i = e; i > b; i = k)
    {
        k = b;
        for(j = b; j < i; j++)
        {
            n++;                            
            if(data[j] < data[j + 1])
            {
                k = j;
                swap(&data[j], &data[j + 1]);
                n++;
            }
        }
    }
    return n;
}

int main()
{
    int data1[] = {5, 3, 1, 665, 77, 66, 44, 11, 10, 9, 8, 6};
    int data2[] = {5, 3, 1, 665, 77, 66, 44, 11, 10, 9, 8, 6};
    output_array(data1, 12);
    printf("%d /n", bubble(data1, 0, 11));
    output_array(data1, 12);
    printf("-----------------------------------/n");
    output_array(data2, 12);
    printf("%d /n", bubble_new(data2, 0, 11));
    output_array(data2, 12);

    return 0;
}

其它内部排序

插入排序(insertion sort)
选择排序(selection sort)
希尔排序(shellsort)
快速排序(quicksort)
归并排序(merge sort)