排序算法之冒泡排序

排序算法之冒泡排序

这一系列主要讲的是排序算法，首先会简单介绍各种排序算法的基本思想，然后会给出每种算法的Python实现和C++实现，代码中均有非常详细的注释。最后会给出不同算法的复杂度分析。
文中Python代码是在Python3.4.3或 Python3.2上实现的，C++代码是在Dev-C++5.7.1上实现的。如果有什么不清楚或者不对的地方，欢迎大家随时指正。

冒泡排序的基本思想是：两两比较相邻元素，如果大数在前小数在后，即反序，则交换，直到没有反序的元素为止。

Python代码实现：

import numpy as np

#定义冒泡排序函数
def BubbleSort(unSortedArray):
    i = 0                #外层循环初始化从0开始
    length = len(unSortedArray)     #数组的长度
    j = length-1         #内层循环初始化从最后一个元素开始向上冒泡
    flag = True          #标记变量，如果为False,说明此序列已经有序，不需要再继续后面的循环判断了
    while i <= (length-1) and flag == True:
        flag = False     #每次进入第一层循环之后，就把flag置为False,如果在内循环中有元素交换，则在内循环置flag为True
        while j > i:
            if unSortedArray[j] < unSortedArray[j-1]:   #比较，把小的元素冒泡到最开始
                temp = unSortedArray[j]
                unSortedArray[j] = unSortedArray[j-1]
                unSortedArray[j-1] = temp
                flag = True     #有交换，flag置为True，说明需要进行下一轮循环
            j -= 1

        i += 1                  #更新循环变量
        j = length -1           #内层循环每次都从序列最底端开始
    return unSortedArray

#算法验证
unSortedArray = np.array([2,7,1,5,9,3,10,18,6])
print("The original data is: ",unSortedArray)
print("The sorted data is: ",BubbleSort(unSortedArray))

运行结果为：

>>> ================================ RESTART ================================
>>>
The original data is:  [ 2  7  1  5  9  3 10 18  6]
The sorted data is:  [ 1  2  3  5  6  7  9 10 18]

C++代码实现：

#include <iostream>

using namespace std;

//交换两个元素，形参为引用形参
void swap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}

//冒泡排序：输入待排序数组和数组长度，返回指向排好序的数组的指针
int* BubbleSort(int *a, int length)
{
    int i = 0;             //初始化外层循环变量从0开始
    int j = length-1;      //初始化内层循环变量从最后一个元素开始
    bool flag = true;      //flag为True表示还需要进行循环比较

    while ((i < length-1) &&  (flag == true))
    {
        flag = false;
        for( ; j>i; --j )
        {
            if( a[j]<a[j-1] )      //进入if语句说明有元素交换，则把flag设为true，表示需要进行下一轮比较
            {
                swap(a[j], a[j-1]);
                flag = true;
            }
        }

        ++i;               //一次内循环结束之后，外循环变量后移一位
        j = length-1;      //一次内循环结束之后，内循环变量重新设置为最后一个元素
    }
    return a;
}

//主函数验证算法
int main(int argc, char** argv) {

    int originalArray[] = {2,7,1,5,9,3,10,18,6};
    int length = sizeof(originalArray)/sizeof(int);          //计算数组长度

    cout << "The length of the array is " << length << endl;
    cout << "The original array is: ";
    for(int i = 0; i <= length-1; i++)                       //打印待排序数组元素
    {
        cout << originalArray[i] << static_cast<char>(32);   //32是空格的ASCII值，把它转换成空格输出
    }
    cout << endl;

    int *sortedArray = BubbleSort(originalArray,length);     //调用排序算法，返回一个指向int型数组的指针
    cout << "The sorted array is: ";
    for(int i = 0; i <= length-1; i++)                       //打印排序结束之后的数组元素
    {
        cout << sortedArray[i] << static_cast<char>(32);
    }
    return 0;
}

运行结果为：

The length of the array is 9
The original array is: 2 7 1 5 9 3 10 18 6
The sorted array is: 1 2 3 5 6 7 9 10 18

冒泡排序的算法复杂度：
如果待排序列本身有序，则需要 n-1 次比较，0 次数据交换，时间复杂度为 O(n)；在最坏的情况下，即待排序列为逆序时，则需要 （n(n-1)/2）次比较和等数量级的元素交换。因此，冒泡排序总的时间复杂度为 O(n^2)。