冒泡排序

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

代码如下：

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

【完】