数据结构与算法 排序算法 冒泡排序

排序算法之冒泡排序

一、原理

冒泡排序（BubbleSort）是一种简单的排序算法。

每次遍历数组，从前往后比较相邻两个数的大小

相邻两个元素A和B，如果A > B，则交换A与B的值，同时指针移动到原本B所在的位置

一次遍历之后，最大的元素就会处于数组的末尾

第二次遍历之后，第二大的元素处于倒数第二个位置

重复这个操作，直到整个数列有序

 

注意：

第一轮比较次数：数组总长度 - 1

下一轮的比较次数：当前一轮比较次数 - 1

外层循环：比较轮数

内层循环：每轮比较次数及交换

 二、图解

 

三、时间复杂度和稳定性

最好时间复杂度：$O(n)$

数组已经有序，比较次数和交换次数都是最小值

最坏时间复杂度：$O(n^2)$

数组是逆序的，每一趟排序，都要进行比较，比较次数和交换次数都是最大值

平均时间复杂度：$O(n^2)$

稳定性：稳定

排序之前，a[i]在a[j]之前，排序之后，a[i]仍在a[j]前面，所以这个排序算法是稳定的。

四、实现

4.1 C++实现

template<class T>
void Swap(T &a, T &b)
{
    T tmp = a;
    a = b;
    b = tmp;
}

template<class T>
void bubbleSort(T *arr, int length)
{
    for (int i = 0; i < length - 1; ++i)
    {
        for (int j = 0; j < length - i - 1; ++j)
        {
            if (arr[j] > arr[j + 1])
            {
                Swap(arr[j], arr[j + 1]);
            }
        }
    }
}

 

4.2 Java实现

 

五、优化

看图解的时候很明显能看到，第四趟排序完成后，数组已经是有序的了，但是循环仍然在进行，进行第5,6,7...次排序

然而并没有必要，所以可以添加一个标志变量

如果发生了交换，就说明这个数组不是有序的

如果没发生交换，就说明这个数组已排好序，可以退出循环

 

5.1 C++实现

template<class T>
void Swap(T &a, T &b)
{
    T tmp = a;
    a = b;
    b = tmp;
}

template<class T>
void bubbleSort(T *arr, int length)
{
    int flag;
    for (int i = 0; i < length - 1; ++i)
    {
        flag = 0;
        for (int j = 0; j < length - i - 1; ++j)
        {
            if (arr[j] > arr[j + 1])
            {
                Swap(arr[j], arr[j + 1]);
                flag = 1;
            }
        }
        if (flag == 0)
        {
            break;
        }
    }
}

5.2 Java实现