数据结构与算法 / 冒泡排序及其优化的三种方式

一、一般写法

统一使用交换函数：

void swap(int& a, int& b)
{
    int tmp = a;
    a = b;
    b = tmp;
    return;
}

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])
                swap(arr[j], arr[j + 1]);
    }
    return;
}

二、优化方案一

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

代码实现：

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

四、优化方案三

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

这种方法被称为“鸡尾酒排序”或者“双向冒泡排序”。

代码实现：

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

 

转载：https://blog.csdn.net/qq_37997523/article/details/89341793?ops_request_misc=&request_id=&biz_id=102&utm_term=linux%20c%20%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F%E4%B8%89%E7%A7%8D%E4%BC%98%E5%8C%96%E6%96%B9%E6%B3%95&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-89341793.nonecase&spm=1018.2226.3001.4187

 

（SAW：Game Over！）