基础算法-冒泡排序

冒泡排序 (Bubble Sort)

像水底的气泡一样，每次比较相邻的两个元素，如果顺序不对就交换它们。每一轮都会把当前未排序部分的最大值“浮”到数组末尾。

核心代码

#include <stdio.h>

// 冒泡排序函数
void bubbleSort(int arr[], int n) {
    // 外层循环控制排序的轮数，n个元素需要n-1轮
    for (int i = 0; i < n - 1; i++) {
        // 内层循环进行相邻元素的比较和交换
        // 每完成一轮，最大的元素就到了末尾，所以比较次数要减去i
        for (int j = 0; j < n - i - 1; j++) {
            // 如果前一个元素比后一个元素大，则交换它们
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];      // 借助临时变量temp
                arr[j] = arr[j + 1];    // 把较小的值赋给前一个位置
                arr[j + 1] = temp;      // 把较大的值赋给后一个位置
            }
        }
    }
}

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

int main() {
    int arr[] = {64, 34, 25, 12, 22};
    int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
    
    printf("排序前：");
    printArray(arr, n);
    
    bubbleSort(arr, n); // 调用冒泡排序
    
    printf("排序后：");
    printArray(arr, n);
    return 0;
}

示例演示

{64, 34, 25, 12, 22}

第 1 轮：寻找整个数组的最大值
目标：把最大的数“冒泡”到数组的最后位置。
比较 64 和 34：64 > 34，交换。数组变为：[34, 64, 25, 12, 22]
比较 64 和 25：64 > 25，交换。数组变为：[34, 25, 64, 12, 22]
比较 64 和 12：64 > 12，交换。数组变为：[34, 25, 12, 64, 22]
比较 64 和 22：64 > 22，交换。数组变为：[34, 25, 12, 22, 64]
第 1 轮结束：最大值 64 已经归位到最右侧。
当前数组：[34, 25, 12, 22, | 64] （竖线右边为已排好序的部分）

第 2 轮：寻找剩余元素的最大值
目标：把第二大的数“冒泡”到倒数第二个位置。
比较 34 和 25：34 > 25，交换。数组变为：[25, 34, 12, 22, | 64]
比较 34 和 12：34 > 12，交换。数组变为：[25, 12, 34, 22, | 64]
比较 34 和 22：34 > 22，交换。数组变为：[25, 12, 22, 34, | 64]
第 2 轮结束：第二大值 34 归位。
当前数组：[25, 12, 22, | 34, 64]

第 3 轮：
目标：把第三大的数归位。
比较 25 和 12：25 > 12，交换。数组变为：[12, 25, 22, | 34, 64]
比较 25 和 22：25 > 22，交换。数组变为：[12, 22, 25, | 34, 64]
第 3 轮结束：第三大值 25 归位。
当前数组：[12, 22, | 25, 34, 64]

第 4 轮：
目标：把第四大的数归位（此时最小的数自然也就归位了）。
比较 12 和 22：12 < 22，不交换。
第 4 轮结束：排序完成。
最终结果：[12, 22, 25, 34, 64]

复杂度

时间复杂度是 \(O(n^2)\)
空间复杂度是 \(O(1)\)