冒泡排序及其优化的三种方式

冒泡排序（BubbleSort）

一般冒泡排序的写法

//假设排序arr[] = { 1, 3, 4, 2, 6, 7, 8, 0 };
void BubbleSort(int arr[],int len)
{
    int i = 0;
    int tmp = 0;
    for (i = 0; i < len - 1; i++)//确定排序趟数
    {
        int j = 0;
        for (j = 0; j < len - 1 - i; j++)//确定比较次数
        {
            if (arr[j]>arr[j + 1])
            {
                //交换
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

优化一

假设我们现在排序ar[]={1,2,3,4,5,6,7,8,10,9}这组数据，按照上面的排序方式，第一趟排序后将10和9交换已经有序，接下来的8趟排序就是多余的，什么也没做。所以我们可以在交换的地方加一个标记，如果那一趟排序没有交换元素，说明这组数据已经有序，不用再继续下去。

代码实现：

void BubbleSort(int arr[], int len)
{
    int i = 0;
    int tmp = 0;
    for (i = 0; i < len - 1; i++)//确定排序趟数
    {
        int j = 0;
        int flag = 0;
        for (j = 0; j < len - 1 - i; j++)//确定比较次数
        {
            if (arr[j]>arr[j + 1])
            {
                //交换
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                flag = 1;//加入标记
            }
        }
        if (flag == 0)//如果没有交换过元素，则已经有序
        {
            return;
        }
    }
}

优化二

优化一仅仅适用于连片有序而整体无序的数据(例如：1， 2，3 ，4 ，7，6，5)。但是对于前面大部分是无序而后边小半部分有序的数据(1，2，5，7，4，3，6，8，9，10)排序效率也不可观，对于种类型数据，我们可以继续优化。既我们可以记下最后一次交换的位置，后边没有交换，必然是有序的，然后下一次排序从第一个比较到上次记录的位置结束即可。

代码实现：
void BubbleSort(int arr[], int len)
{
    int i = 0;
    int tmp = 0;
    int flag = 0;
    int pos = 0;//用来记录最后一次交换的位置
    int k = len - 1;
    for (i = 0; i < len - 1; i++)//确定排序趟数
    {
        pos = 0;
        int j = 0;
        flag = 0;
        for (j = 0; j < k; j++)//确定比较次数
        {
            if (arr[j]>arr[j + 1])
            {
                //交换
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                flag = 1;//加入标记
                pos = j;//交换元素，记录最后一次交换的位置
            }
        }
        if (flag == 0)//如果没有交换过元素，则已经有序
        {
            return;
        }
        k = pos;//下一次比较到记录位置即可
    }
}
 

优化三

优化二的效率有很大的提升，还有一种优化方法可以继续提高效率。大致思想就是一次排序可以确定两个值，正向扫描找到最大值交换到最后，反向扫描找到最小值交换到最前面。例如：排序数据1，2，3，4，5，6，0

 

代码实现：
void BubbleSort(int arr[], int len)
{
    int i = 0;
    int j = 0;
    int n = 0;//同时找最大值的最小需要两个下标遍历
    int flag = 0;
    int pos = 0;//用来记录最后一次交换的位置
    int k = len - 1;
    for (i = 0; i < len - 1; i++)//确定排序趟数
    {
        pos = 0;
        flag = 0;
        //正向寻找最大值
        for (j = n; j < k; j++)//确定比较次数
        {
            if (arr[j]>arr[j + 1])
            {
                //交换
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                flag = 1;//加入标记
                pos = j;//交换元素，记录最后一次交换的位置
            }
        }
        if (flag == 0)//如果没有交换过元素，则已经有序,直接结束
        {
            return;
        }
        k = pos;//下一次比较到记录位置即可
        //反向寻找最小值
        for (j = k; j > n; j--)
        {
            int tmp = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = tmp;
            flag = 1;
        }
        n++;
        if (flag == 0)//如果没有交换过元素，则已经有序,直接结束
        {
            return;
        }
    }
}