冒泡排序

最新推荐文章于 2019-04-09 15:29:50 发布

SmartBrave

最新推荐文章于 2019-04-09 15:29:50 发布

阅读量694

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构

本文链接：https://blog.youkuaiyun.com/SmartBrave/article/details/52182985

数据结构专栏收录该内容

15 篇文章

订阅专栏

本文介绍了冒泡排序的基本思想和实现代码，包括未优化和优化后的版本。虽然优化减少了不必要的交换，但冒泡排序的时间复杂度仍为O(n^2)。文章鼓励读者分享可能的改进方案，并提供了完整代码的github链接。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序可以说是最简单的一种排序了，其核心思想是：
* 每次比较相邻的两个数，若后面的比前面大，则交换之；
* 重复以上步骤，直到所有数都有序为止。

代码如下：

template<typename T>
void BubbleSort(vector<T>& v)
{
    int length=v.size();
    int i,j;
    for(i=0;i<length;++i)
    {
        for(j=0;j<length-1;++j)
        {
            if(1==compair(v[j],v[j+1]))
            {
                std::swap(v[j],v[j+1]);
            }
        }
    }
}

可以看出，冒泡排序采用了比较相邻数字的做法，所以时间复杂度为O(n²)。事实上，所有基于位置的比较排序的时间复杂度都逃不了O(n²)的厄运。

我们来看看以上代码还有没有什么可以优化的地方。

改进一：如果一趟排序中没有发生交换，则表明排序已经完成。
代码如下：

template<typename T>
void BubbleSort(vector<T>& v)
{
    bool flag=true;
    int length=v.size();
    int i,j;
    for(i=0;i<length;++i)
    {
        flag=true;
        for(j=0;j<length-1;++j)
        {
            if(1==compair(v[j],v[j+1]))
            {
                flag=false;
                std::swap(v[j],v[j+1]);
            }
        }
        if(flag==true)
            break;
    }
}

改进二：每一趟排序，都可将一个当前序列中最大的值”冒泡”到最后面，所以下一次只需要进行到这里就可以结束了。
代码如下：

template<typename T>
void BubbleSort(vector<T>& v)
{
    int length=v.size();
    int i,j;
    for(i=0;i<length;++i)
    {
        for(j=0;j<length-i-1;++j)
        {
            if(1==compair(v[j],v[j+1]))
            {
                std::swap(v[j],v[j+1]);
            }
        }
    }
}

值得注意的是，以上虽然对代码做了一些优化，但冒泡排序的算法的时间复杂度在本质上是没有改变的，仍然是2的平方阶。

以上

如果你有任何想法或是可以改进的地方，欢迎和我交流！

完整代码及测试用例在github上：点我前往

本文首发于www.sbrave.cn

【完】