冒泡排序(Bubble Sort)

2024年1月20日 202次阅读

维基百科：http://zh.wikipedia.org/wiki/冒泡排序

算法思想：
不断的交换相邻的两个反序元素，使最小元素“上浮”或使最大元素“下沉”;每一趟“冒泡”都会确定一个最大的元素或最小的元素，同选择排序类似，算法总共只需进行n-1趟。

将一个数组竖着放，低地址在上面，高地址在下面，所谓“上浮”就是较小的元素不断向低地址靠近，所谓“下沉”就是较大的元素不断向高地址靠近，这只是一个形象的说法，你可以按自己的方式理解。

冒泡排序是与插入排序拥有相等的执行时间，但是两种法在需要的交换次数却很大地不同。在最坏的情况，冒泡排序需要O(n^2)次交换，而插入排序只要最多O(n)次交换。冒泡排序的实现（类似下面的简单实现）通常会对已经排序好的数列拙劣地执行（复杂度O(n^2)），而插入排序在这个例子只需要O(n)个运算。因此很多现代的算法教科书避免使用冒泡排序，而用插入排序取代之。冒泡排序如果能在内部循环第一次执行时，使用一个旗标来表示有无需要交换的可能，也有可能把最好的复杂度降低到O(n)。在这个情况，在已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序和比较大小反过来，也可以稍微地改进效率。有时候称为往返排序(鸡尾酒排序)，因为算法会从数列的一端到另一端之间穿梭往返。

1、简单C++实现

#include <cstdlib>
#include <iostream>

using namespace std;

/*较大元素下沉
 *一趟扫描后，置于数组尾部的是最大元素 
 *"无序"数组长度减一，开始下一轮扫描 
*/ 
template<class T>
void bubbleSort1(T* a, int n)
{
    for(int i=0; i<n-1; i++)//循环执行n-1次
    {
        for(int j=0; j<n-i-1; j++)
        {
            if(a[j] > a[j+1])//交换逆序对 
            {
                T temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

//较小元素上浮 
template<class T>
void bubbleSort2(T* a, int n)
{
    for(int i=0; i<n-1; i++)
    {
        for(int j=n-1; j>i; j--)
        {
            if(a[j] < a[j-1])
            {
                T temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}

int main(int argc, char *argv[])
{
    int n;
    int *a = NULL;
    
    while(cin>>n && n > 0)
    {
        a = new int[n];
        for(int i=0; i<n; i++)
        {
            cin>>a[i];
        }
        //bubbleSort1(a,n);
       // bubbleSort2(a,n);
        bubbleSort(a,n); 
        
        for(int i=0; i<n; i++)
        {
            cout<<a[i]<<" ";
        }
        cout<<endl<<endl;
        delete [] a;
    }
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

2、略做改进后的算法

template<class T>
void bubbleSort(T* a, int n)
{
    bool change = true;
    for(int i=n-1; i>0 &&change; i--)
    {
        change = false;
        for(int j=0; j<i; j++)
        {
            if(a[j] > a[j+1])
            {
                T temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
                change = true;
            }
        }
    }
}

冒泡排序肯定还有很多其他的实现方式及其变形，但是原理都是一样的，这里就不一一列举了。

3、算法复杂度分析

对于改进后的算法

最好情况，输入是有序的，扫描一趟后，发现是有序的，change =false，算法终止，此时算法的复杂度为：O(n)
最坏情况：由于算法是按递增排序，当输入为递减序列时，外层循环执行n-1次，内层循环依次执行n-1,n-2,……1次，算法的复杂度为:O(n^2)
平均情况下的复杂度和最坏情况下差不多，为O（n^2）

参考资料：

[1]严蔚敏 《数据结构（C语言版）》

[2]鸡尾酒排序：http://zh.wikipedia.org/wiki/往返排序

点赞