算法学习记录排序——冒泡排序（Bubble Sort）

冒泡排序应该是最常用的排序方法，我接触的第一个排序算法就是冒泡，老师也经常那这个做例子。

冒泡排序是一种交换排序，

基本思想：

通过两两比较相邻的记录，若反序则交换，知道没有反序的记录为止。

例子：

 

依次类推。这里可以看出，每次比较从最后一个开始，向前比较，若反序则交换；

每次都保证了是两两相邻的记录比较。

冒泡排序的代码：

void bubble_sort (myDataType *ary,int len)
{
    int i,j;
    for (i=0;i<len;i++)
    {
        for (j=len-2;j>=i;j--)
        {
            if (ary[j] > ary[j+1])
            {
                myDataType temp = ary[j];
                ary[j] = ary[j+1];
                ary[j+1] = temp;
            }
        }
    }

}

完整代码：

// sort-bubble.cpp : 定义控制台应用程序的入口点。
//
-
#include "stdafx.h"


typedef int myDataType;
myDataType src_ary[10] = {9,1,5,8,3,7,6,0,2,4};

void prt_ary(myDataType *ary,int len)
{
    int i=0;
    while(i < len)
    {
        printf(" %d ",ary[i++]);
    }
    printf("\n");
}

void bubble_sort (myDataType *ary,int len)
{
    int i,j;
    for (i=0;i<len;i++)
    {
        for (j=len-2;j>=i;j--)
        {
            if (ary[j] > ary[j+1])
            {
                myDataType temp = ary[j];
                ary[j] = ary[j+1];
                ary[j+1] = temp;
            }
        }
    }

}


int _tmain(int argc, _TCHAR* argv[])
{
    printf("before sort:\n");
    prt_ary(src_ary,10);

    bubble_sort(src_ary,10);

    printf("after sort:\n");
    prt_ary(src_ary,10);



    getchar();
    return 0;
}

结果：

附录：

另外冒泡排序还有其他变形，

比如：

可以设置一个哨兵下标，对该下标元素和之后的每一个元素做比较，选取最小的元素交换，这样一次类推，每次都是一个最小的元素。

如图：

代码：

void bubble_sort_modify1(myDataType *ary,int len)
{
    int i,j;
    for (i=0;i<len;i++) // 哨兵下标
    {
        for (j=i+1;j<len;j++) //欲比较的下标
        {
            if (ary[i] > ary[j])
            {
                myDataType temp;
                temp = ary[i];
                ary[i] = ary[j];
                ary[j] = temp;
            }
        }
    }
}

这个不是我们标准的冒泡排序算法，但是却很好理解，用的也多。

该算法还可以改进，每次交换顺序耗费时间，可以在比较过程中，将最小值的小标记下，循环结束后，交换。这样每次循环交换操作只有一次。

对标准冒泡排序还可以优化：

10个数字需要循环10趟，如果在第3趟就将所有的顺序排序好了，这样后面的7趟还是要继续执行，但是不起作用。所以可以在比较中添加一个标记

用来查看一次循环是否做了调整，如果没有，则说明排序好了，不用在执行剩余的循环了。

void bubble_sort_opt (myDataType *ary,int len)
{
    int i,j;
    bool flag = true; //增加一个标记元素
    for (i=0;i<len && flag;i++)    //判断之前循环是否执行了交换操作
    {
        flag = false;
        for (j=len-2;j>=i;j--)
        {
            if (ary[j] > ary[j+1])
            {
                myDataType temp = ary[j];
                ary[j] = ary[j+1];
                ary[j+1] = temp;
                flag = true;    //查看该循环是否执行了操作
            }
        }
    }

}