经典冒泡排序法 & 冒泡排序法的优化

一、原理简介

冒泡排序的原理即是，对于一个元素个数为 n 的无序集合，从第一个元素开始依次和下一个元素比较，较大者放在后面的位置，最终可以得到一个最大值并放置在最后一个位置。接下来再遍历 0 至 n-1 个元素，找到第二大的数放置在 n-1 的位置，反复如此完成排序。

 

二、时间复杂度

冒泡排序的时间复杂度为 O(n^2)。

第一次需要检查n个元素，但随后检查的元素数依次为n - 1, n – 2, …, 2和1。平均每次检查的元素数为1/2 n， 因此运行时间为 n 1/2 * n，简单地写作 O(n^2)。

 

三、代码实现

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void bubbleSort(int *array, int length) {
    for (int i = 0; i < length; i++) {
        for (int j = 0; j < length - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                swap(&array[j], &array[j + 1]);
            }
        }
    }
}

void printArray(int *array, int length) {
    for (size_t i = 0; i < length; i++) {
        printf("%d ", array[i]);
    }
}

int main() {
    int arr[] = { 3, 1, 2, 5, 2, 5, 6, 9, 5, 2, 5, 6 };
    bubbleSort(arr, sizeof(arr) / sizeof(arr[0]));
    printArray(arr, sizeof(arr) / sizeof(arr[0]));
    return 0;
}

执行结果为：

1 2 2 2 3 5 5 5 5 6 6 9 

​

四、优化

假设数组已经是排序了的，亦或是在进行数次冒泡后数组变得有序了，那么我们其实是不需要做无谓的后续操作了。

所以，添加一个 exchange 变量来记录在某次冒泡操作中是否发生了交换动作，如果没有，则说明数组已经排序：

    public static void bubbleSort(int[] array) {
        boolean exchange = false;
        for (int i = array.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) {
                    // swap
                    array[j] ^= array[j + 1];
                    array[j + 1] ^= array[j];
                    array[j] ^= array[j + 1];
                    exchange = true;
                }
            }
            if (!exchange) {
                return; // 已经是排序的话无需后续操作了
            }
        }
    }

这样做的好处是，对于一个已排序数组，我们只需要 O(n) 的时间复杂度，即使是乱序的数组，比起之前经典的冒泡排序，通常也能减少不少运算。