排序算法总结

第一轮	比较 5 和 3 → 交换，[3, 5, 8, 4]	比较 5 和 8 → 不交换，[3, 5, 8, 4]	比较 8 和 4 → 交换，[3, 5, 4, 8]	第一轮结束，8 已就位。
第二轮	比较 3 和 5 → 不交换	比较 5 和 4 → 交换，[3, 4, 5, 8]
第三轮	比较 3 和 5 → 不交换

算法特点

特性	描述
排序思想	交换
是否比较排序	是
是否稳定	稳定
是否原地排序	是
最好时间复杂度	O(n)
最坏时间复杂度	O(n²)
平均时间复杂度	O(n²)
空间复杂度	O(1)

实现方式

基础版本

def bubble_sort(arr):

    n = len(arr)

    for i in range(n):

        for j in range(0, n - i - 1):

            if arr[j] > arr[j + 1]:

                arr[j], arr[j + 1] = arr[j + 1], arr[j]

优化版本（提前结束）

def bubble_sort_optimized(arr):

    n = len(arr)

    for i in range(n):

        swapped = False

        for j in range(0, n - i - 1):

            if arr[j] > arr[j + 1]:

                arr[j], arr[j + 1] = arr[j + 1], arr[j]

                swapped = True

        if not swapped:

            break

时间复杂度分析

最坏情况（完全逆序）

比较次数：(n-1) + (n-2) + ... + 1 = n(n-1)/2 → O(n²)

最好情况（已排序，带优化）

一轮比较无交换即可结束 →O(n)

空间复杂度分析

仅使用常数级临时变量

空间复杂度：O(1)

优缺点

优点	实现简单稳定排序适合教学和演示
缺点	时间复杂度高实际工程中极少使用

适用场景

排序算法教学
数据规模极小
数据几乎有序（带优化版本）

快速排序

基础概念

快速排序是一种基于分治思想（Divide & Conquer），通过选取基准值（Pivot）将序列划分为小于基准/大于基准两部分，再对左右子序列递归排序的高效排序算法。

基本思想

快速排序包含三个关键步骤：

选择基准（Pivot）

从数组中选取一个元素作为基准值。

划分（Partition）

将数组重新排列，使：

左侧元素 ≤ pivot

右侧元素 ≥ pivot

递归排序

对基准左右两部分分别进行快速排序。

执行过程

以数组为例:

[7, 3, 9, 4, 6]

第 1 次划分

选 pivot = 7

重排后：

[3, 4, 6, 7, 9]

此时：

7 已在最终位置

左侧 [3,4,6]

右侧 [9]

第 2 次递归（左区）

pivot = 3：

[3, 4, 6]

3 已就位，继续递归 [4,6]

排序完成

[3, 4, 6, 7, 9]

算法特点

特性	描述
排序思想	分治
是否比较排序	是
是否稳定	不稳定
是否原地排序	是
平均时间复杂度	O(n log n)
最坏时间复杂度	O(n²)
最好时间复杂度	O(n log n)
空间复杂度	O(log n)

实现方式

Lomuto 分区（简单、好理解）

def partition(arr, low, high):

    pivot = arr[high]

    i = low - 1



    for j in range(low, high):

        if arr[j] < pivot:

            i += 1

            arr[i], arr[j] = arr[j], arr[i]



    arr[i + 1], arr[high] = arr[high], arr[i + 1]

    return i + 1

Hoare 分区（更高效，工业常用）

def partition(arr, low, high):

    pivot = arr[(low + high) // 2]

    i, j = low - 1, high + 1



    while True:

        i += 1

        while arr[i] < pivot:

            i += 1



        j -= 1

        while arr[j] > pivot:

            j -= 1



        if i >= j:

            return j



        arr[i], arr[j] = arr[j], arr[i]

工程化技巧

随机化基准

import random

pivot_index = random.randint(low, high)

避免最坏情况

三数取中（median-of-three）

取 arr[low]、arr[mid]、arr[high] 的中位数

实际工程中非常常用

小数组切换插入排序

当子数组规模 < 16

使用插入排序更快

时间复杂度分析

最好情况

每次正好平分数组，时间复杂度：O(n log n)。

平均情况

每次划分较均匀，递归深度约为 log n，T(n) = 2T(n/2) + O(n)

→ O(n log n)。

最坏情况

每次选择最小或最大元素作为 pivot，退化为链式递归，T(n) = T(n-1) + O(n)→ O(n²)。

空间复杂度分析

原地排序

递归栈空间：

平均：O(log n)

最坏：O(n)

优缺点

优点	平均性能极优原地排序，缓存友好工程实现成熟
缺点	最坏情况性能差不稳定

适用场景

内存排序
对性能要求极高
可接受不稳定排序

归并排序

基础概念

归并排序是一种基于分治思想（Divide & Conquer）将序列不断二分拆分,在回溯阶段有序合并的稳定、高效排序算法。

基本思想

归并排序遵循三个步骤（分治策略）：

分（Divide）

将数组递归地拆分成两个子数组，直到每个子数组只剩1个元素。

治（Conquer）

单个元素天然有序，无需处理。

合（Merge）

将两个有序子数组合并成一个新的有序数组。

执行过程

以数组为例：

[8, 3, 5, 4, 7, 6, 1, 2]

拆分阶段

[8,3,5,4] [7,6,1,2]

[8,3] [5,4] [7,6] [1,2]

[8] [3] [5] [4] [7] [6] [1] [2]

合并阶段

[8] + [3] → [3,8]

[5] + [4] → [4,5]

[7] + [6] → [6,7]

[1] + [2] → [1,2]

[3,8] + [4,5] → [3,4,5,8]

[6,7] + [1,2] → [1,2,6,7]

最终

[1,2,3,4,5,6,7,8]

算法特点

特性	描述
排序思想	分治
是否比较排序	是
是否稳定	稳定
是否原地排序	否
时间复杂度	始终 O(n log n)
空间复杂度	O(n)

实现方式

递归实现

def merge_sort(arr):

    if len(arr) <= 1:

        return arr



    mid = len(arr) // 2

    left = merge_sort(arr[:mid])

    right = merge_sort(arr[mid:])



    return merge(left, right)



def merge(left, right):

    result = []

    i = j = 0



    while i < len(left) and j < len(right):

        if left[i] <= right[j]:

            result.append(left[i])

            i += 1

        else:

            result.append(right[j])

            j += 1



    result.extend(left[i:])

    result.extend(right[j:])

return result

迭代（自底向上）实现

将数组视为 n 个长度为 1 的子数组

两两合并成长度为 2 的子数组

再合并为 4、8... 直到完成

常用于工程优化，避免递归栈溢出

def merge_sort_bottom_up(arr):

    n = len(arr)

    temp = [0] * n   # 辅助数组

    size = 1         # 当前子数组长度



    while size < n:

        # 每次合并相邻的两个 size 长度子数组

        for left in range(0, n, 2 * size):

 &nb