我不敢说讲得有多专业、多全面，但希望读完，你（还有未来的我）能对「RocksDB 大概是怎么转起来的」有一个清楚的整体印象。下面这些英文词我尽量保留原样（LSM-Tree、MemTable、SST、WAL、compaction……），因为面试和文档里大家就是这么说的，硬翻成中文反而别扭。

RocksDB 是什么

一句话：一个可嵌入的、持久化的键值（key-value）存储引擎。

• 可嵌入（embedded）：它不是一个像 MySQL 那样单独跑的服务器，而是一个库，直接编进你的程序里，省掉了进程间通信的开销。
• 持久化：数据落在磁盘上，崩了也不丢。
• 2012 年从 Google 的 LevelDB fork 出来，用 C++ 写的，专门为 SSD 和写多的场景做了优化。Meta、Microsoft、Netflix、Uber 都在用。
• 它不是分布式的——副本、分片这些得你自己在上层做。

它对外提供的操作很朴素：put(key, value) 写、get(key) 读、delete(key) 删、merge(key, value) 合并、还有 iterator.seek() 做范围扫描。

核心思想：LSM-Tree

RocksDB 的一切都建立在 LSM-Tree（Log-Structured Merge-Tree，日志结构合并树） 上。

它要解决的核心矛盾是：磁盘最怕随机写，最喜欢顺序写。LSM 树的思路就是——先把写攒在内存里排好序，再一次性顺序地刷到磁盘。换句话说，它把大量随机写「攒」成了顺序写，这就是它写得快的根本原因。

结构上，数据分成很多层：最上面一层在内存里，下面一层层在磁盘上，编号 L0、L1、L2……越往下的数据越老、容量越大（通常下一层是上一层的约 10 倍）。

内存   ┌──────────────────────────────┐
       │  MemTable（可写，内部有序）    │  ← 新数据先进这里
       └──────────────────────────────┘
- - - - - - - - - - - - - - - - - - - - - -  flush（刷盘）
磁盘   L0   [SST] [SST] [SST]      ← 最新；文件之间 key 范围可能重叠
       L1   [SST][SST][SST][SST]   ← 每层内部 key 不重叠，且更大
       L2   [SST][SST] ......      ← 越往下越老、越大（约 ×10）
       ...

这套结构 1996 年就提出来了，专门优化写密集的负载。除了 RocksDB，Bigtable、HBase、Cassandra、MongoDB 的 WiredTiger 引擎用的也都是 LSM 树。

写：数据是怎么进去的

一次写入，会同时落到两个地方：

put(key, value)
      │
      ├──► WAL    （顺序追加到磁盘，防崩溃）
      │
      └──► MemTable（在内存里排好序）
                  │  写满约 64MB
                  ▼
            转为只读，后台线程刷成一个 SST 文件 → 落到 L0

MemTable：内存里的写缓冲，所有增删改都先到这。它内部是按 key 排好序的（默认用跳表 skip list 实现），这样后面刷盘和范围查询才高效。一个细节：删除不是真的把数据抹掉，而是写一条墓碑（tombstone）记录，表示「这个 key 删了」——真正的清理留给后面的 compaction。

WAL（Write-Ahead Log，预写日志）：MemTable 在内存里，断电就没了。所以每次写也会顺序追加一条记录到磁盘上的 WAL 文件，里面有 key、value、操作类型和校验和（checksum）。崩溃重启后，靠重放 WAL 把 MemTable 恢复出来。注意 WAL 是按写入顺序追加的，不排序——它图的就是个快。

Flush（刷盘）：MemTable 写满后会变成只读，换一个新的继续接客；后台线程把这个只读的 MemTable 刷成一个 SST 文件，落在 L0。刷完，对应的 WAL 就可以丢了。因为 MemTable 本来就是有序的，这一刷就是一次顺序写——LSM 树的精髓就在这儿。

SST 文件长什么样

SST（Static Sorted Table，静态有序表） 是磁盘上真正存数据的文件，一旦写好就不再修改。它里面是一堆排好序的 key-value，并且为了查询方便做了精心的分块设计（block，默认 4KB，可以用 Snappy、LZ4、ZSTD 等压缩）。

一个 SST 大致分几部分：

• 数据块（data）：有序的 key-value。因为相邻 key 很像，可以只存差异（delta encoding）省空间。
• 索引（index）：记录每个数据块「最后一个 key → 在文件里的位置」，这样查的时候能二分直接定位到某个块，而不用扫整个文件。
• 布隆过滤器（Bloom filter，可选）：一个概率型结构，能极快地回答「这个 key 一定不在这个文件里」。它可能误报「在」，但绝不漏报「不在」——所以特别适合在读的时候先挡掉一大批根本不用查的文件。

读：数据是怎么找出来的

读一个 key，要从新到老一层层找，因为新写的值在上层、旧值在下层，第一个找到的就是最新的：

1. 先查正在写的 MemTable；
2. 再查还没刷完的只读 MemTable；
3. 再查 L0 的每个 SST 文件（L0 文件之间 key 范围会重叠，所以得挨个看，从新到旧）；
4. L1 及以下，每层内部 key 不重叠，所以每层只需定位并查一个文件。

而在单个 SST 文件里找，又是三步走：先用 Bloom filter 问一句「key 在不在」，不在就直接跳过这个文件；在的话，用 index 二分定位到对应的数据块；最后把那个块读出来，在块内找到 key。

所以读的代价，关键看要翻多少层、多少文件——这也引出了下一节要解决的问题。

Compaction：后台一直在「打扫」

前面说了，删除只是写墓碑、更新也只是写新值盖在旧值上面。时间一长，磁盘上就会堆满过期的旧版本和墓碑：既白占空间，又让读的时候要翻越更多文件。

Compaction（压缩合并） 就是后台干这个清理活的：把某一层的若干 SST 文件，和下一层有重叠的文件合在一起，丢掉那些被覆盖的旧值和被删的 key，再写成新的、干净的 SST 放到下一层。因为每个文件本来都有序，合并用的是多路归并（k-way merge），就是归并排序里「合并」那一步的放大版。整个过程在后台线程跑，不挡前台的读写。

RocksDB 默认用 leveled compaction（分层合并）：

• L0 比较特殊，文件之间 key 范围允许重叠（因为它们是 MemTable 直接刷下来的）；当 L0 文件数攒到阈值（默认 4 个）就触发合并。
• L1 及以下，每一层内部所有文件的 key 范围互不重叠、整体有序；当某层的总大小超过设定值，就把超出的部分往下一层合并，有时会一路连锁往下压好几层。

一切都是权衡：三种「放大」

理解 RocksDB（其实是所有 LSM 引擎）调优的关键，是三个放大（amplification）指标：

• 空间放大（space amplification）：实际占的磁盘空间 ÷ 数据本身的大小。旧版本和墓碑越多，空间放大越大。
• 读放大（read amplification）：读一条数据，底层实际要做几次 I/O。要翻的层和文件越多，读放大越大。
• 写放大（write amplification）：写一条数据，底层实际写了几次。同一条数据会在 compaction 里被反复重写到更下面的层，所以写放大会很大。

这三者按下葫芦浮起瓢：compaction 越勤，空间和读放大越小，但写放大越大；反之亦然。怎么平衡全看你的负载，参数极多且互相影响——连 RocksDB 官方都坦言很难讲清每个参数的确切效果，建议多做 benchmark，盯着这三个放大指标调。

顺带一提：merge 操作

除了 put 和 delete，RocksDB 还有个 merge。当你要对一个值做大量「增量更新」（比如不停往一个计数器或列表上追加）时，传统做法是 read-modify-write：读出来、改、再写回去，很费劲。merge 让你只写「增量」本身，把怎么合并交给一个你自定义的 merge 函数，到读取或 compaction 时再真正算出最终值。好处是省写放大、还线程安全；代价是读变贵了——没合并之前，每次读都得把这些增量重新算一遍。

记住这几点就够了

如果只留一张「脑图」，是这样的：

• RocksDB = 可嵌入的持久化 KV 存储，源自 LevelDB，核心是 LSM-Tree；
• 写：先进内存的 MemTable（有序）+ 顺序写 WAL（防崩溃）→ 攒满后刷成 SST 文件落到 L0 → 后台 compaction 慢慢往下整理；
• 读：从新到老一层层找，靠 Bloom filter + index 跳过和定位，少读冤枉文件；
• 本质：用「写放大」换「把随机写变成顺序写」的高吞吐——空间、读、写三种放大之间，永远是权衡，没有免费的午餐。

把这几句记住，RocksDB 的大框架就立起来了。更细的东西——skip list、delta encoding、各种 compaction 策略、参数到底怎么调——等真正用到的时候再往里钻也不迟。

这份笔记里不少理解，来自 Artem Krylysov 的 How RocksDB Works——原文讲得非常细致，想往深里走的话很推荐读一读。

于是干脆把这一遍复习写下来，一方面给后来准备面试的人当个 reference，另一方面也是给未来的自己留个存档：等下次再要面试，我可以回到这里，照着扫一遍，很快就知道「这个我还会、这个我忘了，重点看一下」。

这篇文章的用法很简单：

• 先看下面那张速查表，扫一眼就能自检哪些算法你已经忘了；
• 想细看哪个，用右侧的目录（TOC）直接跳过去；
• 每个算法都按同一个模板写：一句话思路 → Python 实现 → 复杂度 → 稳定性和是否原地 → 面试要点，方便对照。

代码全部用 Python 写，因为它最接近伪代码、最容易看清逻辑。

一页速查表

先把结论摆出来。下面这张表覆盖了本文的全部 11 种排序，面试里被问到复杂度、稳定性的时候，脑子里应该能立刻浮现出这张表。

几点说明，免得这张表骗到你：

• 希尔排序的复杂度取决于「增量序列」，最好情况随用的序列不同而变，所以这里的数字只是常见量级。
• 快排标的空间是平均情况下的递归栈深度 O(log n)，最坏会退化到 O(n)；它是原地分区，但递归本身要占栈。
• 桶排序的稳定性打了星号：桶内用稳定排序（比如插入排序）它才稳定。
• k 是数据的取值范围，d 是数字的位数——非比较排序的复杂度都和数据本身的特征绑在一起，这点后面会细说。

写在前面：几个绕不开的概念

在逐个看算法之前，有四个概念几乎每道排序面试题都会用到。把它们先讲清楚，后面就不用反复解释了。

比较排序 vs 非比较排序

比较排序只通过「两个元素谁大谁小」这一种操作来决定顺序——冒泡、插入、归并、快排、堆排都是。它们的共同点是：理论下界就是 O(n log n)，谁也快不过（原因见下面）。

非比较排序不靠比较，而是利用元素本身的值去「算」出它该放的位置——计数、基数、桶都是。正因为绕开了比较，它们能做到线性时间 O(n)，但代价是对数据有额外要求（比如必须是范围有限的整数）。

稳定性（stability）

如果两个元素的排序键相等，排完序后它们的相对先后顺序不变，这个排序就是稳定的。

举个具体例子。有一批订单，已经按下单时间排好了，现在要再按金额排序：

排序前（已按时间）： (100元, 9:00)  (50元, 9:01)  (100元, 9:02)
稳定排序后（按金额）：(50元, 9:01)  (100元, 9:00)  (100元, 9:02)   ← 两个 100 元仍保持时间先后
不稳定排序后：       (50元, 9:01)  (100元, 9:02)  (100元, 9:00)   ← 两个 100 元的顺序被打乱

为什么面试爱问？因为多关键字排序依赖它：先按次要键排，再用一个稳定排序按主要键排，次要键的顺序就被保留下来了。记住哪些稳定（冒泡、插入、归并、计数、基数、Timsort）、哪些不稳定（选择、希尔、快排、堆排）几乎是必考点。

原地排序（in-place）

只用 O(1) 或 O(log n) 的额外空间就能完成排序，叫原地。归并排序要额外开一个 O(n) 的数组，所以不是原地；快排、堆排只在原数组上倒腾，是原地的。当面试官追问「内存很紧张怎么办」，问的往往就是这个。

复杂度为什么分最好/平均/最坏

同一个算法，面对不同输入表现可能天差地别。最典型的是快排：输入随机时是 O(n log n)，但输入已经有序、又恰好每次都挑到最差的 pivot 时，会退化成 O(n²)。面试里报复杂度，最好顺带说清是哪种情况——这恰恰是体现你理解深度的地方。

为什么比较排序快不过 O(n log n)？ 任何比较排序都可以画成一棵「决策树」：每个内部节点是一次比较，每个叶子是一种可能的最终排列。n 个元素共有 n! 种排列，所以树至少要有 n! 个叶子。一棵高度为 h 的二叉树最多有 2ʰ 个叶子，于是 2ʰ ≥ n!，即 h ≥ log₂(n!)。由斯特林公式，log₂(n!) ≈ n log n。树的高度就是最坏情况下的比较次数，所以下界是 Ω(n log n)。这也解释了为什么想更快，就只能绕开「比较」这件事——也就是非比较排序。

好，概念铺垫完了，开始逐个看。

比较类排序

冒泡排序 Bubble Sort

一句话思路：相邻两个元素两两比较，逆序就交换，每一轮都把当前最大的「冒泡」到末尾。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        swapped = False
        # 每一轮把未排序区间里最大的元素冒泡到右端
        for j in range(n - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:          # 一整轮都没交换，说明已经有序，提前收工
            break
    return arr

• 复杂度：最坏、平均都是 O(n²)；加了 swapped 提前退出后，对已经有序的输入是 O(n)。空间 O(1)。
• 稳定性 / 原地：稳定（只在严格大于时才交换），原地。
• 面试要点：实战里基本不用，但它是「稳定 + 提前退出能到 O(n)」的经典例子。注意那个 swapped 优化，常被拿来考。
• LeetCode 例题：912. 排序数组 —— LeetCode 没有专门考冒泡的题，这道通用排序题可以拿来练手实现（纯 O(n²) 在大数据下会超时，仅作练习）。

选择排序 Selection Sort

一句话思路：每一轮从未排序区间里挑出最小的，放到已排序区间的末尾。

def selection_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        min_idx = i
        # 在未排序区间 [i+1, n) 里找最小值的下标
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

• 复杂度：无论输入长什么样都是 O(n²)——它不会因为数据有序而变快。空间 O(1)。
• 稳定性 / 原地：不稳定，原地。比如 [5a, 5b, 2]，第一轮把 2 和 5a 交换，两个 5 的相对顺序就反了。
• 面试要点：唯一的亮点是交换次数最少（最多 n−1 次），在「写操作很贵」的场景下有意义。另外它是「最好情况也救不回来」的反例，常和插入排序对比着考。
• LeetCode 例题：912. 排序数组 —— 同样用这道通用题练手实现，体会它「交换少、但比较一点不少」的特点。

插入排序 Insertion Sort

一句话思路：像理扑克牌——从左到右，把每张新牌插到左边已经排好的牌中正确的位置。

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        # 把比 key 大的元素整体右移一位，给 key 腾出位置
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

• 复杂度：最坏、平均 O(n²)；对几乎有序的输入接近 O(n)。空间 O(1)。
• 稳定性 / 原地：稳定（while 条件用 > 不是 >=），原地。
• 面试要点：别小看它。数据量小或几乎有序时，插入排序比快排还快，所以它正是 Timsort、Introsort 这些工业级排序在「小块」上回退使用的算法。基础三件套里，它是最有实用价值的一个。
• LeetCode 例题：147. 对链表进行插入排序 —— 专门为插入排序准备的题：在链表上原地插入。

希尔排序 Shell Sort

一句话思路：插入排序的升级版。先按一个较大的「间隔」分组做插入排序，再逐步缩小间隔，最后一轮间隔为 1（就是普通插入排序），但此时数组已经「大致有序」，所以很快。

def shell_sort(arr):
    n = len(arr)
    gap = n // 2
    while gap > 0:
        # 对每个间隔为 gap 的子序列做插入排序
        for i in range(gap, n):
            key = arr[i]
            j = i - gap
            while j >= 0 and arr[j] > key:
                arr[j + gap] = arr[j]
                j -= gap
            arr[j + gap] = key
        gap //= 2
    return arr

• 复杂度：取决于增量序列。上面这种 n//2 折半序列最坏是 O(n²)；换更好的序列（如 Knuth 的 3k+1、Sedgewick 序列）能到 O(n^1.5) 甚至更好。空间 O(1)。
• 稳定性 / 原地：不稳定（跨间隔交换会打乱相等元素的相对位置），原地。
• 面试要点：它是「为什么让数据先变得大致有序，能让插入排序提速」这个思想的代表。面试不常直接考，但作为承上启下的一环值得知道——它把简单的 O(n²) 排序往 O(n log n) 的方向推了一把。
• LeetCode 例题：912. 排序数组 —— 拿它练手实现希尔排序，可以试试不同增量序列对耗时的影响。

归并排序 Merge Sort

一句话思路：分治。把数组对半切到不能再切，再把两个已排序的小数组合并成一个大的有序数组。

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

• 复杂度：最好、平均、最坏全是 O(n log n)——非常稳定，不会因为输入退化。空间 O(n)（合并时要额外数组）。
• 稳定性 / 原地：稳定，不是原地。
• 面试要点：复杂度稳如磐石、天然稳定，是「需要稳定 + 最坏也要 O(n log n)」时的首选。
• LeetCode 例题：148. 排序链表 —— 排序链表的最优解就是归并；想练数组版可用 912. 排序数组。

下面是两个高频延伸：

概念补充：链表排序和外部排序

链表排序：归并排序对链表特别友好——合并链表只要改指针，不需要额外数组，能做到 O(1) 额外空间（不算递归栈）。这也是为什么「O(n log n) 排序一个链表」的标准答案是归并而不是快排。

外部排序（external sort）：当数据大到内存装不下（经典面试题：「1G 内存怎么排 10G 文件？」），答案就是外部归并排序——把大文件切成内存能装下的小块，逐块读进来排好序写回磁盘，再用「多路归并」把这些有序小文件合并成最终结果。归并的精髓「合并多个有序序列」在这里被用到了极致。

快速排序 Quick Sort

这是我自己复习时最该重点捡起来的一节，partition 的细节五年没碰就模糊了。慢慢来。

一句话思路：分治。选一个基准值（pivot），通过一次分区（partition）把数组拆成「比 pivot 小的」和「比 pivot 大的」两部分，pivot 归位后，再对两边递归。

1. Lomuto 分区（最好背的版本）

def quick_sort(arr, low=0, high=None):
    if high is None:
        high = len(arr) - 1
    if low < high:
        p = partition(arr, low, high)
        quick_sort(arr, low, p - 1)    # 递归左半
        quick_sort(arr, p + 1, high)   # 递归右半
    return arr


def partition(arr, low, high):
    pivot = arr[high]            # Lomuto：固定取最右元素作 pivot
    i = low - 1                  # i 是「小于 pivot 区」的右边界
    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]   # pivot 归位
    return i + 1

Lomuto 的好处是只用一个指针 i 推进，逻辑直观、最好记。面试里手写快排，默认写这个版本就行。

2. 为什么会退化，以及怎么救

固定取最右元素当 pivot 有个致命问题：输入已经有序（或逆序）时，每次分区都把数组切成 0 和 n−1 两块，递归深度变成 n，复杂度退化到 O(n²)，还可能爆栈。

救法是别让 pivot 的选择被输入「预测」——随机选一个，或者取「头、中、尾」三个数的中位数（median-of-three）：

import random

def partition(arr, low, high):
    rand = random.randint(low, high)
    arr[rand], arr[high] = arr[high], arr[rand]   # 随机选 pivot，再换到最右，复用上面的逻辑
    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

只加两行，就把「有序输入退化」这个最常见的坑堵上了。面试官追问「快排最坏情况怎么办」，这就是标准答案。

3. 三路快排：对付大量重复元素

如果数组里有大量重复值（比如全是 0 和 1），普通快排还是会做很多无谓的递归。三路快排（基于「荷兰国旗问题」）把数组分成 < pivot、== pivot、> pivot 三段，等于 pivot 的那一整段直接跳过：

def quick_sort_3way(arr, low=0, high=None):
    if high is None:
        high = len(arr) - 1
    if low >= high:
        return arr
    pivot = arr[low]
    lt, i, gt = low, low, high   # [low,lt)<pivot  [lt,i)==pivot  (gt,high]>pivot
    while i <= gt:
        if arr[i] < pivot:
            arr[lt], arr[i] = arr[i], arr[lt]
            lt += 1
            i += 1
        elif arr[i] > pivot:
            arr[gt], arr[i] = arr[i], arr[gt]
            gt -= 1               # 换过来的元素还没检查，i 不动
        else:
            i += 1
    quick_sort_3way(arr, low, lt - 1)
    quick_sort_3way(arr, gt + 1, high)
    return arr

• 复杂度：平均 O(n log n)，最坏 O(n²)（用随机 pivot 后几乎遇不到）。空间 O(log n)，是递归栈的开销。
• 稳定性 / 原地：不稳定（分区里的远距离交换会打乱相等元素），原地。
• 面试要点：手写默认 Lomuto；被追问最坏情况就讲随机/三数取中；被追问大量重复就讲三路快排。
• LeetCode 例题：912. 排序数组 —— 提交时记得用随机 pivot，否则遇到有序或大量重复的数据会超时、甚至递归栈溢出。

再加一个高频延伸——

概念补充：Quickselect（快速选择）

「求第 k 大/小的元素」是面试常客。如果只是要第 k 个，没必要全排序：用快排的 partition，每次分区后看 pivot 落在哪，只递归 k 所在的那一边。平均 O(n)，比先排序再取（O(n log n)）更快。

def quickselect(arr, k):
    """返回第 k 小的元素，k 从 1 开始计数"""
    low, high, target = 0, len(arr) - 1, k - 1
    while low <= high:
        p = partition(arr, low, high)
        if p == target:
            return arr[p]
        elif p < target:
            low = p + 1        # 目标在右边
        else:
            high = p - 1       # 目标在左边

练手：215. 数组中的第 K 个最大元素 —— 用快速选择平均 O(n) 解，正好和堆的解法对照。

堆排序 Heap Sort

一句话思路：先把数组建成一个最大堆（每个父节点都 ≥ 子节点），堆顶就是最大值；把堆顶换到末尾，堆缩小 1，再调整堆顶下沉，重复直到排完。

def heap_sort(arr):
    n = len(arr)
    # 1. 建堆：从最后一个非叶子节点开始，逐个向下调整
    for i in range(n // 2 - 1, -1, -1):
        sift_down(arr, i, n)
    # 2. 反复把堆顶（最大值）换到末尾，再修复剩下的堆
    for end in range(n - 1, 0, -1):
        arr[0], arr[end] = arr[end], arr[0]
        sift_down(arr, 0, end)
    return arr


def sift_down(arr, root, size):
    while True:
        largest = root
        left, right = 2 * root + 1, 2 * root + 2
        if left < size and arr[left] > arr[largest]:
            largest = left
        if right < size and arr[right] > arr[largest]:
            largest = right
        if largest == root:      # 父节点已经最大，下沉结束
            break
        arr[root], arr[largest] = arr[largest], arr[root]
        root = largest

• 复杂度：最好、平均、最坏全是 O(n log n)。建堆是 O(n)（不是 O(n log n)，这是个常考的反直觉点），之后 n 次下沉每次 O(log n)。空间 O(1)。
• 稳定性 / 原地：不稳定，原地。
• 面试要点：它是唯一既保证最坏 O(n log n)、又只用 O(1) 空间的排序——「内存极紧又不能退化」时选它。注意它和优先队列 / 堆（heap）是同一套机制：heapq、Top-K 问题、Dijkstra 里的堆，全是这个 sift_down 的变体。用最小堆维护一个大小为 k 的堆求 Top-K，是堆这块的连环考点。
• LeetCode 例题：215. 数组中的第 K 个最大元素 —— 堆的经典题（维护一个大小为 k 的最小堆）；它也能用快速选择解，正好对照两种思路。

非比较类排序

前面所有算法都靠「比较」，所以卡在 O(n log n) 这条线上。接下来三个绕开了比较，用元素的值本身当索引去定位，从而做到线性时间——代价是对数据有要求。这一块也是我复习时空白最大的地方，写得细一点。

计数排序 Counting Sort

一句话思路：统计每个值出现了几次，再用「前缀和」算出每个值在结果里该放的位置，直接放进去。适合取值范围 k 不大的整数。

def counting_sort(arr):
    if not arr:
        return arr
    lo, hi = min(arr), max(arr)
    k = hi - lo + 1
    count = [0] * k
    for x in arr:                # 1. 计数
        count[x - lo] += 1
    for i in range(1, k):        # 2. 前缀和：count[i] 变成「值 ≤ i 的元素个数」
        count[i] += count[i - 1]
    result = [0] * len(arr)
    for x in reversed(arr):      # 3. 从后往前填，保证稳定
        count[x - lo] -= 1
        result[count[x - lo]] = x
    return result

• 复杂度：O(n + k)，n 是元素个数，k 是取值范围。空间 O(n + k)。
• 稳定性 / 原地：稳定（关键就在第 3 步从后往前遍历），不是原地。
• 面试要点：当 k 远小于 n（比如给十万个 0–100 的分数排序）时，它吊打任何 O(n log n) 排序。但 k 一旦很大（比如要排任意 32 位整数），空间就爆了——这正是它的适用边界，也是基数排序要解决的问题。
• LeetCode 例题：75. 颜色分类 —— 只有 0、1、2 三种值，计数排序（或三路快排）一趟搞定。

基数排序 Radix Sort

一句话思路：按位排序。从最低位（个位）开始，对每一位用一次稳定的计数排序，一直排到最高位。因为每一轮都稳定，排完最高位时整体就有序了。

def radix_sort(arr):
    if not arr:
        return arr
    max_val = max(arr)
    exp = 1                           # 当前处理的位：1=个位, 10=十位, 100=百位…
    while max_val // exp > 0:
        arr = counting_sort_by_digit(arr, exp)
        exp *= 10
    return arr


def counting_sort_by_digit(arr, exp):
    count = [0] * 10                  # 十进制，每位只有 0–9
    for x in arr:
        count[(x // exp) % 10] += 1
    for i in range(1, 10):
        count[i] += count[i - 1]
    result = [0] * len(arr)
    for x in reversed(arr):           # 从后往前，保持这一位排序的稳定性（基数排序正确性的关键）
        digit = (x // exp) % 10
        count[digit] -= 1
        result[count[digit]] = x
    return result

• 复杂度：O(d·(n + k))，d 是最大数字的位数，k 是基数（这里十进制 k=10）。空间 O(n + k)。
• 稳定性 / 原地：稳定，不是原地。
• 面试要点：它解决了计数排序「取值范围一大空间就爆」的问题——把一个大整数拆成几位小数字来排。上面的版本只处理非负整数；要支持负数，可以先整体平移成非负，或对正负分别处理。面试常考的点：为什么必须从低位排到高位？为什么每一位的排序必须稳定？（因为高位排序时要靠稳定性保留低位已经排好的顺序。）
• LeetCode 例题：164. 最大间距 —— 要求线性时间和空间，标准解法正是基数排序或桶排序。

桶排序 Bucket Sort

一句话思路：把数据按值域均匀分到若干个「桶」里，每个桶内部各自排序，最后按桶的顺序拼起来。适合均匀分布的数据。

def bucket_sort(arr):
    if not arr:
        return arr
    n = len(arr)
    buckets = [[] for _ in range(n)]
    for x in arr:                     # 假设元素均匀分布在 [0, 1)
        buckets[int(n * x)].append(x)
    result = []
    for bucket in buckets:
        insertion_sort(bucket)        # 桶内用稳定排序，整体才稳定
        result.extend(bucket)
    return result

• 复杂度：数据均匀分布时平均 O(n + k)；最坏情况（所有元素挤进同一个桶）退化到 O(n²)。空间 O(n + k)。
• 稳定性 / 原地：取决于桶内排序——用插入排序就稳定；不是原地。
• 面试要点：它的性能完全押在「数据分布是否均匀」上，这是它和计数/基数最大的区别。计数和基数对数据形态不敏感，桶排序敏感。经典适用场景：把一批均匀分布在 [0, 1) 的浮点数排序。
• LeetCode 例题：347. 前 K 个高频元素 —— 按出现频次分桶，是这道题最漂亮的解法。

现实世界里用的是什么：Timsort

前面这些都是「教科书算法」。但你每天 sorted() 一下，Python 背后跑的其实是 Timsort——一个为真实世界数据精心调校过的混合算法。值得单独说，因为面试里能讲出这个，往往是加分项。

核心思想：真实数据很少是完全随机的，往往局部已经有序。Timsort 抓住这一点：

1. 先扫描数组，找出已经天然有序的连续片段，叫 run；
2. 太短的 run 用插入排序补齐到一个最小长度（minrun，通常 32–64）——前面说过，小数组上插入排序最快；
3. 再用归并排序的方式，按一套规则把这些 run 两两合并，合并时还有「galloping（飞奔）」模式来加速。

所以 Timsort = 归并排序的骨架 + 插入排序的小块优化 + 对已有序数据的特判。

• 复杂度：最坏 O(n log n)，但对几乎有序的数据能到 O(n)。空间 O(n)。
• 稳定性：稳定。这也是为什么 Python 的 sorted() 和 list.sort() 保证稳定。
• 冷知识：Java 给对象排序（Arrays.sort(Object[])）用的也是 Timsort 的变体；而 C++ 的 std::sort 用的是另一个混合算法 Introsort（快排打底，递归太深时切换堆排避免退化，小块用插入排序）。「快排 + 堆排 + 插入排序」三合一，思路和 Timsort 异曲同工：没有银弹，工业级排序都是混合的。
• LeetCode 例题：56. 合并区间 —— 先排序再扫描合并；在 Python 里那句 sorted() 跑的就是 Timsort，正好体会「真实数据局部有序」带来的加速。

面试里到底怎么选 / 怎么答

把上面的东西浓缩成一张「该用哪个」的决策清单：

• 没有特殊要求，就要快 → 快排（随机 pivot）。这是大多数场景的默认选择。
• 要稳定，且最坏也得 O(n log n) → 归并排序。
• 内存极紧（要 O(1) 空间）又不能退化 → 堆排序。
• 数据量很小（几十个）或几乎已经有序 → 插入排序。
• 排链表 → 归并排序。
• 整数且取值范围不大 → 计数排序。
• 整数但范围很大（如定长整数 / 字符串） → 基数排序。
• 数据均匀分布在一个区间 → 桶排序。
• 只要第 k 大 / 中位数，不用全排序 → Quickselect。
• 数据大到内存装不下 → 外部归并排序。

几个常见的连环追问，提前想好答案：

• 「哪些排序是稳定的？」 → 冒泡、插入、归并、计数、基数、桶（桶内稳定时）、Timsort。
• 「快排最坏情况和怎么避免？」 → 有序输入 + 坏 pivot 退化成 O(n²)；用随机 pivot 或三数取中。
• 「能不能比 O(n log n) 更快？」 → 比较排序不能（决策树下界）；但如果数据是范围有限的整数，可以用非比较排序到 O(n)。
• 「O(n log n) 又稳定又原地的排序存在吗？」 → 一般实现里不存在；归并稳定但不原地，堆排原地但不稳定，快排原地但不稳定。这是个很好的「理解权衡」的考点。

几个常见易错点

复习时我自己踩过或者差点踩的坑，列在这里：

• 选择排序对有序输入也不会变快——它没有「提前退出」，永远 O(n²)。别和冒泡/插入搞混。
• 建堆是 O(n) 不是 O(n log n)。直觉上是 n 个元素各 O(log n)，但仔细算（大部分节点离底很近）是 O(n)。这是个高频反直觉考点。
• 计数 / 基数排序「从后往前」填结果——这一步是稳定性的来源，反过来写就不稳定了，而基数排序一旦不稳定就直接错了。
• 快排的空间不是 O(1)——虽然原地分区，但递归栈平均 O(log n)、最坏 O(n)。
• 桶排序的最坏是 O(n²)——别只记平均 O(n)，分布不均时会退化。
• 稳定 ≠ 原地，这是两个独立的维度，面试里经常被一起问，别混为一谈。

小结

排序这块知识，框架其实很清楚：

• 比较排序卡在 O(n log n)，里面快排最快但会退化、归并稳定但费空间、堆排原地但不稳定——没有全能选手，全是权衡；
• 非比较排序靠数据特征换来线性时间，但对数据有要求；
• 工业级排序（Timsort、Introsort）都是混合的，把几种算法的长处缝在一起。

如果你和我一样是隔了几年重新捡起来，建议照着最上面那张速查表过一遍：能默写出实现、说清复杂度和稳定性的就跳过，卡壳的就回到对应章节细看。等下次再准备面试，回到这里再扫一遍就好。

祝面试顺利。