冒泡排序

冒泡排序的基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大 的数往下沉 ，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

关于程序中4中冒泡排序写法的说明：

bubble_sort1：基本的冒泡排序的写法。

bubble_sort2：基本冒泡排序的不同写法，基本的冒泡排序是每次遍历，每次缩小范围1，这种办法是每次正向和反向遍历，每次缩小范围2，所以两者的比较次数也是一样的。

bubble_sort3：如果在某一趟的冒泡途中没有出现数据交换，那就只能是数据已经被排好序了，这样就可以提前得知数据排好序从而中断循环，消除掉不必要的比较。

bubble_sort4：如果在某一趟的冒泡途中最后的交换出现在pos的位置，那么表示pos位置以后都已经排好序，这样相比于基本冒泡每一次缩小遍历范围1而言有可能一次缩小的遍历范围>=1，所以这样也可以提高排序的效率。

程序代码如下：

这里写代码片


#include <stdio.h>

int bubble_sort1(int num[], int n) /*最基本的冒泡排序法*/
{
    int i, j, tmp;
    int count = 0;

    for(i = 0; i < n-1; i++) /*冒泡一次放好一个数，冒泡n-1次就可以全部放置好*/
        for(j = 0; j < n-1-i; j++, count++) /*后面的i个数已经为有序序列*/
        {
            if(num[j] > num[j+1])
            {
                tmp = num[j];
                num[j] = num[j+1];
                num[j+1] = tmp;
            }
        }

    return count;
}

int bubble_sort2( int num[], int n) /*基本冒泡法的另一种写法*/
{  
    int low = 0;   
    int high= n -1; /*设置边界low和high*/  
    int tmp, j, count = 0; 
    while (low < high) 
    {  
        for(j=low; j < high; j++, count++) /*正向冒泡，找最大值*/  
            if (num[j] > num[j+1]) 
            {  
                tmp = num[j]; 
                num[j] = num[j+1];
                num[j+1] = tmp;  
            }   
        high --; /*更新冒泡区间*/
        for(j=high; j > low; j--, count++) /*反向冒泡，找最小值*/   
            if (num[j] < num[j-1]) 
            {  
                tmp = num[j]; 
                num[j] = num[j-1];
                num[j-1] = tmp;  
            }  
        low ++; /*更新冒泡区间*/
    }  

    return count;
}  

int bubble_sort3(int num[], int n) /*加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，
    如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，
                                     则立即结束排序，避免不必要的比较过程。*/
{
    int i, j, tmp, exchange = 1, count =0;

    for(i = 0; i<n-1 && (exchange==1); i++) /*判断上一趟是否有数据交换，没有则表明排序已完成*/
        for(j = 0, exchange=0; j < n-1-i; j++, count++)
        {
            if(num[j] > num[j+1])
            {
                exchange = 1;
                tmp = num[j];
                num[j] = num[j+1];
                num[j+1] = tmp;
            }
        }

    return count;
}

int bubble_sort4(int num[], int n) /*加入一标志性变量pos，用于标志某一趟排序过程中最后交换数据的位置，
    那么在这个位置之后的数据都是已经排好序的，进而根据这个pos重新计算
                                     还剩余的冒泡次数*/
{
    int i, j, tmp, pos, count =0;

    for(i=0; i < n-1; i=n-pos) /*n-pos表示已经排好序的个数，用来替代以前的i++方式计算已经排好序的个数*/
        for(j=0, pos=0; j < n-1-i; j++, count++) /*pos=0是必须的，不然没有交换的时候会出现死循环*/
        {
            if(num[j] > num[j+1])
            {
                tmp = num[j];
                num[j] = num[j+1];
                num[j+1] = tmp;
                pos = j+1; /*从j+1开始的往后的数据已经排好序*/
            }
        }

    return count;
}


void print_num(int num[], int n)
{
    int i;

    printf("[0-%d]: ", n-1);
    for(i=0; i < n; i++)
        printf("%d ", num[i]);
    printf("\n");
}

int main()
{
    int num1[] = {1, 9, 3, 5, 6, 2, 7, 10, 8, 4, 11, 15, 13, 12, 16, 14};
    int num2[] = {1, 9, 3, 5, 6, 2, 7, 10, 8, 4, 11, 15, 13, 12, 16, 14};
    int num3[] = {1, 9, 3, 5, 6, 2, 7, 10, 8, 4, 11, 15, 13, 12, 16, 14};
    int num4[] = {1, 9, 3, 5, 6, 2, 7, 10, 8, 4, 11, 15, 13, 12, 16, 14};
    int cmp_cnt;

    cmp_cnt = bubble_sort1(num1, sizeof(num1)/sizeof(int));
    print_num(num1, sizeof(num1)/sizeof(int));
    printf("Method1 compare count is: %d.\n\n", cmp_cnt);

    cmp_cnt = bubble_sort2(num2, sizeof(num2)/sizeof(int));
    print_num(num2, sizeof(num2)/sizeof(int));
    printf("Method2 compare count is: %d.\n\n", cmp_cnt);

    cmp_cnt = bubble_sort3(num3, sizeof(num3)/sizeof(int));
    print_num(num3, sizeof(num3)/sizeof(int));
    printf("Method3 compare count is: %d.\n\n", cmp_cnt);

    cmp_cnt = bubble_sort4(num4, sizeof(num4)/sizeof(int));
    print_num(num4, sizeof(num4)/sizeof(int));
    printf("Method4 compare count is: %d.\n\n", cmp_cnt);

    return 0;
}

程序运行结果截图：

冒泡排序法的特点：

时间复杂度：O(n^2)

空间复杂度：O(1)

稳定性：稳定