冒泡排序通过相邻元素交换将最大值逐步“浮”到末尾，每轮确定一个最大值位置，具有稳定性但时间复杂度为O(n²)，适合小数据量或教学演示；快速排序采用分治策略，选取基准值将数组划分为两部分并递归排序，平均时间复杂度O(n log n)，效率高但不稳定，广泛应用于实际场景；堆排序基于最大堆性质，每次取出堆顶最大元素并重建堆，时间复杂度O(n log n)，空间复杂度低但不稳定，适用于对内存敏感的场景。三种算法各有优劣，应根据数据规模和稳定性需求选择合适方法。
冒泡排序、快速排序和堆排序是常见的排序算法，各有特点。下面用 Python 实现这三种排序方法，并简要说明其原理和性能。
1. 冒泡排序（Bubble Sort）
冒泡排序通过重复遍历数组，比较相邻元素并交换位置，将最大值“浮”到末尾。每轮确定一个最大值的位置。
特点：稳定、时间复杂度 O(n²)，适合小数据量或教学演示。
实现代码：
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]
return arr
示例：
print(bubble_sort([64, 34, 25, 12, 22])) # 输出 [12, 22, 25, 34, 64]
2. 快速排序（Quick Sort）
快速排序采用分治策略：选一个基准值（pivot），将数组分为小于和大于基准的两部分，递归排序。
立即学习“Python免费学习笔记（深入）”；
特点：平均时间复杂度 O(n log n)，不稳定，实际应用中效率高。
实现代码：
def quick_sort(arr):
if len(arr)
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
示例：
print(quick_sort([64, 34, 25, 12, 22])) # 输出 [12, 22, 25, 34, 64]
3. 堆排序（Heap Sort）
堆排序利用最大堆（或最小堆）的性质，每次取出堆顶最大元素放到末尾，重建堆。
特点：时间复杂度 O(n log n)，不稳定，空间复杂度低。
实现代码：
def heapify(arr, n, i):
largest = i
l = 2 * i + 1
r = 2 * i + 2
if l arr[largest]:
largest = l
if r arr[largest]:
largest = r
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
def heap_sort(arr):
n = len(arr)
for i in range(n // 2 - 1, -1, -1):
heapify(arr, n, i)
for i in range(n - 1, 0, -1):
arr[0], arr[i] = arr[i], arr[0]
heapify(arr, i, 0)
return arr
示例：
print(heap_sort([64, 34, 25, 12, 22])) # 输出 [12, 22, 25, 34, 64]
基本上就这些。冒泡简单但慢，快排高效常用，堆排序稳定高效但不保序。根据场景选择合适算法即可。
