9.冒泡排序：像鱼缸泡泡一样的简单排序算法

一、什么是冒泡排序？

冒泡排序（Bubble Sort）是一种简单直观的排序算法，它的核心思想是通过相邻元素的比较和交换，让较大的元素像鱼缸里的泡泡一样 "浮" 到数组的末尾，重复这个过程直到所有元素排序完成。

简单来说，冒泡排序就像鱼缸里的泡泡：

每次只比较相邻的两个元素；
如果前面的元素比后面的大，就交换它们的位置；
一轮结束后，最大的元素会 "浮" 到数组的最后；
重复这个过程，直到所有元素都排好序。

二、冒泡排序的核心步骤

冒泡排序的核心步骤可以分为以下几步：

遍历数组：从第一个元素开始，遍历整个数组；
相邻比较：比较当前元素和下一个元素的大小；
交换位置：如果前面的元素比后面的大，就交换它们的位置；
重复：继续遍历下一个位置，直到所有元素排序完成。

三、冒泡排序的代码实现

1. 基础版本

复制代码

#include <stdio.h>

// 交换两个元素
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 冒泡排序
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        // 每一轮将最大的元素"浮"到末尾
        for (int j = 0; j < n - i - 1; j++) {
            // 相邻比较，前面比后面大就交换
            if (arr[j] > arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
            }
        }
    }
}

// 打印数组
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {5, 2, 6, 1, 4, 3};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("排序前：");
    printArray(arr, n);

    bubbleSort(arr, n);

    printf("排序后：");
    printArray(arr, n); // 输出：1 2 3 4 5 6

    return 0;
}

2. 优化版本：提前结束

如果某一轮没有发生任何交换，说明数组已经有序，可以提前结束排序：

复制代码

#include <stdio.h>
#include <stdbool.h>

// 交换两个元素
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 优化的冒泡排序：提前结束
void optimizedBubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        bool swapped = false; // 标记本轮是否发生交换
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
                swapped = true; // 标记本轮发生了交换
            }
        }
        // 如果本轮没有发生交换，说明数组已经有序，提前结束
        if (!swapped) {
            break;
        }
    }
}

// 打印数组
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {5, 2, 6, 1, 4, 3};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("排序前：");
    printArray(arr, n);

    optimizedBubbleSort(arr, n);

    printf("排序后：");
    printArray(arr, n); // 输出：1 2 3 4 5 6

    return 0;
}

四、冒泡排序的时间复杂度和空间复杂度

时间复杂度：O (n²)，因为需要两层循环，每层循环的时间复杂度都是 O (n)；
空间复杂度：O (1)，只需要常数级别的额外空间；
稳定性：稳定，因为交换操作不会改变相同元素的相对位置。

五、冒泡排序的优缺点

优点

实现简单：代码逻辑清晰，容易理解和实现；
空间复杂度低：不需要额外的内存空间；
稳定：不会改变相同元素的相对位置；
可提前结束：如果数组已经有序，可以提前结束排序。

缺点

时间复杂度高：O (n²)，不适合大规模数据排序；
效率低：即使数组已经有序，仍然需要 O (n²) 的时间复杂度（除非优化提前结束）。

六、冒泡排序的实际应用场景

冒泡排序虽然效率不高，但在以下场景中仍然有用：

小规模数据排序：当数据量较小时，冒泡排序的实现简单，性能可以接受；
教学和学习：冒泡排序是理解排序算法的基础，适合初学者学习排序的基本思想；
稳定性要求高的场景：比如排序的元素是对象，需要保持相同元素的相对位置。

七、总结

冒泡排序是一种简单直观的排序算法，它的核心思想是通过相邻元素的比较和交换，让较大的元素像鱼缸里的泡泡一样 "浮" 到数组的末尾，重复这个过程直到所有元素排序完成。

冒泡排序的时间复杂度是 O (n²)，空间复杂度是 O (1)，虽然效率不高，但实现简单，稳定，适合小规模数据排序和教学学习。

希望这篇文章能帮助你理解冒泡排序的原理和实现！