Python冒泡排序详解：从原理到代码实现与优化

在Python算法入门学习中，排序算法是绕不开的基础内容，而冒泡排序作为最经典、最易理解的排序算法之一，绝对是新手的首选入门案例。它的核心逻辑就像水中的气泡一样，让"大元素"逐步"上浮"到数组末端，过程直观且逻辑清晰。今天，我们就全面拆解冒泡排序，从原理理解到Python代码实现，再到性能优化，带你彻底掌握这个基础排序算法。

一、冒泡排序是什么？核心原理很直观

冒泡排序（Bubble Sort）是一种简单的交换排序，核心思路是：

重复遍历要排序的数组，每次遍历过程中，依次比较相邻的两个元素。如果它们的顺序错误（比如"前元素大于后元素"，针对升序排序），就交换这两个元素的位置。这样一来，每完成一轮遍历，数组中未排序部分的"最大元素"就会像气泡一样，被逐步"推"到数组的末尾。

举个通俗的例子：假设我们有一个无序数组 [5, 2, 9, 1, 5, 6]，要通过冒泡排序实现升序排列。第一轮遍历会依次比较 (5,2)、(5,9)、(9,1)、(9,5)、(9,6)，每遇到前大后小的组合就交换，最终最大的元素 9 会被"浮"到数组最后；第二轮遍历不再考虑已排好的 9，继续比较剩余元素，把第二大的 6 浮到倒数第二位......以此类推，直到整个数组有序。

关键特点：

属于"原地排序"：不需要额外的数组空间，仅在原数组上进行交换操作；
属于"稳定排序"：相等元素的相对位置不会改变（比如两个 5，排序后仍保持原来的顺序）；
时间复杂度：最坏情况和平均情况均为 O(n²)，最好情况（数组已有序）可优化到 O(n)。

二、Python实现基础版冒泡排序

先从最基础的升序排序开始，我们一步步拆解代码逻辑：

1. 核心逻辑拆解

确定遍历轮数：对于长度为 n 的数组，最多需要遍历 n-1 轮（因为每轮确定一个最大元素，最后一个元素无需比较）；
每轮遍历的比较范围：第 i 轮（从 0 开始计数）需要比较的元素范围是 [0, n-1-i]（因为后面 i 个元素已经排好序）；
相邻元素比较与交换：遍历过程中，若当前元素大于下一个元素，就交换两者位置。

2. 基础版代码实现

python 复制代码

def bubble_sort(arr):
    n = len(arr)
    # 外层循环：控制遍历轮数，共 n-1 轮
    for i in range(n - 1):
        # 内层循环：控制每轮比较的范围，每轮结束后，最大元素已"浮"到末尾
        for j in range(n - 1 - i):
            # 比较相邻元素，前大后小则交换（升序排序）
            if arr[j] > arr[j + 1]:
                # Python 优雅的交换写法，无需临时变量
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

# 测试代码
if __name__ == "__main__":
    test_arr = [5, 2, 9, 1, 5, 6]
    sorted_arr = bubble_sort(test_arr)
    print("排序前：", test_arr)  # 注意：原数组已被修改（原地排序）
    print("排序后：", sorted_arr)

3. 代码运行结果

text 复制代码

排序前： [1, 2, 5, 5, 6, 9]
排序后： [1, 2, 5, 5, 6, 9]

4. 关键说明

原地排序特性：上述代码中，我们直接修改了输入数组 arr 的元素顺序，因此排序后原数组会发生变化。如果需要保留原数组，可以先创建一个副本再排序（如 arr_copy = arr.copy()）；
交换写法：Python 支持 a, b = b, a 的简洁交换方式，无需像其他语言那样定义临时变量，代码更简洁；
降序排序修改：若要实现降序排序，只需将内层循环的判断条件改为 if arr[j] < arr[j + 1] 即可。

三、基础版的问题：不必要的遍历------优化版冒泡排序

基础版冒泡排序存在一个问题：如果数组在第 i 轮（i < n-1）就已经完全有序，后续的遍历仍然会继续执行，这会造成不必要的性能浪费。

比如数组 [1, 2, 3, 4, 5]，基础版会执行 4 轮遍历，但实际上第一轮遍历后，数组已经有序，后续 3 轮都是多余的。

1. 优化思路：添加"有序标记"

在每轮遍历开始前，添加一个布尔变量（如 is_sorted）标记数组是否已有序。如果某一轮遍历中，没有发生任何一次元素交换，说明数组已经完全有序，直接跳出后续遍历，结束排序。

2. 优化版代码实现

python 复制代码

def optimized_bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        is_sorted = True  # 初始标记为"有序"
        for j in range(n - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                is_sorted = False  # 发生交换，标记为"无序"
        # 若当前轮未发生交换，说明数组已有序，直接退出
        if is_sorted:
            break
    return arr

# 测试已有序数组
if __name__ == "__main__":
    test_arr1 = [1, 2, 3, 4, 5]
    optimized_bubble_sort(test_arr1)
    print("已有序数组排序后：", test_arr1)  # 仅执行 1 轮遍历

    test_arr2 = [5, 2, 9, 1, 5, 6]
    optimized_bubble_sort(test_arr2)
    print("无序数组排序后：", test_arr2)

3. 优化效果说明

优化后，对于已有序的数组，排序时间复杂度从 O(n²) 降至 O(n)，这是冒泡排序的"最好情况"；对于无序数组，性能与基础版一致，但不会增加额外开销，是非常实用的优化。

四、进阶优化：双向冒泡排序（鸡尾酒排序）

还有一种特殊场景：数组中存在"小元素"在数组末端，基础版冒泡排序需要多轮遍历才能将其"沉"到前端。比如数组 [3, 4, 2, 1, 5, 6]，末端的 1 和 2 是小元素，基础版需要多轮才能将它们移到前面。

针对这种情况，可进一步优化为"双向冒泡排序"（也叫鸡尾酒排序）：

核心思路：每轮遍历分为两个阶段------第一阶段从左到右，将最大元素浮到末尾；第二阶段从右到左，将最小元素沉到前端。这样可以减少小元素移动的轮数，提升排序效率。

双向冒泡排序代码实现

python 复制代码

def cocktail_sort(arr):
    n = len(arr)
    left = 0  # 左边界
    right = n - 1  # 右边界
    while left < right:
        is_sorted = True
        # 第一阶段：从左到右，将最大元素浮到右边界
        for j in range(left, right):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                is_sorted = False
        if is_sorted:
            break
        right -= 1  # 右边界左移（已排好最大元素）

        # 第二阶段：从右到左，将最小元素沉到左边界
        for j in range(right, left, -1):
            if arr[j] < arr[j - 1]:
                arr[j], arr[j - 1] = arr[j - 1], arr[j]
                is_sorted = False
        if is_sorted:
            break
        left += 1  # 左边界右移（已排好最小元素）
    return arr

# 测试代码
if __name__ == "__main__":
    test_arr = [3, 4, 2, 1, 5, 6]
    cocktail_sort(test_arr)
    print("双向冒泡排序后：", test_arr)  # 输出：[1, 2, 3, 4, 5, 6]

适用场景说明

双向冒泡排序在"数组两端存在小元素或大元素"的场景下性能更优，但整体时间复杂度仍为 O(n²)，不适用于大规模数据排序，仅作为冒泡排序的进阶学习案例。

五、冒泡排序的性能分析与适用场景

1. 性能指标

排序类型	时间复杂度（最坏）	时间复杂度（平均）	时间复杂度（最好）	空间复杂度	稳定性
基础版冒泡排序	O(n²)	O(n²)	O(n²)	O(1)	稳定
优化版冒泡排序	O(n²)	O(n²)	O(n)	O(1)	稳定
双向冒泡排序	O(n²)	O(n²)	O(n)	O(1)	稳定

2. 适用场景

冒泡排序的时间复杂度为 O(n²)，效率较低，因此不适合大规模数据排序。其核心价值在于"逻辑简单、代码易实现"，适合以下场景：

算法入门学习：理解排序的核心逻辑（比较与交换）；
小规模数据排序：数据量较少（如 n < 100）时，性能差异不明显；
接近有序的数据排序：优化版冒泡排序在数据接近有序时，能达到 O(n) 的高效性能；
对排序稳定性有要求的场景：冒泡排序是稳定排序，能保证相等元素的相对位置不变。

3. 不适用场景

大规模无序数据排序（如 n > 1000）：此时应选择效率更高的排序算法，如快速排序（O(n log n)）、归并排序（O(n log n)）等。

六、常见问题与注意事项

原数组被修改 ：冒泡排序是原地排序，直接操作输入数组。若需保留原数组，需先创建副本（如 arr_copy = arr[:] 或 arr_copy = arr.copy()）；
边界条件错误：内层循环的范围容易写错（如多写 1 或少写 1），记住核心：第 i 轮的比较范围是 [0, n-1-i]；
忘记优化有序场景：基础版在数组已有序时仍会执行全部轮数，建议优先使用添加"有序标记"的优化版；
混淆升序/降序条件：升序是"前大后小则交换"，降序是"前小后大则交换"，不要记反；
数据类型兼容：排序的数组元素需支持比较操作（如数字、字符串），若为自定义对象，需重写比较方法。

七、总结：学习冒泡排序的核心价值

很多人会觉得冒泡排序"效率低、不实用"，但作为算法入门的第一站，它的价值远不止"排序"本身：

理解"比较-交换"的排序核心逻辑，为学习更复杂的排序算法（如快速排序、插入排序）打下基础；
通过优化过程（添加有序标记、双向遍历），培养"发现问题-解决问题"的算法思维；
掌握Python的简洁语法特性（如元素交换、循环结构），提升代码编写能力。

对于Python初学者来说，建议先手动实现基础版，再理解优化思路并写出优化版，最后尝试双向冒泡排序，通过对比不同版本的代码，感受算法优化的魅力。