排序算法大全：从冒泡到快速排序
项目地址: https://gitcode.com/GitHub_Trending/he/hello-algo 本文全面系统地介绍了各类排序算法，从基础的冒泡排序、选择排序、插入排序，到高效的快速排序与归并排序，再到特殊场景的计数排序、基数排序和桶排序。文章详细分析了每种算法的原理、实现代码、时间复杂度、空间复杂度、稳定性等关键特性，并通过对比表格和可视化图表帮助读者深入理解不同算法的优缺点和适用场景。最后，文章还提供了基于复杂度分析和实际性能的综合选择建议，帮助读者在实际应用中做出最合适的技术决策。
基础排序算法：冒泡、选择、插入
在排序算法的世界中，有三种基础但非常重要的算法：冒泡排序、选择排序和插入排序。虽然它们的时间复杂度都是O(n²)，但各自有着独特的工作原理和适用场景，是理解更复杂排序算法的基础。
冒泡排序：气泡上升的优雅
冒泡排序通过连续地比较与交换相邻元素实现排序，这个过程就像气泡从底部升到顶部一样，因此得名。
算法原理： 冒泡排序的核心思想是重复遍历数组，每次比较相邻的两个元素，如果顺序错误就交换它们。经过一轮遍历后，最大的元素会"冒泡"到数组的末尾。
def bubble_sort(nums: list[int]):
"""冒泡排序"""
n = len(nums)
# 外循环：未排序区间为 [0, i]
for i in range(n - 1, 0, -1):
# 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in range(i):
if nums[j] > nums[j + 1]:
# 交换 nums[j] 与 nums[j + 1]
nums[j], nums[j + 1] = nums[j + 1], nums[j]
优化版本： 通过添加标志位，可以在数组已经有序时提前终止排序：
def bubble_sort_with_flag(nums: list[int]):
"""冒泡排序（标志优化）"""
n = len(nums)
for i in range(n - 1, 0, -1):
flag = False
for j in range(i):
if nums[j] > nums[j + 1]:
nums[j], nums[j + 1] = nums[j + 1], nums[j]
flag = True
if not flag:
break
算法特性：
- 时间复杂度：O(n²)，优化后最佳情况O(n)
- 空间复杂度：O(1)，原地排序
- 稳定性：稳定排序
- 自适应：是
选择排序：精准选择的最优解
选择排序的工作原理非常简单：每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。
算法流程：
def selection_sort(nums: list[int]):
"""选择排序"""
n = len(nums)
# 外循环：未排序区间为 [i, n-1]
for i in range(n - 1):
# 内循环：找到未排序区间内的最小元素
k = i
for j in range(i + 1, n):
if nums[j] < nums[k]:
k = j # 记录最小元素的索引
# 将该最小元素与未排序区间的首个元素交换
nums[i], nums[k] = nums[k], nums[i]
算法特性：
- 时间复杂度：O(n²)，非自适应
- 空间复杂度：O(1)，原地排序
- 稳定性：非稳定排序
- 自适应：否
插入排序：扑克牌式的自然排序
插入排序的工作原理与手动整理一副牌的过程非常相似，将未排序元素插入到已排序部分的正确位置。
算法实现：
def insertion_sort(nums: list[int]):
"""插入排序"""
# 外循环：已排序区间为 [0, i-1]
for i in range(1, len(nums)):
base = nums[i]
j = i - 1
# 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
while j >= 0 and nums[j] > base:
nums[j + 1] = nums[j] # 将 nums[j] 向右移动一位
j -= 1
nums[j + 1] = base # 将 base 赋值到正确位置
插入操作可视化：
算法特性：
- 时间复杂度：O(n²)，最佳情况O(n)
- 空间复杂度：O(1)，原地排序
- 稳定性：稳定排序
- 自适应：是
三种算法的对比分析
| 特性 | 冒泡排序 | 选择排序 | 插入排序 |
|---|---|---|---|
| 时间复杂度 | O(n²) | O(n²) | O(n²) |
| 最佳情况 | O(n) | O(n²) | O(n) |
| 空间复杂度 | O(1) | O(1) | O(1) |
| 稳定性 | 稳定 | 不稳定 | 稳定 |
| 自适应 | 是 | 否 | 是 |
| 交换次数 | 较多 | 较少 | 较少 |
实际应用建议：
虽然这三种算法的时间复杂度相同，但在实际应用中有着不同的表现：
- 插入排序在小数据量或部分有序数据中表现最佳，许多编程语言的内置排序函数在小数组时采用插入排序
- 冒泡排序由于其简单性常用于教学目的，但在实际应用中较少使用
- 选择排序的交换次数最少，但缺乏自适应能力
这三种基础排序算法虽然时间复杂度较高，但它们是理解更复杂算法的基础，每种算法都有其独特的思维模式和适用场景。掌握它们的工作原理和特性，将为学习更高效的排序算法打下坚实的基础。
高效排序：快速排序与归并排序
在排序算法的世界里，快速排序和归并排序无疑是两颗璀璨的明星。它们都采用了分治策略，将复杂问题分解为更小的子问题来解决，但各自的实现方式和适用场景却有着显著差异。让我们深入探索这两种高效排序算法的奥秘。
快速排序：分而治之的典范
快速排序由英国计算机科学家Tony Hoare于1959年发明，是一种基于分治策略的高效排序算法。其核心思想是通过"哨兵划分"操作将数组分为两个部分，然后递归地对这两个部分进行排序。
算法原理与实现
快速排序的核心是哨兵划分操作，其基本流程如下：
def partition(nums, left, right):
"""哨兵划分函数"""
# 选择最左端元素作为基准数
i, j = left, right
while i < j:
# 从右向左找首个小于基准数的元素
while i < j and nums[j] >= nums[left]:
j -= 1
# 从左向右找首个大于基准数的元素
while i < j and nums[i] <= nums[left]:
i += 1
# 交换这两个元素
nums[i], nums[j] = nums[j], nums[i]
# 将基准数交换到正确位置
nums[i], nums[left] = nums[left], nums[i]
return i
完整的快速排序算法：
def quick_sort(nums, left, right):
"""快速排序主函数"""
if left >= right:
return
# 执行哨兵划分
pivot = partition(nums, left, right)
# 递归排序左右子数组
quick_sort(nums, left, pivot - 1)
quick_sort(nums, pivot + 1, right)
性能特点
快速排序的性能表现可以通过以下表格清晰展示：
| 特性 | 数值 | 说明 |
|---|---|---|
| 平均时间复杂度 | O(n log n) | 在大多数情况下表现出色 |
| 最差时间复杂度 | O(n²) | 当输入数组已排序或逆序时 |
| 空间复杂度 | O(log n) | 递归调用栈的空间需求 |
| 稳定性 | 不稳定 | 相等元素可能改变相对顺序 |
| 原地排序 | 是 | 不需要额外的存储空间 |
优化策略
为了应对最坏情况，快速排序有多种优化方案：
1. 中位数基准数优化
def median_three(nums, left, mid, right):
"""三数取中法选择基准数"""
a, b, c = nums[left], nums[mid], nums[right]
if (a <= b <= c) or (c <= b <= a):
return mid
if (b <= a <= c) or (c <= a <= b):
return left
return right
2. 递归深度优化
def quick_sort_optimized(nums, left, right):
"""递归深度优化的快速排序"""
while left < right:
pivot = partition(nums, left, right)
# 优先处理较短的子数组
if pivot - left < right - pivot:
quick_sort_optimized(nums, left, pivot - 1)
left = pivot + 1
else:
quick_sort_optimized(nums, pivot + 1, right)
right = pivot - 1
归并排序：稳定高效的合并艺术
归并排序采用典型的分治策略，将排序过程分为划分和合并两个阶段，确保在任何情况下都能保持稳定的O(n log n)时间复杂度。
算法流程详解
归并排序的实现包含两个主要函数：
def merge(nums, left, mid, right):
"""合并两个有序子数组"""
# 创建临时数组存储合并结果
tmp = [0] * (right - left + 1)
i, j, k = left, mid + 1, 0
# 合并过程
while i <= mid and j <= right:
if nums[i] <= nums[j]:
tmp[k] = nums[i]
i += 1
else:
tmp[k] = nums[j]
j += 1
k += 1
# 处理剩余元素
while i <= mid:
tmp[k] = nums[i]
i += 1
k += 1
while j <= right:
tmp[k] = nums[j]
j += 1
k += 1
# 将结果复制回原数组
for idx in range(len(tmp)):
nums[left + idx] = tmp[idx]
def merge_sort(nums, left, right):
"""归并排序主函数"""
if left >= right:
return
mid = (left + right) // 2
merge_sort(nums, left, mid) # 递归左半部分
merge_sort(nums, mid + 1, right) # 递归右半部分
merge(nums, left, mid, right) # 合并结果
性能特征分析
归并排序的性能特点如下表所示：
| 特性 | 数值 | 说明 |
|---|---|---|
| 时间复杂度 | O(n log n) | 在所有情况下都稳定 |
| 空间复杂度 | O(n) | 需要额外的存储空间 |
| 稳定性 | 稳定 | 相等元素保持原有顺序 |
| 原地排序 | 否 | 需要辅助数组 |
| 适应性 | 非自适应 | 性能不随输入特性变化 |
归并排序的流程可视化
两种算法的深度对比
快速排序和归并排序虽然都基于分治策略，但在多个方面存在显著差异：
1. 性能特征对比
| 特性 | 快速排序 | 归并排序 |
|---|---|---|
| 平均时间复杂度 | O(n log n) | O(n log n) |
| 最差时间复杂度 | O(n²) | O(n log n) |
| 空间复杂度 | O(log n) | O(n) |
| 稳定性 | 不稳定 | 稳定 |
| 缓存友好性 | 优秀 | 一般 |
| 适用场景 | 通用排序 | 需要稳定性的场景 |
2. 算法选择指南
选择排序算法时需要考虑以下因素：
- 数据规模：小规模数据适合简单排序算法，大规模数据适合快速排序或归并排序
- 内存限制：内存紧张时选择快速排序，充足时选择归并排序
- 稳定性要求：需要保持相等元素顺序时选择归并排序
- 数据分布：快速排序对随机数据表现最佳，归并排序对任何数据都稳定
3. 实际应用场景
快速排序适用场景：
- 通用目的的排序任务
- 内存受限的环境
- 对缓存性能要求高的应用
- 大多数编程语言的内置排序实现
归并排序适用场景：
- 需要稳定排序的场合
- 外部排序（大数据集无法全部装入内存）
- 链表排序（可优化空间复杂度到O(1)）
- 多路归并排序
算法优化与变体
两种算法都有多种优化版本和变体：
快速排序变体
- 双轴快速排序：使用两个基准数进行划分
- 三路快速排序：将数组划分为小于、等于、大于基准数三部分
- 内省排序：结合快速排序和堆排序的优点
归并排序变体
- 自底向上归并排序：迭代实现，避免递归开销
- 多路归并排序：同时合并多个有序序列
- 原地归并排序：减少空间使用但增加时间复杂度
性能测试与比较
通过实际测试可以观察到两种算法在不同数据规模下的表现：
# 性能测试示例代码
import time
import random
def test_performance(sort_func, data_size):
"""测试排序算法性能"""
data = [random.randint(0, 10000) for _ in range(data_size)]
start_time = time.time()
sort_func(data.copy())
return time.time() - start_time
# 测试不同数据规模
sizes = [1000, 10000, 100000]
for size in sizes:
quick_time = test_performance(quick_sort, size)
merge_time = test_performance(merge_sort, size)
print(f"数据规模 {size}: 快速排序 {quick_time:.4f}s, 归并排序 {merge_time:.4f}s")
测试结果通常显示：
- 小数据量时两种算法差异不大
- 大数据量时快速排序通常更快
- 对于已排序数据，归并排序表现更稳定
总结与选择建议
快速排序和归并排序都是极其优秀的分治排序算法，各有其独特的优势和适用场景。快速排序以其出色的平均性能和原地排序特性成为大多数情况下的首选，而归并排序则以其稳定性和可预测的性能在特定场景中不可替代。
在实际应用中，建议：
- 对于通用排序任务，优先选择快速排序
- 当需要稳定性时，选择归并排序
- 对于链表排序，归并排序是更好的选择
- 在内存受限环境中，选择快速排序
- 对于外部排序，使用归并排序的变体
理解这两种算法的内在原理和性能特征，能够帮助我们在面对不同的排序需求时做出最合适的选择，从而编写出既高效又可靠的排序代码。
特殊场景排序：计数、基数、桶排序
在排序算法的广阔领域中，除了我们熟知的比较排序算法外，还存在一类专门针对特定场景设计的非比较排序算法。这些算法在某些特定条件下能够突破O(n log n)的时间复杂度限制，达到线性时间复杂度。今天我们将深入探讨三种特殊的排序算法：计数排序、基数排序和桶排序，它们各自适用于不同的数据特性和应用场景。
计数排序：统计计数的艺术
计数排序是一种基于统计的非比较排序算法，特别适用于整数数组且数据范围相对较小的情况。其核心思想是通过统计每个元素出现的次数，然后根据统计结果直接确定元素在排序后数组中的位置。
算法原理
计数排序的工作原理可以分为三个主要步骤：
- 统计频率：遍历数组，找出最大值m，创建一个长度为m+1的计数数组，统计每个数字出现的次数
- 计算前缀和：将计数数组转换为前缀和数组，表示每个元素在排序后数组中的结束位置
- 反向填充：从原数组末尾开始遍历，根据前缀和数组确定每个元素的正确位置
def counting_sort(nums: list[int]):
"""计数排序完整实现"""
m = max(nums)
counter = [0] * (m + 1)
# 统计各数字出现次数
for num in nums:
counter[num] += 1
# 计算前缀和
for i in range(m):
counter[i + 1] += counter[i]
# 反向填充结果数组
n = len(nums)
res = [0] * n
for i in range(n - 1, -1, -1):
num = nums[i]
res[counter[num] - 1] = num
counter[num] -= 1
# 覆盖原数组
for i in range(n):
nums[i] = res[i]
性能分析
| 特性 | 数值 | 说明 |
|---|---|---|
| 时间复杂度 | O(n + m) | n为元素数量，m为数据范围 |
| 空间复杂度 | O(n + m) | 需要额外空间存储计数和结果 |
| 稳定性 | 稳定 | 保持相等元素的相对顺序 |
| 适用场景 | 整数、范围小 | 数据范围为常数级别时最优 |
应用限制
计数排序虽然高效，但有其特定的适用条件：
- 只能用于整数排序
- 数据范围m不能过大，否则空间消耗巨大
- 当n << m时，效率可能不如O(n log n)的算法
基数排序：逐位处理的智慧
基数排序是计数排序的扩展，通过对待排序元素的每一位进行排序来实现整体排序。它特别适用于固定位数的数字排序，如电话号码、学号等。
算法流程
基数排序采用最低位优先(LSD)的策略：
- 从最低位开始，对每一位执行计数排序
- 逐步向高位推进，直到最高位排序完成
- 每次排序都会基于前一次排序的结果
def radix_sort(nums: list[int]):
"""基数排序实现"""
# 获取最大位数
m = max(nums)
exp = 1
# 从最低位到最高位依次排序
while m // exp > 0:
counting_sort_digit(nums, exp)
exp *= 10
def counting_sort_digit(nums: list[int], exp: int):
"""按指定位数进行计数排序"""
# 初始化计数数组(0-9)
counter = [0] * 10
n = len(nums)
res = [0] * n
# 统计当前位数出现次数
for num in nums:
d = (num // exp) % 10
counter[d] += 1
# 计算前缀和
for i in range(1, 10):
counter[i] += counter[i - 1]
# 反向填充
for i in range(n - 1, -1, -1):
d = (nums[i] // exp) % 10
res[counter[d] - 1] = nums[i]
counter[d] -= 1
# 更新原数组
for i in range(n):
nums[i] = res[i]
多轮排序过程
复杂度分析
基数排序的时间复杂度为O(nk)，其中k为最大位数。当k为常数时，时间复杂度为O(n)。空间复杂度为O(n + d)，其中d为进制数（通常为10）。
桶排序：分而治之的策略
桶排序将数据分配到多个桶中，每个桶内部进行排序，最后合并所有桶的结果。它特别适用于数据量巨大且分布相对均匀的情况。
算法实现
def bucket_sort(nums: list[float]):
"""桶排序实现"""
# 初始化k个桶
k = len(nums) // 2
buckets = [[] for _ in range(k)]
# 将元素分配到各个桶中
for num in nums:
# 计算元素应该放入哪个桶
idx = int(num * k)
buckets[idx].append(num)
# 对每个桶内部进行排序
for i in range(k):
buckets[i].sort()
# 合并所有桶的结果
i = 0
for bucket in buckets:
for num in bucket:
nums[i] = num
i += 1
桶分配策略
性能特点
| 场景 | 时间复杂度 | 空间复杂度 | 备注 |
|---|---|---|---|
| 理想情况 | O(n) | O(n + k) | 数据均匀分布 |
| 最坏情况 | O(n²) | O(n + k) | 所有数据集中在一个桶 |
| 平均情况 | O(n + k) | O(n + k) | k为桶的数量 |
三种算法的对比与应用
为了更清晰地理解这三种特殊排序算法的适用场景，我们通过以下对比表格进行分析：
| 算法 | 最佳场景 | 时间复杂度 | 空间复杂度 | 稳定性 | 限制条件 |
|---|---|---|---|---|---|
| 计数排序 | 整数、范围小 | O(n + m) | O(n + m) | 稳定 | 只能处理整数 |
| 基数排序 | 固定位数数字 | O(nk) | O(n + d) | 稳定 | 需要固定位数 |
| 桶排序 | 数据分布均匀 | O(n) | O(n + k) | 依赖内部排序 | 需要良好的分布 |
实际应用场景
- 计数排序：适合小范围整数排序，如年龄统计、成绩排序等
- 基数排序：适合固定长度的数字排序，如电话号码、身份证号排序
- 桶排序：适合大数据量的外部排序，如海量数据的分批处理
选择指南
在选择合适的排序算法时，需要考虑以下因素：
- 数据类型：整数、浮点数还是其他类型
- 数据范围：数值的范围大小
- 数据分布：是否均匀分布
- 数据量：小数据量还是海量数据
- 稳定性要求：是否需要保持相等元素的相对顺序
通过合理选择和应用这些特殊场景排序算法，我们可以在特定条件下获得比传统比较排序算法更优的性能表现。这些算法在大数据处理、数据库系统、操作系统等领域的排序任务中发挥着重要作用。
排序算法复杂度与适用场景分析
在掌握了各种排序算法的基本原理后，深入理解它们的复杂度特征和适用场景对于在实际工程中选择合适的排序算法至关重要。不同的排序算法在时间复杂度、空间复杂度、稳定性等方面有着显著差异，这些特性决定了它们在不同场景下的表现优劣。
时间复杂度对比分析
排序算法的时间复杂度是衡量算法效率的核心指标。根据算法设计原理的不同，我们可以将常见排序算法的时间复杂度归纳如下：
平方级时间复杂度算法
冒泡排序：平均和最差情况均为 O(n²)，但在输入数据基本有序时，通过标志位优化可以达到 O(n) 的最佳时间复杂度。其两层嵌套循环结构决定了其效率相对较低。
选择排序：无论输入数据如何，时间复杂度始终为 O(n²)。因为它需要在未排序部分中反复寻找最小（或最大）元素。
插入排序：平均和最差情况为 O(n²)，但对于基本有序的数据集，可以达到接近 O(n) 的效率。这种自适应性使其在小规模数据或近乎有序数据中表现出色。
线性对数级时间复杂度算法
快速排序：平均情况 O(n log n)，但在最坏情况下（如输入完全有序或逆序）可能退化到 O(n²)。通过基准数优化（三数取中）和递归深度优化，可以大幅降低退化概率。
归并排序：稳定保持 O(n log n) 的时间复杂度，不受输入数据分布影响。其分治策略确保了性能的稳定性。
堆排序：同样保持 O(n log n) 的时间复杂度，但实际常数因子较大，通常比快速排序慢。
线性时间复杂度算法
计数排序：时间复杂度为 O(n + k)，其中 k 是数据范围。当 k = O(n) 时，复杂度为线性。
桶排序：时间复杂度取决于桶内排序算法，理想情况下为 O(n)，最差情况下可能退化到 O(n²)。
基数排序：时间复杂度为 O(d(n + k))，其中 d 是数字位数，k 是基数大小。
空间复杂度分析
空间复杂度反映了算法对内存资源的消耗程度：
| 算法类型 | 空间复杂度 | 特点 |
|---|---|---|
| 原地排序 | O(1) | 冒泡、选择、插入、堆排序、快速排序（优化后） |
| 非原地排序 | O(n) | 归并排序、计数排序、桶排序、基数排序 |
| 递归算法 | O(log n) ~ O(n) | 快速排序、归并排序的递归栈空间 |
稳定性特征对比
排序算法的稳定性对于多级排序场景至关重要：
稳定排序算法：
- 冒泡排序（相等元素不交换）
- 插入排序（相等元素保持相对位置）
- 归并排序（合并时保持相等元素顺序）
- 计数排序、桶排序、基数排序
非稳定排序算法：
- 选择排序（可能交换相等元素）
- 快速排序（哨兵划分可能改变相等元素顺序）
- 堆排序（堆调整可能破坏稳定性）
适用场景分析
小规模数据场景
当数据规模较小时（通常 n < 50），简单排序算法往往更具优势：
- 插入排序：数据基本有序时效率极高，适合增量排序
- 冒泡排序：代码简单，适合教学和小规模应用
- 选择排序：交换次数最少，适合交换成本高的场景
通用排序场景
对于中等至大规模数据，基于比较的 O(n log n) 算法是首选：
- 快速排序：综合性能最佳，缓存友好，是大多数语言标准库的选择
- 归并排序：稳定且性能可预测，适合外部排序和链表排序
- 堆排序：最差情况性能稳定，适合实时系统
特殊数据分布场景
当数据具有特定特征时，非比较排序算法可能更优：
- 计数排序：数据范围有限且已知（如年龄、分数排序）
- 桶排序：数据均匀分布，适合外部排序
- 基数排序：固定位数的数字或字符串排序
内存敏感场景
在内存受限的环境中：
- 原地排序算法：优先选择空间复杂度 O(1) 的算法
- 堆排序：虽然不如快速排序快，但空间效率极高
稳定性要求场景
需要保持相等元素相对顺序时：
- 归并排序：稳定的 O(n log n) 算法首选
- 插入排序：小规模稳定排序
- 冒泡排序：简单的稳定排序实现
实际选择建议
基于复杂度分析和实际性能测试，给出以下实用建议：
- 小数组（n < 10）：使用插入排序，简单且高效
- 中等数组（10 < n < 1000）：使用快速排序，综合性能最佳
- 大数组（n > 1000）：使用优化后的快速排序或归并排序
- 需要稳定性：选择归并排序或TimSort（Python、Java等语言的内置算法）
- 数据范围已知且有限：考虑计数排序或基数排序
- 内存极度受限：使用堆排序或选择排序
性能优化策略
在实际应用中，还可以采用混合策略来进一步提升性能：
- 内省排序（Introsort）：结合快速排序、堆排序和插入排序的优点
- Timsort：归并排序和插入排序的混合，适应现实世界的数据特征
- 并行排序：利用多核处理器进行并行化处理
理解每种排序算法的复杂度特征和适用场景，能够帮助开发者在面对具体问题时做出最合适的技术选择，从而编写出既高效又可靠的排序代码。
总结
排序算法是计算机科学中的基础且重要的主题，不同的算法各有其独特的优势和适用场景。基础排序算法如冒泡、选择、插入排序虽然时间复杂度较高，但易于理解和实现，适合小规模数据或教学用途。高效排序算法如快速排序和归并排序采用分治策略，在大规模数据下表现优异，其中快速排序综合性能最佳，而归并排序则具有稳定性优势。特殊场景排序算法如计数排序、基数排序和桶排序在特定条件下能够突破比较排序的时间复杂度限制，达到线性时间复杂度。在实际应用中，选择排序算法需要综合考虑数据规模、数据类型、分布特征、内存限制和稳定性要求等因素。通过理解各种算法的内在原理和性能特征，我们能够根据具体需求选择最合适的排序策略，编写出高效可靠的排序代码。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
