算法 on 方糖猫Blog

《图解算法》学习笔记：一把尺子、一张地图，和算法的直觉

Thu, 02 Oct 2025 14:20:00 +0800

《图解算法》学习笔记：一把尺子、一张地图，和算法的直觉

目标读者：会写代码但没系统学过算法、一碰到"该用什么数据结构/算法"就凭感觉的新手；也适合学过但忘光了、想快速重建地图的老手。
参考书籍：Aditya Bhargava《图解算法》（Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People）
阅读目标：不追求覆盖每个细节，只提炼全书的骨架——一把评估工具的尺子（大 O），一张"问题形状 → 工具"的地图。

0. 写在前面：一本刻意"不完整"的算法书

算法书的光谱上，两端各有一座大山：

一端是《算法导论》（CLRS）：全面、严谨、数学化，厚得能挡子弹，也厚得让大多数人停在第三章。
另一端是刷题网站：直接给你题目和答案，见效快，但题目之间的"地形"要自己去悟。

《图解算法》刻意站在这两端之外。作者 Bhargava 是工程师出身、靠画画解释概念出名（他维护过 illustrated 技术博客），这本书的每一个算法都先配一幅手绘风格的图，再配一段短代码。它覆盖的主题只有十来个，每个都只讲"够用"的深度。

这不是缺点，是设计。这本书的定位是第一张地图：让你在"问题"和"工具"之间先建立起粗糙但正确的连接，知道某个形状的问题该往哪个方向走。地图粗糙没关系，怕的是手里连地图都没有。

全书十一章，蒸馏到最后其实是两件事：

一把尺子：大 O 表示法，用来评估任何工具的性能。
一张地图：识别问题的形状，映射到对应的工具——二分查找、分治、散列表、图搜索、贪婪、动态规划。

下面按这条主线展开。

1. 大 O：全书通用的货币

书从二分查找讲起，但二分查找只是引子，真正的主角是大 O 表示法——后面每一章都在花这种"货币"。

二分查找本身：在有序数组里找元素，每次猜中间值，把搜索空间砍半。100 个元素最多 7 次猜中，40 亿个元素最多 32 次。前提只有一个：数据必须有序。

大 O 说的不是时间，是增长趋势。它回答的问题是：“输入规模翻倍，运行时间怎么变？“书里反复出现的五种：

大 O	名字	书里的例子
`O(log n)`	对数时间	二分查找
`O(n)`	线性时间	简单查找（逐个翻）
`O(n log n)`	—	快速排序（平均）
`O(n^2)`	—	选择排序
`O(n!)`	—	旅行商问题的暴力解

新手最容易误解的三点，书里都点了名：

大 O 是最坏情况。简单查找运气好时第一次就命中，但大 O 管的是"倒霉到底"的那个上界。
大 O 吃掉了常数，但常数有时很重要。快排的常数因子比归并排序小，所以两者同为 O(n log n)，实践中快排通常更快——这是第四章的一个伏笔。
两种算法的差距会随规模放大。O(log n) 对 O(n)，在小数据上无所谓，在 40 亿条数据上是 32 次对 40 亿次。评估算法时先问自己：我的数据会涨到多大？

这把尺子从此不离手：后面每拿出一个新工具，第一件事就是量一量它。

2. 数据结构的地基：数组与链表

第三章之前，书先补了一块地基：内存里的数据只有两种基本摆法。

flowchart LR
    A["需要随机访问<br/>按下标直接拿"] --> B["数组<br/>读取 O(1)<br/>插入删除 O(n)"]
    C["需要频繁插入删除<br/>顺序遍历为主"] --> D["链表<br/>读取 O(n)<br/>插入删除 O(1)"]

数组：元素在内存里连排，知道下标就能直接跳过去；但插入一个元素，后面所有人都得挪窝，而且数组满了还得整体搬家。
链表：每个元素存着下一个的地址，插入删除只要改指针；但想找第 5 个，只能从头数过去。

选择排序在这里出场，不是因为它重要，而是因为它是一个绝佳的"反面教具”：每轮扫一遍数组找最小值，n 个元素扫 n 轮，O(n^2)。它存在的意义是让你亲身体会"为什么 O(n^2) 不能接受”，给后面的快排当对照组。

这一章的真正收获是一个思维模式：先说操作模式，再选数据结构。读写各半？那就得接受折中（后面散列表给出答案）。

3. 递归与分治：把问题缩到基线

递归在书里被拆成一句话：每个递归函数都有两部分——

基线条件（base case）：什么时候不再调用自己；
递归条件（recursive case）：什么时候调用自己。

漏掉基线条件就是死循环。而理解递归的物理载体是调用栈：每次调用往栈上压一层，栈顶永远是当前正在执行的函数。栈好用，但深度失控会爆栈——这是递归的隐形成本。

递归的最大用处是支撑**分治（Divide and Conquer）**策略。书里给分治的解题套路是：

找出尽可能简单的基线条件；
不断把问题分解（缩小规模），直到触及基线条件。

书的例子很妙：把一块 1680×640 的地均匀分成方块、要求方块尽可能大——每次"切掉一块最大的正方形，对剩下的部分重复同样的操作"，最后收敛到欧几里得算法。分治不是算法，是想问题的姿势。

快速排序是分治的招牌应用：

基线条件：数组元素少于 2 个，不用排。
递归条件：选一个基准值（pivot），把数组分成"比它小"和"比它大"两堆，对两堆分别快排。

快排的复杂度很讲政治：平均 O(n log n)，最坏 O(n^2)——最坏情况出现在每次都选到极端 pivot（比如对已排序数组总选第一个元素）。所以 pivot 的选择就是性能的关键，随机选是最省事的保险。

记住那个伏笔：快排平均情况的常数比归并排序小，所以它是工程实践的默认选择。大 O 相同不代表一样快，常数在日复一日地收税。

4. 散列表：用函数换时间

如果说数组和链表是两种"认命"的摆法，散列表（hash table）就是那个"我全都要"的答案：平均情况下，查找、插入、删除全是 O(1)。

它的构造朴素得不像话：

flowchart LR
    A["键 key"] --> B["散列函数<br/>把任意输入映射成固定数字"]
    B --> C["数组下标"]
    C --> D["值 value"]

一个合格的散列函数要满足：同样的输入永远得到同样的输出；不同的输入尽量映射到不同位置。于是"查找"从"翻箱倒柜"变成了"算一下地址直接拿"。

书里的三个经典用法，值得刻进肌肉：

查找表：电话簿、商品价格、DNS 解析——dict/map 存在的意义。
去重：投票站查"这人投过票没有"，把逐个翻名单变成 O(1) 查询。
缓存：服务器把算过的结果按 URL 存起来，下次直接给——所有 Web 框架都在这么干。

但散列表不是免费的，书也讲了两条暗线：

冲突（collision）：两个键被映射到同一位置。标准解法是链表法——这个位置存一个链表，所有撞车的都挂上去。冲突多了，散列表就退化成了链表，性能从 O(1) 滑向 O(n)。
负载因子（load factor）= 元素数 / 位置数。负载因子超过约 0.7 就该扩容（换个更大的数组重新散列）。扩容昂贵，但摊销到每次操作上仍然便宜。

工程直觉：散列表的平均 O(1) 建立在"散列函数好 + 负载受控"两个前提上。前提塌了，最坏 O(n) 在等着你。

5. 图搜索（一）：广度优先，用队列换最短

第六章把场景从"数组里找东西"升级到"网络里找关系"：在你的朋友关系网里，谁认识芒果经销商？

图就是节点加边，是对"关系"的建模。广度优先搜索（BFS）回答两类问题：

从 A 到 B 有没有路？
从 A 到 B 的最短路径（经过的边最少）是哪条？

算法的核心道具是队列（FIFO）：

把起点的朋友全部入队；
每次从队首取一个人检查：是芒果经销商吗？不是就把他的朋友加到队尾；
队列为空还找不到，就是不存在。

为什么队列保证"最短"？因为你按距离分层推进：一度人脉全部查完，才轮到二度人脉。第一个被找到的目标，一定在最少边数的那条路上。换栈（LIFO）就变成深度优先，性质全变——道具即语义。

两个工程细节别漏：

必须记录"已检查"名单（正好用上一章的散列表），否则关系网里有环时会在原地打转。
检查名单还顺便去重：同一个人被多个人介绍，只查一次。

树是特殊的图（没有环、没有指回祖先的边），所以这一章的思维方式覆盖了文件系统、组织结构、依赖关系等大量日常问题。

6. 图搜索（二）：狄克斯特拉，带权重的最短

BFS 找的是"段数最少"，但现实里每段路的代价不同——换乘 2 次但花 2 小时，和直达但花 3 小时，选哪个？狄克斯特拉算法（Dijkstra）处理的就是带权图的最短路径。

它的循环只有四步：

flowchart LR
    A["找出当前开销最小<br/>且未处理的节点"] --> B["检查它的邻居<br/>经由它是否更便宜"]
    B --> C["更便宜就更新<br/>邻居的开销和父节点"]
    C --> D["标记该节点已处理"]
    D --> A

关键直觉是贪心的有序性：一个"当前最便宜"的节点一旦被处理，它的最终开销就锁定了——因为不存在更便宜的迂回路线能再改进它（这正是不能有负权边的原因）。

书明确划了两条边界，比算法本身还值钱：

负权边禁用狄克斯特拉，改用贝尔曼-福特算法（Bellman-Ford）。负权边意味着"绕路反而赚钱"，廉价节点处理完后仍可能被改进，四步循环的前提崩了。
BFS 是狄克斯特拉的特例：所有边权重相等时，“段数最少"就是"开销最小”。学算法时这种"一般与特例"的父子关系，比单独记两个算法省一半脑子。

7. 贪婪算法：局部最优的边界

有些问题不存在快速精确解，贪婪算法的哲学是退而求其次：每步都选当前看起来最好的，拼出一个"足够好"的解。

书里的两个对比案例是这个哲学的完整两面：

教室调度：要在一间教室排最多的课。策略是"每步选结束最早的课"——这里的贪婪恰好就是最优解。
背包问题：小偷往包里装最值钱的商品，按"单价最高"贪婪地装，装不满，也装不到总价值最大——这里的贪婪只能拿到近似解。

同一个策略，一个精确一个近似，差别在问题结构。所以书的真正教益是后半章：识别 NP 完全问题。

旅行商问题、集合覆盖问题这类难题，精确解的复杂度是 O(n!) 或 O(2^n)，规模稍大就算不动。书里给的判断流程非常工程：

元素少时算法很快，元素一多就爆炸？可疑。
“所有组合"的字眼出现在解法里？可疑。
要算所有子集/所有排列才能出答案？基本坐实。

一旦确认撞上 NP 完全问题，正确动作不是硬算，而是换目标：用贪婪算法拿近似解。集合覆盖问题里，“每步选覆盖最多未覆盖电台的台"这个贪婪策略，能以 O(n^2) 的代价拿到足够好的答案。

完美是优秀的敌人，在 NP 完全问题面前，这句话是数学事实而不是鸡汤。

8. 动态规划：把大问题拆成可缓存的小问题

第九章是全书的智力高峰。动态规划（Dynamic Programming）的场景是：问题可以拆成子问题，且子问题的最优解能拼出大问题的最优解——那就先解子问题、存起来、再组装。

书用背包问题把整套方法演了一遍：背包容量 4 磅，商品有吉他、音响、笔记本电脑，各有限重和价值，怎么装总价值最大？

答案是画一张网格：

行是商品（逐个加入考虑范围）；
列是背包容量（1 磅到 4 磅，每个容量是一个子问题）；
每个单元格填：“只考虑前 i 件商品、容量为 j 时，能装的最大价值”。

填第 i 行第 j 列时，只有两种选择取最大：不装第 i 件（抄上一行的值），或者装（这件的价值 + 剩余容量在上一行的最优值）。填到右下角，答案自然浮现。

flowchart TD
    A["大问题<br/>容量4 全部商品"] --> B["子问题网格<br/>每个单元格 = 部分商品 + 部分容量"]
    B --> C["按行填表<br/>每格取两种选择的最大值"]
    C --> D["右下角 = 原问题的最优解"]

网格法同样解了最长公共子串（比如拼写检查里 hunish 更像 hunch 还是 fish）和最长公共子序列（diff 工具、生物序列比对的雏形）。两者的网格公式不同，书特意对比：子串要求连续，只在左上角相邻格匹配时加一；子序列允许跳跃，不匹配时取左格和上格的较大者。

动态规划的使用前提，书里埋了两条硬规则：

每个子问题必须是离散的、不互相依赖的——背包里装两件商品的"组合优惠”（比如去巴黎的行程互相抢时间）会毁掉方法；
它优化的是某个约束下的某个指标，先想清楚约束是什么、指标是什么，再画网格。

新手对动态规划的恐惧，九成来自没见过"网格"这个脚手架。见过一次，DP 就从玄学变成了填表。

9. K 最近邻：从算法走向机器学习的一脚

第十章画风突变，讲起了K 最近邻（KNN）——它不是传统意义上的"精确算法”，而是通往机器学习的引桥。

套路分两步：

特征抽取：把对象变成一组可比较的数值。判断橙子还是柚子，可以抽"大小"和"颜色"两个特征；推荐电影，就把用户口味变成若干维评分。
找邻居算距离：新对象来了，找特征空间里最近的 K 个已知对象，分类就看邻居里哪类多，回归就取邻居的平均值。

书顺手点了两条暗线：特征选得好不好决定一切（推荐系统里"喜好"这种主观特征比"年龄"有用得多）；以及回归——不只分类，还能预测数值（比如预测明天面包销量）。第十章还拿 OCR 和垃圾邮件过滤、预测股市当例子，并诚实地泼冷水：股市这种受太多不可测因素影响的对象，KNN 也无能为力。

这一章不求深，它是在全书结尾处把一扇门推开一条缝：算法世界的下一层是统计学习，特征工程是那层世界的"数据结构"。

10. 最后一章的真正价值：一张进阶地图

第十一章标题是"接下来如何做"，看似附录，实则是这本书最像"地图"的一章——它把十个更大的主题各用一页纸点了名，告诉你每个是干什么的、什么时候会撞上：

二叉查找树：有序数据的插入查找都比排序数组灵活，是数据库索引的原型。
反向索引：搜索引擎的核心——给每个词建一张"出现在哪些网页"的表，正好是散列表思路的工业化。
傅里叶变换：把信号拆成频率成分，MP3 压缩、地震预测、音乐识别都靠它。
布隆过滤器与 HyperLogLog：海量数据下的概率型判断——“这个 URL 我爬过吗？“允许极小的误判率，换来指数级的空间节省。
SHA 与局部敏感哈希：前者做安全散列和密码存储，后者（如 Simhash）让"相似内容"散列到相近位置，是查重和推荐的底层件。
Diffie-Hellman 密钥交换：双方在不安全的信道上协商出共享密钥，现代加密的基石。
线性规划：在给定约束下最大化目标，图论问题是它的特例，运筹学的发动机。
MapReduce 与并行算法：数据大到单机装不下时，把计算分发到成百上千台机器；并行排序的最优复杂度也从 O(n log n) 变成约 O(n)。

这一章的正确读法不是"学会”，而是建立索引：以后在真实工作里撞见"爬虫去重"“密码存储"“海量计数"这些词，你能想起"好像有个专门的东西解决这个”，再回头深查。地图的价值不在精细，在覆盖。

11. 带走的清单

把全书压成一张工位清单：

评估任何工具时

先问数据规模会涨到多大——小数据上无所谓的差距，大数据上是生死线。
用大 O 说最坏情况，别用"运气好"的例子安慰自己。
大 O 相同时，记得问常数因子（快排 vs 归并）；常数在日复一日地收税。
空间和时间一样要算：递归的调用栈、散列表的扩容、DP 的网格都是空间账单。

看到问题时先认形状

数据有序、要查找？二分查找，O(log n)。
要"按 key 秒查 / 去重 / 缓存”？散列表，盯紧负载因子。
关系网里找"最少几步”？BFS + 队列 + 已检查名单。
带代价的图里找"最便宜"？狄克斯特拉，先确认没有负权边。
问题能拆成独立子问题且子问题可复用？画 DP 网格，先写清约束和优化指标。
解法里出现"所有组合/所有排列"？多半是 NP 完全，别硬算，贪婪近似走起。

卡住时

试试分治：基线条件是什么？能不能把规模砍掉一块再递归？
试试换数据结构：很多"算法难题"其实是"数据摆错了地方"。
识别"当前问题是不是某个经典问题的特例"——BFS 之于狄克斯特拉，图论之于线性规划，特例意味着现成解法。

继续学

把第十一章当索引：布隆过滤器、反向索引、傅里叶变换、MapReduce，撞见了再深挖。
想系统化：去啃《算法导论》对应章节，那时你有地图了，不会迷路。
想练手感：刷题，但每道题先归类"这是什么形状的问题"，再看答案。

这本书两百多页、图比字多，值回票价的理由只有一个：它把"算法"从一门课变成了一箱工具，并且教会你拿起任何一件工具之前，先看清手里问题的形状。

参考书籍：Aditya Bhargava《图解算法》（Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People, Manning, 2016；中译本由人民邮电出版社出版）。

《计算机程序设计艺术》笔记：Knuth 用半个世纪给算法写的一部《史记》

Fri, 08 Dec 2023 10:40:00 +0800

《计算机程序设计艺术》笔记：Knuth 用半个世纪给算法写的一部《史记》

目标读者：被"要不要读 TAOCP"这个问题折磨过的工程师；也想给正在啃这套书的人一张地图和一份劝退/劝进并存的导读。参考书籍：Donald E. Knuth《计算机程序设计艺术》（The Art of Computer Programming）：卷 1《基本算法》（1968）、卷 2《半数值算法》（1969）、卷 3《排序与查找》（1973）、卷 4A《组合算法（一）》（2011），以及陆续以分册（fascicle）形式发布的 4B、4C。阅读目标：不假装自己通读了这套书——说实话，没人通读过——而是把它读成一张"算法领域的地形图"：每卷解决什么问题、Knuth 的方法论是什么、哪些内容今天仍是工程师的硬通货、正确的打开姿势是什么。

一、定位：这不是教材，是算法学科的《史记》

先破一个流传最广的误读：TAOCP 不是"编程教程"，甚至不是"算法教材"。它是 Knuth 从 1962 年开始写的一部算法领域的编年史加分析法典——每一种重要算法都给出精确的描述、完整的正确性论证、严格的运行时间分析，以及详尽到令人发指的文献考证。Bill Gates 那句著名的话是对这套书最准确的注脚：

“如果你觉得自己是个足够优秀的程序员，就去读 Knuth 的《计算机程序设计艺术》……如果你能读完它，请一定把简历发给我。”

这句话的重点不在"读完"，在"读完的人值得收简历"——它说的是这套书的密度。Knuth 自己的写作史也配得上这份密度：1962 年动笔时他以为自己写的是一本"编译器构造"的书，越写发现底料越多，最终膨胀成七卷规划；卷 1 到卷 3 在 1968-1973 年间出齐，然后卷 4 一写就是近四十年，2011 年才出了 4A，至今仍在以分册形式连载。顺带一个工程师会心一笑的插曲：1977 年卷 2 出第二版时，出版商改用照相排版，Knuth 对数学公式的排版质量忍无可忍，于是自己花了近十年写了 TeX 排版系统——全世界数学论文的排版标准，是这套书的副产品。

flowchart TD
    TAOCP["TAOCP 七卷规划<br/>1962 年动笔"] --> V1["卷 1 基本算法 1968<br/>数学基础 + 数据结构"]
    TAOCP --> V2["卷 2 半数值算法 1969<br/>随机数 + 高精度算术"]
    TAOCP --> V3["卷 3 排序与查找 1973<br/>内排序 + 外排序 + 查找"]
    TAOCP --> V4["卷 4 组合算法<br/>4A 2011 已出<br/>4B/4C 分册连载中"]
    TAOCP --> V5["卷 5-7 规划中<br/>句法算法 / 语言理论等"]
    V1 -.->|"排版质量事故"| TEX["副产品: TeX<br/>全世界数学排版标准"]
    style TEX fill:#fff3cd

为什么用 MIX/MMIX 汇编，而不是高级语言

这是理解全书方法论的一把钥匙。书里所有算法都用一台假想计算机 MIX（后来升级为 64 位 RISC 风格的 MMIX）的机器语言写成。Knuth 给的理由，本质上是三条工程判断：

要算性能账，就得有一台确定的机器。算法分析的核心是精确计算执行次数和时间，而"这条语句花多少时间"在高级语言里是说不清的——编译器、运行时、指令集全在中间隔着。MIX 是一台指令集、时序完全定义好的机器，每条指令几个时钟周期白纸黑字，运行时间的分析因此可以精确到指令级。
机器语言不赶时髦。1960 年代的高级语言换得飞快（Algol、Fortran、PL/I……），用任何一种写书都会很快过时；而一台假想的、设计得足够经典的机器，五十年不过时。事实证明他赌对了。
逼你看清代价。用汇编写，每一次访存、每一次循环、每一条跳转都暴露在纸面上——Knuth 认为程序员必须知道自己写的每一行代码让机器做了什么，这是"程序设计艺术"里"艺术"二字的底线。

代价也是显然的：阅读门槛被这道汇编抬得很高。这也是为什么本文后面会专门谈"怎么读"——这套书的正确打开方式不是从第一页硬啃。

另一个体现 Knuth 写作态度的细节是勘误奖励：他给每个在书中首次发现错误的人签发一张"十六进制一美元"的支票（0x$1.00 = 2.56 美元）。钱少到可笑，但这张支票在技术圈是荣誉勋章——它宣示的是一种工程文化：错误不是羞耻，藏着掖着才是；每一版书都比上一版更接近正确。 半个世纪几十个印次，这套书可能是人类历史上被校对得最狠的技术著作。

还有一个容易忽略的风格特征：几乎每一节结尾都有 “History and bibliography”（历史与文献） 小节，把这个算法从最早的雏形到最新的改进逐年考证，作者、年份、原始论文一个不落。这让 TAOCP 同时是一部算法史的目录——想知道某个思想的最早出处，查这套书通常比查搜索引擎可靠。

二、卷 1《基本算法》：算法的定义与数据结构的奠基

算法是什么：五个特征与欧几里得算法

卷 1 开篇就干了件"法典"该干的事：给"算法"下定义。Knuth 用**算法 E（欧几里得求最大公约数）**做标本，提炼出算法的五个特征：

有穷性（Finiteness）：算法必须在有限步内终止。（Knuth 特别注明：只满足其余四条而不满足有穷性的，可以叫"计算方法"，比如某些永不终止但仍有用处的反应式过程。）
确切性（Definiteness）：每一步都必须精确定义、无歧义——自然语言描述做不到这一点，这是书里坚持用形式化记号的原因。
输入（Input）：有零个或多个输入。
输出（Output）：有一个或多个输出，且与输入有确定关系。
能行性（Effectiveness）：每一步都必须足够基本，原则上能用纸笔在有限时间内完成。

这个定义的价值在于它立刻产生了区分能力：菜谱通常不满足确切性（“适量盐”），死循环程序不满足有穷性，而"掷骰子决定下一步"不满足确切性——都不是算法。定义不是用来背的，是用来划界的。

数学基础与 O/Ω/Θ 的来历

卷 1 第一章的数学部分（归纳法、数、幂与对数、和与积、排列、斐波那契、生成函数）常被读者跳过，但里面埋着全书的方法论核心：渐近分析（asymptotic analysis）。几个史实值得澄清：

大 O 记号不是 Knuth 发明的——它来自数论学家 Bachmann（1894 年），经 Landau 推广；
Knuth 的贡献是把它引入算法分析，并在 1976 年专门写了一篇短文《Big Omicron and Big Omega and Big Theta》，推广了大 Ω（下界）和大 Θ（紧界）记号，结束了当时文献里"什么都叫 O"的混乱局面。

也就是说，今天我们写在面试白板上的 O(n log n) 这套语言，其语法规范是这套书（及配套论文）定下来的。Knuth 的态度始终如一：“大约 n 的平方量级"不是分析，“3n² + 5n - 7 次 MIX 指令执行"才是分析，O 记号是对前者的严格速写，不是含糊的挡箭牌。

数据结构：栈、队列、链表与树

卷 1 第二章是整部书对后世影响最深的部分之一——今天教科书里的数据结构章节目录，几乎就是这一章的子孙：

线性结构：栈、队列、双端队列，以及链表（含循环链表、双向链表）的完整代数化描述——插入、删除、遍历的每一步都用 MIX 实现并计算代价。
树与二叉树：形式化定义、三种遍历（先序/中序/后序）、线索二叉树（threaded tree）——利用空指针存放前驱后继信息，让遍历不再需要栈。这是一个漂亮的"空间复用"思想实验。
动态存储分配与垃圾回收：内存池的伙伴系统（buddy system）、首次适配/最佳适配策略、以及垃圾回收的标记思想——1968 年就成体系地写在书里，比多数编程语言拥有 GC 早了一代人。

感悟：读这一章最大的震撼是"年代错位感”——我们以为的"现代概念”（垃圾回收、智能指针的引用计数思想、内存分配策略的权衡），全部写在 1968 年的书里，连权衡的框架都没变过。所谓新技术，多数是老思想在新硬件上的重排。

三、卷 2《半数值算法》：随机数与"算得准"的艺术

卷 2 处理一个独特的中间地带：对象是数，但关心的是算法而非数值分析。两大主线是随机数和算术。

先解释一下这个奇怪的书名：“半数值”（seminumerical） 指的是这类算法介于"纯数值计算"（数值分析的地盘，关心连续数学与误差界）和"纯符号处理"（编译、树操作的地盘）之间——输入输出是数，但算法的骨架是离散的组合结构。随机数生成、进制转换、多精度算术都属于这一带。

随机数：不该用随机的方法生成

卷 2 第三章是全书被引用最多的章节之一，开篇那句名言每个工程师都该见过一次：

“Random numbers should not be generated by a method chosen at random."（随机数不该用一个随机选出来的方法生成。）

Knuth 用亲身经历佐证这句话：他年轻时曾设计过一个"超级随机"的生成器——程序里随机地跳转、随机地执行不同操作，自以为复杂到不可能有规律；实际一跑，序列几乎立刻陷入一个短循环或不动点。教训被写成定理级别的警告：复杂性不等于随机性，没有理论分析的"看起来乱"都是自欺欺人。

线性同余法（LCG）：x 的下一个值 = (a·x + c) mod m。全书用几十页分析三个参数怎么选——模数 m、乘数 a、增量 c 的选择决定了周期长度和统计质量，每一个坏选择的下场都有具体展示。
统计检验：卡方检验、Kolmogorov-Smirnov 检验、以及专门测高维均匀性的谱检验（spectral test）——一个 LCG 可以在一维上完美均匀，在二维平面上却排成几条明显的直线，谱检验就是抓这种"隐藏结构"的。
这一章的工程翻译到今天依然直接：不要用 rand() 做密码学，不要自己发明随机数生成器，用之前先查它的检验记录。

高精度算术与"算得准”

另一条主线是让计算机突破机器字长地算数：

多精度算术：加减乘的经典算法之外，重点是算法 D（多精度除法）——除法是四则运算里唯一需要"试商"的，Knuth 给出完整的规范化、试商、校正流程和正确性证明。今天所有大整数库的除法实现，祖师爷都是这一节。
进制转换：二进制、十进制之间的转换算法及其代价分析——这个在当年是日常刚需。
有理数与浮点运算：浮点数的表示、舍入误差分析——“浮点算术不是实数算术"这个每个工程师都会踩的坑，书里有完整的误差传播分析。
多项式算术与幂的快速计算：包括快速幂（平方-乘方法）的前身分析，以及乘法复杂度的下潜——Karatsuba 乘法这类"比课本算法快"的分治思路。更进一步是**加法链（addition chain）**问题：计算 x 的 n 次方最少需要几次乘法？“反复平方"并不总是最优，而求最优加法链本身至今没有完全解决——又一个"看似简单、实则研究级"的 50 分题栖息地。

感悟：卷 2 是四卷里"最数学"的一卷，但它的工程含义一点不虚：凡是钱、坐标、时间戳参与计算的地方，都在和"算得准"打交道。浮点误差、大数溢出、随机数质量——这三类生产事故的完整理论都在这一卷里，早该被列为后端工程师的体检项目。

四、卷 3《排序与查找》：工程师的硬通货

四卷里工程密度最高、最值得当工具书常备的一卷。Knuth 把排序和查找这两个"最古老的生产问题"做到了考古学级别的穷尽。

内排序：一个家族的谱系

flowchart TD
    S["内排序算法家族"] --> I["插入类<br/>直接插入 / Shell 排序"]
    S --> E["交换类<br/>冒泡 / 快速排序 Hoare 1962"]
    S --> SE["选择类<br/>直接选择 / 堆排序 Williams-Floyd"]
    S --> M["归并类<br/>二路归并 / 自然归并"]
    S --> D["分布类<br/>计数 / 基数排序"]
    E -.->|"平均最优<br/>原地性差"| NOTE["各有适用场景<br/>没有全能冠军"]
    M -.->|"稳定 + 可外排"| NOTE
    style NOTE fill:#e8f5e9

书里对每一类的处理都是"描述 + 实现 + 精确分析"三段式，几个今天仍在生产环境活跃的名字：

快速排序（Hoare，1962）：Knuth 给出了平均比较次数的完整推导，以及最坏 O(n²) 的触发条件——“已排序输入配最左基准元"这个教科书反面案例就出自这里的分析。
堆排序（Williams 提出堆，Floyd 改进）：最坏情况也是 O(n log n)，堆这个数据结构本身后来长成了优先级队列的标准实现。
归并排序：稳定、可预测，并且是通往外排序的桥。

读这一章时建议始终带着 Knuth 的三个评价维度去看每个算法：稳定性（相等元素的相对次序是否保持）、原地性（额外空间是常数还是随 n 增长）、适应性（输入已接近有序时能否变快）。三个维度没有全能冠军——快排快在常数、堆排赢在最坏情况、归并赢在稳定和可外排——选型就是在这张三维表里做取舍，这也是"没有银弹，只有权衡"在算法层的具体形态。

最优排序：n log n 下界的信息论论证

卷 3 最优雅的一段数学是基于比较的排序的下界证明，值得单独记：

flowchart LR
    A["n 个元素<br/>共有 n! 种可能排列"] --> B["比较排序 = 决策树<br/>每个内部节点是一次比较<br/>每片叶子对应一种排列"]
    B --> C["树至少有 n! 片叶子"]
    C --> D["高度至少为 log2(n!)"]
    D --> E["Stirling 公式<br/>log2(n!) 约等于<br/>n log2 n - 1.44n"]
    E --> F["结论:<br/>任何比较排序的最坏情况<br/>下界为 Ω(n log n)"]
    style F fill:#fff3cd

这个论证的力量在于它不针对任何具体算法——它限制的是"比较"这个信息获取方式本身：一次比较最多带来 1 比特信息，而区分 n! 种排列需要 log2(n!) 比特。要快过 n log n，唯一的出路是放弃纯比较——这正是基数排序、计数排序这些"分布类"算法存在的理由。这是我在全书中最喜欢的一段：用信息论给一类算法封顶，一句话堵死一个方向的无效努力。

外排序与查找

外排序：当数据放不进内存，瓶颈从比较次数变成读写趟数。多路归并、**置换选择（replacement selection）**生成初始归并段、多相归并——这一整套是磁带时代的遗产，但思想直接活在今天的 LSM-tree（LevelDB/RocksDB 的多路归并 compaction）里。
查找：顺序查找与二分查找（Knuth 照例指出：思路人人会，写对的没几个——边界条件的完整分析在书里；他还考据出二分查找的思路 1946 年就见诸文献，而第一个对所有输入规模都正确的完整算法直到 1962 年才发表，一个"显而易见"的算法花了十六年才写对）；哈希：拉链法、开放寻址、线性探测的平均探查次数分析——线性探测的完整数学分析正是 Knuth 本人在 1962 年做出的，他自称正是这个问题让他决定写这套书；平衡树：AVL 树的旋转与再平衡，多路查找树与 B 树——数据库索引的物理形态；数字查找树（trie）：按位/按字符逐级展开的查找结构。

五、卷 4A《组合算法》：生成一切的艺术

隔了 38 年，2011 年出的卷 4A 换了一个世界：从"算数"和"排序"进入组合对象——布尔函数、组合、排列、划分——的领域。这卷的气质和前三卷一脉相承：先把对象定义到无歧义，再讨论"如何系统性地、不重不漏地枚举出全部实例”。

布尔函数与按位运算（7.1 节）：真值表、按位技巧的宝库——掩码、并行按位计数（population count 的 sideways addition）、“x 与 x-1 的按位与可以抹掉最低位的 1"这类惯用法——这一节读起来像高级位操作黑魔法集，但每个技巧都有正确性论证。
生成所有组合对象（7.2.1 节）：全 n 元组与 Gray 码（相邻码字只差一位的编码，枚举时每次只翻转一位）、全排列、全组合、整数划分、集合划分、所有树——每类对象都给出"不重不漏、常数均摊时间"的生成算法。
回溯思想：组合生成的算法骨子里都是"受控的回溯”——按字典序推进、到头回退。系统化的回溯框架（Algorithm B）在卷 4B 的 7.2.2 节正式登场；顺带交代一句出版史：4A 出版后 Knuth 继续以分册形式推进，卷 4B 已于 2022 年正式成书，当年那个"卷 4 写了四十年"的段子至此翻篇了一半。

用一张图记住回溯的骨架——所有组合枚举问题都可以投影成同一棵树：

flowchart TD
    R["空解<br/>第 0 层"] --> A["第 1 位选 a"]
    R --> B["第 1 位选 b"]
    A --> A1["第 2 位选 a<br/>...继续深入"]
    A --> A2["第 2 位选 b"]
    A2 -->|"约束不满足<br/>剪枝回退"| X1["放弃整棵子树"]
    A1 --> A1L["到达叶子<br/>输出一个完整解"]
    B --> B1["...同样的展开"]
    X1 -.->|"回退到最近分叉<br/>试下一个分支"| A
    style X1 fill:#ffcccc
    style A1L fill:#e8f5e9

核心纪律只有两条：到底就输出，碰壁就回退，回退后试下一个未试过的分支——不重不漏靠的就是这条纪律，而不是事后去重。

感悟：卷 4A 对今天的工程师有一个直接映射：所有"遍历所有可能配置"的需求——测试用例生成、组合优化、穷举校验——都是组合生成问题，而"生成"远比"收集后再去重"高效。不重不漏四个字，说起来像小学要求，做起来是算法设计里最硬的纪律之一。

六、怎么读这套书：习题分级、费马大定理与路线图

习题分级体系：00 到 50 的登山标尺

TAOCP 的习题是半本书——Knuth 给每道题标了难度分，这套编号体系本身就是个值得单独记住的设计：

编号	含义	预期投入
00	看一眼就该会	几秒钟
10	简单	一分钟内
20	中等	一刻钟上下
30	较难	可能需要数小时
40	学期项目级	数周
50	研究级问题	出题时可能无人解决

编号前可加 M（数学向）或 HM（高等数学向）。最著名的梗是卷 1 里那道 [M50]：题目是"证明费马大定理”——Knuth 的意思是"这道题出题时没人会做”。1995 年 Wiles 真的证明了它之后，后续印次里这道题的处境变成了书迷间的段子。50 分题不是作业，是路标：它告诉你学科边界在哪里。

我的路线图建议

对全职工程师，“通读"是个伪目标，务实的姿势是：

卷 3 当工具书常备：排序和查找是唯一一卷会在日常代码评审、性能分析、系统设计面试中直接变现的。通读一遍，之后按需回查。
卷 1 读第二章：数据结构部分是"为什么链表这样设计、为什么 GC 这样工作"的第一性原理来源；第一章数学基础按需查，不必顺序啃。
卷 2 按需精读：写大数、随机、浮点相关代码之前，把对应章节当 pre-mortem 读一遍。
卷 4A 当兴趣读物：遇到组合枚举需求（生成测试组合、配置穷举）时按目录取用。
习题只做 20 分以下的：10-20 分题保证理解，30 分以上当文献指南——题目本身常附带一整段文献史，不打算做题也值得读题。
别按顺序读。Knuth 自己也没指望人顺序读：每节相对独立，前置依赖写在节首。把这套书当成"算法领域的百科全书"而不是"课程”，是心态上最重要的一步。

七、落到工程实践：这套书改变了什么

复杂度分析从"感觉"变成了"账"。 读过 Knuth 的分析后，再说"这个操作是 O(n)“会本能地问：常数是什么？最坏情况和平均情况分别是多少？输入分布假设是什么？这套书最宝贵的遗产不是任何单个算法，而是**“性能是可以、也必须被精确计算的"这个信念**——profile 之前的估算、capacity planning 里的量级推演，全是它的日常形态。
对"下界"的敬畏。 n log n 的信息论论证训练了一种思维方式：优化之前先问这个问题的理论下界在哪，离下界还有多远。很多"再优化一下"的努力，看一眼下界就知道是徒劳——知道哪里没有油水，和知道哪里有油水一样值钱。
随机与浮点有了红线意识。 “不自己造随机数生成器"“钱不用浮点表示"这类团队规约，以前是被当经验口诀背下来的；读完卷 2 它们变成了有证明的结论，执行的腰杆完全不一样。
读旧文献的胆子变大了。 Knuth 的行文示范了一件事：1960 年代的论文不是"过时的古董”，而是很多问题唯一的完整答案所在。排障和选型时敢往回翻原始论文，是这套书给的胆量。
对"正确性"的标准被永久抬高了。 书里每个算法都带正确性证明或严格论证，读多了会形成一种肌肉记忆：写完一段非平凡逻辑，先问"循环不变式是什么"“边界情况枚举全了吗”。二分查找十六年才写对的考据，是这条标准最好的反面教材。

本篇小结

TAOCP 是算法学科的编年史加分析法典：七卷规划，卷 1-3 出版于 1968-1973，卷 4A 迟至 2011，副产品是 TeX；Gates 那句"读完发简历"说的是它的密度。
MIX/MMIX 假想机不是老派怪癖，是方法论：要精确算性能账，就得有一台指令级确定的机器。
卷 1 立规矩：算法五特征（有穷、确切、输入、输出、能行），数据结构大全，O/Ω/Θ 的语法规范（O 来自 Bachmann，Ω/Θ 由 Knuth 推广）。
卷 2 管"算得准”：随机数不该用随机方法生成（LCG 参数分析、谱检验），多精度算术（算法 D），浮点误差。
卷 3 是工程师硬通货：排序家族全谱、n log n 下界的信息论论证（比较即信息获取）、外排序思想活在今天的 LSM-tree 里、哈希与 B 树。
卷 4A 进入组合世界：按位技巧、不重不漏地生成所有组合/排列/划分，回溯的思想雏形。
读法：卷 3 常备、卷 1 读数据结构、卷 2/4A 按需精读；习题分级 00-50，[M50] 的费马大定理题是学科边界的路标。

这套书我没读完，大概率也永远不会读完——但这不妨碍它一直在工作：它就立在手边，像一个不说话的考官，每次想偷懒说"差不多 n log n 吧"的时候，抬头就能看见。

参考资料

Donald E. Knuth, The Art of Computer Programming, Volume 1: Fundamental Algorithms (3rd ed., Addison-Wesley, 1997; 初版 1968).
Donald E. Knuth, The Art of Computer Programming, Volume 2: Seminumerical Algorithms (3rd ed., 1997; 初版 1969).
Donald E. Knuth, The Art of Computer Programming, Volume 3: Sorting and Searching (2nd ed., 1998; 初版 1973).
Donald E. Knuth, The Art of Computer Programming, Volume 4A: Combinatorial Algorithms, Part 1 (Addison-Wesley, 2011).
Donald E. Knuth, “Big Omicron and Big Omega and Big Theta”, ACM SIGACT News, 1976（O/Ω/Θ 记号规范化的原始短文）。

《编程珠玑》学习笔记：小书大道理，问题求解的完整闭环

Tue, 08 Aug 2023 10:40:00 +0800

《编程珠玑》学习笔记：小书大道理，问题求解的完整闭环

目标读者：会写代码、刷过一些算法题，但想知道"真实工程里高手是怎么想问题"的程序员。
参考书籍：Jon Bentley《编程珠玑》（Programming Pearls）
阅读目标：提炼全书的问题求解闭环，把几个经典案例变成自己的思维肌肉。

0. 写在前面：一本"中间点"的书

如果给程序员的案头书排一条光谱：

一端是吴军《数学之美》：讲的是大思想——数学模型如何降维打击真实世界的问题，视野宏大，但离每天的代码有点远。
另一端是波利亚《怎样解题》：讲的是纯方法论——“看清问题、拟定计划、执行、回顾”，放之四海皆准，但抽象到几乎不给具体例子。

《编程珠玑》正好卡在中间：用一个个小而真的问题，走完"定义 → 估算 → 设计 → 验证 → 调优"的完整闭环。

它的出身就很"工程"：1983 年起，Jon Bentley 在贝尔实验室工作期间，为《ACM 通讯》（Communications of the ACM）主持 “Programming Pearls” 专栏，每期挑一个看似不起眼的小问题，带着读者从头到尾把它想透、写对、调快。专栏后来结集成书（1986 年初版，2000 年第二版），薄薄两百多页，却影响了整整几代程序员。

这本书的"珠玑"（pearls）不是奇技淫巧，而是一种工作方式：

把问题定义清楚，用估算摸清规模，设计正确的算法，证明它是对的，最后再谈调优。顺序不能乱。

下面我按这条主线，把书里最值得带走的几个案例提炼出来。

1. 全书主线：问题求解的完整闭环

先看一张全景图。这本书十五个专栏（第二版按五部分组织），其实都在打磨同一个闭环：

flowchart LR
    A["1 定义问题<br/>真正的输入输出是什么"] --> B["2 估算规模<br/>信封背面算一算"]
    B --> C["3 设计算法<br/>数据结构 + 算法策略"]
    C --> D["4 程序验证<br/>断言、边界、测试"]
    D --> E["5 代码调优<br/>测量驱动的优化"]
    E -.->|"发现假设不对"| A
    C -.->|"规模估算变了"| B

几个要点：

闭环是环，不是直线。调优时发现瓶颈，可能要回到算法设计；设计时发现规模估计错了，要回到估算；甚至写着写着发现"问题本身定义错了"——回到起点。
每一步都有"便宜可占"。定义清楚了，问题可能消失（位图排序）；估算做对了，方案直接收敛；验证做扎实了，能躲过标准库级别的 bug。
大部分程序员只在"设计"一环花力气，这正是这本书要纠正的。

下面五个案例，分别对应闭环上的关键环节。

2. 定义问题 + 算法设计：开篇的旋转数组

2.1 问题

把一个有 n 个元素的数组向左循环移动 i 位。比如 n=8、i=3：

原数组：  [1, 2, 3, 4, 5, 6, 7, 8]
左移 3 位：[4, 5, 6, 7, 8, 1, 2, 3]

约束：尽量少的额外空间（最好 O(1)），时间也要快。

2.2 解法一：逐一移动（正确但慢）

最直觉的做法：把 x[0] 存到临时变量，整体左移一位，把临时变量放到末尾；重复 i 次。

移动 1 次：[2, 3, 4, 5, 6, 7, 8, 1]
移动 2 次：[3, 4, 5, 6, 7, 8, 1, 2]
移动 3 次：[4, 5, 6, 7, 8, 1, 2, 3]  ✓

代码好写、肯定对，但时间是 O(n·i)——n 和 i 都是百万级时就是万亿次操作，直接出局。它的价值是当"对照组"：先有一个肯定正确的慢版本，后面所有快版本都可以拿它对拍。

2.3 解法二：求逆三次（全书的第一个"啊哈"）

把数组看成两段：AB（A 是前 i 个元素，B 是剩下的）。我们要 BA。

看一个神奇的操作序列（X’ 表示把 X 反转）：

原数组：  AB
反转 A：  A'B
再反转 B：A'B'
整体反转：(A'B')' = BA  ✓

手摇上面的例子（i=3）：

[1, 2, 3 | 4, 5, 6, 7, 8]   反转前 3 个
[3, 2, 1 | 4, 5, 6, 7, 8]   反转后 5 个
[3, 2, 1 | 8, 7, 6, 5, 4]   整体反转
[4, 5, 6, 7, 8, 1, 2, 3]    ✓

代码只需一个 reverse 函数加三次调用，O(n) 时间、O(1) 空间，短到几乎不可能写错：

reverse(0, i-1);
reverse(i, n-1);
reverse(0, n-1);

优雅在哪？ 旋转是个"整体"操作，我们却一直想逐个元素去搬；而反转是数组上最廉价、最不容易出错的局部操作，三次廉价的局部操作拼出了整体效果。Bentley 借这个例子想说的是：换个视角看问题，难题会塌缩成 trivial 的三行代码。 Brian Kernighan 评价这类代码是"既正确又明显地正确"——这是软件里最高级的状态。

2.4 解法三：块交换 / 杂耍算法

还有第三条路：把数组按 gcd(n, i) 分成若干"循环链"，每条链上的元素像杂耍一样依次归位（juggling algorithm）；或者递归地做块交换。时间同样是 O(n)，移动次数比求逆法略少，但代码明显复杂、边界更容易错。

三种解法摆在一起，就是一堂微型的方法论课：

解法	时间	额外空间	写对的难度	角色
逐一移动	O(n·i)	O(1)	极低	对照组 / 对拍基准
求逆三次	O(n)	O(1)	低	生产代码首选
块交换/杂耍	O(n)	O(1)	高	炫技 / 面试加分

一句话理解：先写"蠢但对"的版本建立信心，再找"巧且短"的版本上线，复杂版本只用于学习。

3. 重新定义问题：位图排序（1MB 排 900 万个电话号码）

这是全书第一章 “Cracking the Oyster”（撬开牡蛎）的核心案例，也是"定义问题"环节最漂亮的一次示范。

3.1 问题（来自真实场景）

一个文件里有至多 900 万个整数，每个都是 7 位数（即 0 ~ 9,999,999），没有重复。要把它们排序输出。可用内存大约 1 兆字节，磁盘空间充足。

3.2 第一反应：归并排序

标准答案是多路归并：内存里一次读一批，排序后写回磁盘，再多趟归并。正确、通用，但要好几趟磁盘读写，代码也不少。

在动手之前，Bentley 追问了一句：这个问题里有哪些信息被我忽略了？

每个数恰好出现一次（无重复）；
数值范围是已知的、有限的（10^7 种可能）；
除了排序之外没有其他操作；
没有关联数据（不像学生记录要跟着学号走）。

3.3 关键洞察：用"位"表示"存在"

如果把这些约束用足，答案呼之欲出：不存数字本身，只存"这个数出现过没有"。

用一个 10^7 位的位图（bitmap），第 j 位为 1 表示整数 j 在输入里。10^7 位 = 1,250,000 字节 ≈ 1.19 MB，刚好塞进那点可怜的内存。整个排序变成三趟：

把所有位置 0；
读入每个整数 i，把第 i 位置 1；
从头到尾扫一遍位图，把为 1 的位依次输出——天然有序。

flowchart TD
    A["输入文件<br/>至多 900 万个 7 位整数<br/>无重复"] --> B["阶段一<br/>10^7 位的位图全部置 0"]
    B --> C["阶段二<br/>每读到一个整数 i<br/>把第 i 位置 1"]
    C --> D["阶段三<br/>从 0 到 10^7-1 扫描位图<br/>位为 1 就输出下标"]
    D --> E["输出文件<br/>已排序"]

没有比较、没有交换、没有归并——排序问题被转化成了表示问题。时间 O(n)，磁盘只顺序读写两遍，代码量远小于归并方案。

3.4 这个案例真正教的东西

问题的表象 ≠ 问题的本质。 嘴上说的是"排序"，实质是"有限集合的表示与枚举"。一旦换了表示法，排序"消失"了。
追问约束是最大的杠杆。 “无重复"和"范围有限"这两句话，价值千金。真实工作里，甲方给的条件往往比我们用上的多。
思想有长长的影子。 位图索引、Bloom Filter（布隆过滤器）、Redis 的 bitmap、Roaring Bitmap，都是"用位表示存在性"这条线上的后代。今天在海量数据去重、用户签到、UV 统计里天天在用。

一句话理解：当值域有限且无重复时，“存在性位图"可以把排序、去重、判重全部压成 O(n) 的位操作。

4. 算法设计：最大子数组和的复杂度演进

如果说位图排序展示的是"重新定义问题”，最大子数组展示的就是闭环里"设计"环节的完整教科书：同一个问题，四个算法，复杂度连降三级。

4.1 问题

输入一个有 n 个数的数组（有正有负），找出连续子数组中和最大的那个，返回这个最大和。

小例子：[-2, 11, -4, 13, -5, -2]，答案是 20（子数组 [11, -4, 13]）。

这个问题不是编造的智力题。它源自布朗大学 Ulf Grenander 做模式识别时遇到的二维问题：在数字图像里找"最像某个模式"的子区域。二维版本太贵，他先把它化简到一维——化简本身就是设计的一部分。

4.2 四个版本的演进

版本一：O(n³) 暴力。 枚举所有起点 i 和终点 j，对每对 (i, j) 把中间的数加起来。n=1000 时约 10^9 次加法，已经没法用了。

版本二：O(n²)。 注意到 sum(i..j+1) = sum(i..j) + x[j+1]——内层循环不用从头加，带着上一次的累加和走就行。一次"重用已有计算”，干掉一个数量级。

版本三：O(n log n) 分治。 把数组从中点劈开。最大子数组只有三种可能：全在左半、全在右半、跨过中点。前两种递归解决；跨中点的答案 = 从中点向左扫描的最大后缀和 + 向右扫描的最大前缀和，O(n) 内搞定。T(n) = 2T(n/2) + O(n)，总共 O(n log n)。

版本四：O(n) 扫描线。 从左到右扫一遍，维护"以当前元素结尾的最大子数组和"：

ending_here = max(x[i], ending_here + x[i])
so_far      = max(so_far, ending_here)

直觉：一个负数前缀对后面只有拖累。当累加和变成负数，果断扔掉，从下一个元素重新开始。手摇上面的例子：

i  x[i]  ending_here  so_far
0   -2       -2          0   (负数前缀，扔掉)
1   11       11         11
2   -4        7         11
3   13       20         20   ← 答案
4   -5       15         20
5   -2       13         20

这就是后来大名鼎鼎的 Kadane 算法。

flowchart LR
    subgraph 演进["同一个问题的四次设计"]
        V1["版本一 暴力枚举<br/>O(n³)"] -->|"重用累加和"| V2["版本二 前缀复用<br/>O(n²)"]
        V2 -->|"分而治之"| V3["版本三 分治<br/>O(n log n)"]
        V3 -->|"负数前缀果断丢弃"| V4["版本四 扫描线<br/>O(n)"]
    end
    V4 --> R["n=10^6 时<br/>从'算到宇宙热寂'<br/>到毫秒级"]

4.3 真实掌故：高手也不是一步到位的

Bentley 在书里交代了这段历史，非常值得记住：Grenander 把一维问题抛给卡内基梅隆的 Michael Shamos，Shamos 一夜之间设计出 O(n log n) 的分治算法——当时他们都觉得这大概就是极限了。后来在一次研讨会上，统计学家 Jay Kadane 听了一分钟，当场给出了 O(n) 算法。

这个故事的两层启示：

连 Shamos 这个级别的算法专家，第一反应也不是最优解。 算法设计是迭代的，不是顿悟的。
每降一个数量级，靠的都是一个新视角：重用计算、分治、负数前缀丢弃——而不是更卖力的实现。

工程连接：这个 O(n) 扫描思想今天活在很多地方——股票最大收益、信号处理里的峰值检测、乃至面试最高频题。而"版本二"的累加和技巧，就是前缀和数组，是区间查询类问题的通用武器。

5. 程序验证：二分查找，一个藏了九年的标准库 bug

闭环里最容易被跳过的一环是"验证"。Bentley 用二分查找给了所有自信的程序员一记耳光。

5.1 一个尴尬的事实

二分查找的思想小学生都懂：有序数组里每次砍一半。但 Bentley 在贝尔实验室和后来的课程里反复做过同一个实验：请专业程序员（给了充足时间、任意语言、可以用高级伪码）写出正确的二分查找，结果大约 90% 的人写错。

这不是个案。他在书里引用过一个考据：第一个二分查找的发表版本出现在 1946 年，而第一个对任意长度数组都正确的发表版本，要等到 1962 年。十六年里，所有人发表的版本都有 bug。

Knuth 在《计算机程序设计艺术》第三卷里说得更直白（大意）：二分查找的思想虽然简单，细节却可能棘手得出乎意料——很多好程序员都在这上面栽过跟头。

5.2 坑都藏在哪

错的从来不是"砍一半"这个思想，而是边界：

区间定义不清：while (low < high) 还是 low <= high？mid 算出来之后，新区间是 [low, mid-1] 还是 [low, mid]？两两组合里只有一种自洽。
差一位错误（off-by-one）：死循环在 n=2 的小数组上，或者漏查最后一个元素。
返回值的语义：没找到时返回 -1？还是返回插入位置？调用方怎么处理？

5.3 标准库级别的翻车：溢出 bug 藏了九年

2006 年，Google 首席 Java 架构师 Joshua Bloch 在官方博客发了一篇著名的文章《Extra, Extra — Read All About It: Nearly All Binary Searches and Mergesorts are Broken》，自曝家丑：

java.util.Arrays.binarySearch 里的这行代码——

int mid = (low + high) / 2;

是错的。 当 low 和 high 都很大时，low + high 会溢出成负数，mid 变成负值，抛 ArrayIndexOutOfBoundsException。更扎心的是：这段代码最初正是 Bloch 自己写的，在他的《Effective Java》里也作为范例出现过；同样的 bug 还潜伏在归并排序的实现里，而且在 JDK 里藏了大约九年才被发现——因为要让 low + high 溢出，数组得大到 10^9 量级，当年的机器根本装不下这么大的数组。

修复方式也很"珠玑"：

int mid = low + (high - low) / 2;        // 减法会溢出吗？low<=high 时不会
int mid = (low + high) >>> 1;            // 或者用无符号右移

5.4 验证环节的正确姿势

Bentley 的对策不是"更聪明"，而是更机械：

用循环不变式写程序：写二分查找前先写下"如果目标存在，它一定在 [low, high] 区间内"，每一轮循环保持这个断言为真，程序的正确性就跟着不变式走，而不是靠感觉。
断言（assert）进代码：把不变式直接写成断言，测试期全部打开。
小数据穷举对拍：n=0、1、2、3 的所有情况手算或穷举，目标值在开头、结尾、中间、不存在各试一遍。
拿慢版本对拍：用一个 O(n) 线性查找和二分查找在随机数据上跑几万次，结果必须一致——这就是 2.2 节"蠢但对"版本的真正用途。

一句话理解：简单算法 + 复杂边界 = 专业坟场。正确性不靠自信，靠不变式和机械验证。

6. 估算的艺术：信封背面的算术

闭环里的"估算"环节，Bentley 把它叫做 back-of-the-envelope calculation（信封背面估算）：在餐厅信封背面用粗略数字、心算，三分钟搞清楚问题的规模。它的目的不是精确，而是在投入大量工作之前，先确认方向是不是错的。

6.1 为什么要估算

回到位图排序的例子：那个"大约 1MB 内存"的约束，配合"至多 900 万个 7 位数"，先算一笔——

如果每个数存成 32 位整数：900 万 × 4 字节 = 36 MB，内存放不下，所以"全部读进内存排序"这条路当场枪毙；
而 10^7 位的位图 ≈ 1.19 MB，勉强塞得下，方案成立。

两笔心算，直接决定了整个方案的形态。这就是估算的价值：它花三分钟，替你省掉三天返工。

6.2 随身武器一：72 法则

钱以年利率 r% 复利增长，大约 72/r 年翻一番。年利率 6%，约 12 年翻倍；利率 12%，约 6 年翻倍。

这个法则对程序员的用处远超理财——凡是指数增长的东西都适用：

数据量每年涨 40%？72/40 ≈ 1.8 年翻一倍，三年后是现在的 5 倍多，现在的存储架构撑得住吗？
程序每慢 1 倍，意味着规模翻倍时要多等一倍时间——反过来，复杂度从 O(n²) 降到 O(n log n) 在 n 翻倍时省多少，心算就能估出来。

6.3 随身武器二：π 秒就是一个纳世纪

Bentley 在书里给了一个极好记的常数：π 秒 ≈ 一纳世纪（nanocentury，10^-9 个世纪 ≈ 3.155 秒）。

用法：程序每秒跑多少操作、跑一世纪要多久，换算成"纳世纪"立刻有直觉。比如一个操作 1 微秒，跑 10^9 次就是 1000 秒 ≈ 318 个纳世纪 ≈ 6 分钟——心里有没有数，决定你要不要现在就换算法。

再配几个该背下来的量级：

2^10 ≈ 10^3（千），2^20 ≈ 10^6（百万），2^30 ≈ 10^9（十亿）；
磁盘顺序读比随机读快几个数量级；内存比磁盘快约 10^5 倍；
一年约 π × 10^7 秒。

6.4 随身武器三：安全系数与双重估算

Bentley 建议的重要习惯：同一个问题用两种不同路径估算，结果应该对得上；对不上就查到哪里错了。

书里举过估算密西西比河日径流量的例子：一条路径从"流域面积 × 降雨"估，另一条从"河道宽度 × 深度 × 流速"估，两个粗算结果在同一个数量级上吻合，估算就可信。工程里的翻版：系统容量规划时，既从"日活 × 人均请求 × 峰值系数"往下算，也从"单机压测 QPS × 机器数"往上顶，两边对上才算完。

工程连接：今天这活叫 capacity planning，面试里叫 Fermi 问题（“北京有多少个加油站”）。内核没变：粗糙但快速的数字直觉，是工程师防止自己被宏大叙事欺骗的唯一武器。

7. 代码调优：闭环的最后一环，也是最危险的一环

7.1 先立规矩

Bentley 对调优的态度非常克制，三条规矩：

先正确，再调优。 调优引入的复杂度会制造 bug，而一个跑得快但算错的程序毫无价值。
先测量，再调优。 瓶颈几乎从不在你以为的地方。用 profiler 找到热点，只调那 5% 的代码。
算法层级收益 » 代码层级收益。 O(n²) 换 O(n log n) 可能快一千倍；循环展开通常只快百分之几十。调优是锦上添花，不是雪中送炭。

7.2 书里反复出现的几招

缓存（避免重复计算）。 如果同一个值被算了很多次，算一次存起来。最现代的版本就是 memoization 和各级缓存体系。书里有个经典场景：频繁计算 c[i][j] 这类昂贵表达式，而它在循环里其实不变——把循环不变式提到循环外，或者干脆预处理一张表。

哨兵（sentinel）。 顺序查找时，先把要查找的值放到数组末尾当"哨兵"，内层循环就可以省掉"是否越界"的判断，比较次数近似减半：

x[n] = t;                    /* 哨兵：保证一定能找到 */
for (i = 0; x[i] != t; i++)  /* 循环里只剩一个比较 */
    ;

查找命中与否分开处理。思想内核：用一次提前的准备，换掉循环里千万次的检查。 今天的 std::string 以 \0 结尾、链表的 dummy head 节点，都是哨兵思想的亲戚。

循环展开。 把循环体复制几份，减少循环控制开销。Bentley 同时警告：展开会让代码变长、指令缓存变挤，而且现代编译器自己会做。手写展开之前，先确认编译器没帮你做，并且 profiler 说这里值得。

测试重排。 一串 if-else 判断，把命中频率最高的条件放最前面。思想内核和哈夫曼编码一样：高频路径应该最短。

7.3 今天的读者要打个折扣

这本书写于编译器还笨、内存按 KB 算的年代。今天读调优章节要带两个过滤器：

编译器已经很强：很多手工强度削减、展开，-O2 会替你做，手写反而碍事；
瓶颈换了地方：当年的敌人是指令数，今天的敌人常常是缓存未命中和内存墙——Bentley 的"缓存重复计算"思想没过时，但主战场从 ALU 挪到了 cache line。

不变的元规则：测量驱动。 不调没测过的代码，不信没数字的优化。

8. 番外：Bentley 与 Knuth 的那次交锋

这是计算机科学史上很有名的一段公案，也值得单独记一笔。

1986 年，Bentley 在自己的专栏里请 Donald Knuth 展示他倡导的 literate programming（文学编程，用 WEB 系统把代码和文档织在一起）。Knuth 领的题目很朴素：读一个文本文件，统计并输出出现次数最多的 k 个单词及次数。

Knuth 交出了一篇十多页、结构精妙的 WEB 程序，专为这个问题设计了一个巧妙的数据结构（带计数的有序 trie）。Bentley 把它发了出来，同时请 Unix 之父之一的 Doug McIlroy 写书评。McIlroy 的评论比程序本身更出名——他指出 Knuth 程序的优雅毋庸置疑，但整个问题用 6 行 Unix shell 就能解决：

tr -cs A-Za-z '\n' | tr A-Z a-z | sort | uniq -c | sort -rn | sed ${1}q

而且这 6 行是每个工程师随手可写、可改、可组合的。

这场交锋没有输家，它留下的启示是双面的：

Knuth 展示了为一个值得的问题量身打造工具与文档能达到的深度；
McIlroy 展示了用已有简单工具组合，可能比重新发明深刻十倍的轮子更工程。

这正是《编程珠玑》整本书的张力所在：深度与简单，各自在什么场合赢。 Bentley 把两篇都发表出来，本身就是"珠玑"。

9. 带走的清单

把全书压成一张可以贴在工位上的清单：

想问题时

先把问题用一句话写清楚：输入、输出、约束。约束里往往藏着解法（位图排序）。
信封背面先算规模：数据多大、时间预算多少、哪些方案当场出局（36MB vs 1.19MB）。
问一句"这个问题有没有更简单的等价形式"——旋转数组的三次求逆就是这么来的。

写代码时

先写"蠢但对"的版本，留作对照组，方便对拍。
每降一个数量级靠新视角，不靠更卖力：重用计算 → 分治 → 丢弃无用信息。
写二分查找这类"简单"算法时，先写循环不变式，再写代码；n=0、1、2 手动过一遍。
记住 (low + high) / 2 会溢出：用 low + (high - low) / 2。标准库都翻过车，你没有豁免权。

调优时

先 profile，只调热点；调优前后各测一次，没数字不算数。
优先换算法和数据结构，再考虑代码级技巧。
哨兵、缓存重复计算、循环不变式外提，这三招便宜又安全；循环展开先问编译器。

作为工程师

背上 72 法则和 “π 秒 = 纳世纪”，让指数增长在你心里有形状。
重要估算走两条独立路径，对上了才信。
读 Knuth vs McIlroy 之争：深刻的方案和简单的方案，各自配得上各自的问题。

这本书两百多页，值回票价的理由只有一个：它教的不是答案，而是从拿到问题到交付代码之间，那段大多数人凭感觉乱走的路程，其实每一步都有章法。

参考书籍：Jon Bentley《编程珠玑》（Programming Pearls, 2nd Edition）；Joshua Bloch, “Extra, Extra — Read All About It: Nearly All Binary Searches and Mergesorts are Broken”, Google Research Blog, 2006。

《算法与数据结构》教材学习笔记：一张地图看懂全书，附避坑技巧与典型题

Sat, 12 Nov 2022 10:30:00 +0800

《算法与数据结构》教材学习笔记

目标读者：正在学（或补）大学《算法与数据结构》这门课的新人。阅读目标：看完能对全书有一个整体地图；知道每种结构"什么时候用、怎么实现、容易踩什么坑"；能用简单代码解决典型问题。代码说明：实现采用 Python（简洁易懂、贴近伪代码），但思路与语言无关。

0. 开篇：这门课到底在讲什么

《算法与数据结构》整本书其实只回答一个问题：如何把"数据"组织起来，让"操作"更快。

教材里的任何一章，都可以拆成三句话：

逻辑结构：数据之间的关系（线性、树形、图状、集合）。
存储结构：这些关系在内存里怎么放（顺序存储 / 链式存储 / 散列存储）。
运算（算法）：在这种组织方式上怎么做增删改查，效率如何。

flowchart TD
    A[现实世界的问题] --> B[抽象出逻辑结构]
    B --> C{选存储结构}
    C --> C1[顺序存储<br/>连续内存, 随机访问快]
    C --> C2[链式存储<br/>指针串联, 增删快]
    C --> C3[散列存储<br/>哈希函数, 查找接近O1]
    C --> D[设计运算/算法]
    D --> E[用复杂度评估好坏]
    E --> F[得到可执行的程序]

新人最容易犯的错误，是上来就背代码。正确顺序是：先想清楚逻辑关系 → 再选存储方式 → 最后才是写算法。

评判算法好坏的尺子只有两个：

时间复杂度：操作次数随输入规模 n 增长的趋势（O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ)）。
空间复杂度：额外占用了多少内存。

避坑 #0：复杂度看的是"趋势"不是"精确次数"。O(2n+100) 就是 O(n)，常数和低阶项全部扔掉。

1. 全书知识地图

flowchart LR
    subgraph 基础["数据结构部分"]
        L1[线性表<br/>顺序表/链表]
        L2[栈与队列<br/>受限线性表]
        L3[串与数组<br/>KMP/特殊矩阵]
        L4[树<br/>二叉树/BST/赫夫曼/B树]
        L5[图<br/>遍历/最短路/生成树]
    end
    subgraph 算法["算法部分"]
        A1[查找<br/>顺序/二分/哈希]
        A2[排序<br/>插入/交换/选择/归并]
        A3[算法思想<br/>递归/分治/贪心/动态规划]
    end
    基础 --> 算法
    L1 --> L2 --> L3 --> L4 --> L5
    L4 --> A1
    L3 --> A2

学习主线一句话：线性表是地基，栈队列是线性表的特例，树和图是推广，查找和排序是应用，递归分治等思想贯穿始终。

2. 线性表：一切的起点

2.1 什么时候用哪种

	顺序表（Python 的 list）	链表
随机访问第 i 个	O(1)	O(n)
中间插入/删除	O(n)（要搬数据）	O(1)（找到位置后）
内存	连续，按需自动扩容	分散，逐个结点申请
典型场景	频繁按下标读、长度稳定	频繁增删、长度不确定

一句话场景判断：“读多写少用数组，增删多用链表”。（Python 的 list 是动态数组，自带扩容；教材里的链表则要自己定义结点类。）

2.2 单链表结构与操作图解

flowchart LR
    head[头指针] --> H((头结点))
    H --> A1[a₁] --> A2[a₂] --> A3[a₃] --> NULL[∅ None]

在结点 p 之后插入新结点 s，顺序不能反：

sequenceDiagram
    participant s as 新结点s
    participant p as 结点p
    participant n as p.next
    Note over s,n: 第一步: s.next = p.next (先接上后面)
    s->>n: s 指向 p 的后继
    Note over s,p: 第二步: p.next = s (再让 p 指向 s)
    p->>s: p 指向 s

避坑 #1：插入时如果先写 p.next = s，原来 p.next 指向的结点就丢了（断链）。永远先接后继，再改前驱。

2.3 简单实现：单链表反转

链表反转是理解指针（引用）操作的"Hello World"，也是面试必考：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverse_list(head: ListNode) -> ListNode:
    """原地反转单链表，返回新的头结点"""
    prev, cur = None, head
    while cur:
        nxt = cur.next   # 1. 先记住下一个，防止断链
        cur.next = prev  # 2. 掉头
        prev = cur       # 3. prev 前进
        cur = nxt        # 4. cur 前进
    return prev          # prev 停在原尾结点，即新头

避坑 #2：所有链表题，先建一个"虚拟头结点"（dummy node），可以让"删除头结点"和"删除中间结点"用同一套代码，不用特判，错误率直线下降。避坑 #3：引用操作完一定要检查边界：对 None 取 .next 会报 AttributeError，循环里每一步都问自己"这个引用可能是 None 吗"。

3. 栈与队列：加了规矩的线性表

flowchart LR
    subgraph 栈Stack["栈：后进先出 LIFO"]
        direction TB
        in1[入栈 push] --> top
        top[栈顶 top] --> out1[出栈 pop]
    end
    subgraph 队列Queue["队列：先进先出 FIFO"]
        direction LR
        rear[队尾 rear<br/>入队] --> q1[...] --> front[队首 front<br/>出队]
    end

3.1 场景速查

栈：括号匹配、表达式求值、函数调用栈、DFS、撤销（Undo）、浏览器后退。Python 里直接用 list，append() 入栈、pop() 出栈。
队列：BFS、消息队列、缓冲区、按层处理（如二叉树层序遍历）。Python 里用 collections.deque，append() 入队、popleft() 出队（不要用 list.pop(0)，那是 O(n)）。

判断口诀：“后进先出想栈，排队公平想队列”。

3.2 简单实现：括号匹配

def is_match(s: str) -> bool:
    """判断字符串中的 () [] {} 是否匹配"""
    pairs = {')': '(', ']': '[', '}': '{'}
    stack = []
    for c in s:
        if c in '([{':
            stack.append(c)          # 左括号入栈
        elif c in ')]}':
            if not stack:            # 坑：栈空还来右括号
                return False
            if stack.pop() != pairs[c]:
                return False
    return not stack                 # 坑：别忘了栈里可能剩左括号

避坑 #4：括号匹配的两个经典漏判——栈空时遇到右括号（如 ")("）和遍历完栈非空（如 "((("）。考试和面试最爱在这两个地方埋雷。避坑 #5：顺序队列用定长数组实现时会有"假溢出"（rear 到顶但前面有空位），解法是把数组首尾相接做成循环队列，用 (rear+1) % MAXSIZE == front 判满。（Python 的 deque 内部已处理好这个问题，但考试按教材的循环队列答。）

4. 串与 KMP：让字符串匹配不回退

朴素的字符串匹配：主串指针 i 每次失配都要回退，最坏 O(n·m)。

KMP 的核心思想一句话：失配时利用"已匹配部分的前后缀相同"信息，让主串指针 i 永不回退，只移动模式串指针 j，复杂度降到 O(n+m)。

flowchart TD
    A[i 指向主串, j 指向模式串] --> B{"s[i] == p[j] ?"}
    B -- 相等 --> C[i++, j++]
    B -- 不等且 j>0 --> D["j = next[j]<br/>(模式串自己回退, i 不动)"]
    B -- 不等且 j==0 --> E[i++]
    C --> F{j 到达模式串末尾?}
    D --> B
    E --> B
    F -- 是 --> G[匹配成功]
    F -- 否 --> B

避坑 #6：next 数组的定义是"模式串前 j 个字符中，最长的相等真前后缀长度"。很多人背了代码却没理解这句话，换道题就不会推。手工推 next 数组是教材必考题，务必练几次。

5. 树：最重要的非线性结构

5.1 二叉树长什么样

graph TD
    A((A 根)) --> B((B))
    A --> C((C))
    B --> D((D))
    B --> E((E))
    C --> F((F))

三种遍历对同一棵树的不同访问顺序：

遍历	顺序	上图结果	典型用途
前序	根→左→右	A B D E C F	复制树、表达式前缀形式
中序	左→根→右	D B E A F C	BST 中序 = 有序序列
后序	左→右→根	D E B F C A	释放树、计算目录大小

5.2 简单实现：递归遍历

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def preorder(root: TreeNode):
    """前序遍历；把三行的顺序换成 LVR / LRV 就是中序/后序"""
    if root is None:         # 递归出口
        return
    visit(root)              # V：访问根
    preorder(root.left)      # L：遍历左子树
    preorder(root.right)     # R：遍历右子树

避坑 #7：树的题 90% 能用递归解决，写递归时先写递归出口（root is None），再写"我对当前结点做什么、把什么交给子树"。想不清就画一棵三层的树手动模拟。另外注意 Python 默认递归深度约 1000，树很深时要改迭代写法或调 sys.setrecursionlimit。避坑 #8：**“二叉搜索树（BST）中序遍历结果是升序”**这条性质是大量题目的钥匙——验证 BST、找第 K 小、找两结点最近公共祖先都靠它。

5.3 教材里的三种重要树

赫夫曼树：带权路径长度最短的树，用于赫夫曼编码（压缩）。构造方法：每次取权值最小的两棵合并（Python 里用 heapq 实现非常顺手）。
二叉搜索树（BST）：左子树所有值 < 根 < 右子树所有值。查找/插入/删除平均 O(log n)，但退化成链表时最坏 O(n)。
平衡二叉树（AVL）与 B 树：为了解决 BST 退化问题。AVL 靠旋转保持左右子树高度差 ≤ 1；B 树一个结点存多个关键字，矮而胖，是数据库索引和文件系统的基石。

避坑 #9：BST 删除有两个孩子的结点时，标准做法是用中序直接前驱（左子树最大）或中序直接后继（右子树最小）顶替，再删除那个顶替者。直接删会把子树搞丢。

6. 图：关系最一般的结构

6.1 怎么存

邻接矩阵：g[i][j] 表示 i 到 j 是否有边。适合稠密图，查边 O(1)，空间 O(n²)。
邻接表：每个顶点挂一个邻居列表。适合稀疏图，空间 O(n+e)，默认首选。Python 里用 dict[int, list[int]] 即可。

6.2 两种遍历

flowchart LR
    subgraph DFS["DFS 深度优先"]
        d1[访问v] --> d2[选一个未访问邻居<br/>递归深入] --> d3[无路可走才回溯]
    end
    subgraph BFS["BFS 广度优先"]
        b1[v 入队] --> b2[出队并访问] --> b3[所有未访问邻居入队] --> b2
    end

from collections import deque

def dfs(g: dict, v, visited: set):
    """DFS：递归 + visited 集合防环"""
    visited.add(v)
    visit(v)
    for w in g[v]:
        if w not in visited:
            dfs(g, w, visited)

def bfs(g: dict, s):
    """BFS：队列 + visited 集合"""
    visited = {s}
    q = deque([s])
    while q:
        v = q.popleft()
        visit(v)
        for w in g[v]:
            if w not in visited:
                visited.add(w)   # 坑：入队时就标记，不是出队时
                q.append(w)

避坑 #10：图遍历必须配 visited，漏了它遇到环就死循环。而且要在入队时（不是出队时）标记 visited，否则同一结点会被多次入队。

6.3 图的经典应用速查

问题	算法	一句话说明
无权图最短路径	BFS	按层扩展，第一次到达即最短
带权（非负）最短路	Dijkstra	每次挑当前距离最小的点"定稿"
最小生成树	Prim / Kruskal	连通所有点的最小代价（布线、修路）
课程先修顺序	拓扑排序	反复找入度为 0 的点输出
关键路径	AOE 网	工程中最长路径决定工期

6.4 简单实现：Dijkstra 最短路径

思想一句话：每次从未定稿的点里挑距离最小的点"定稿"，再用它去松弛所有出边（好比涟漪一圈圈扩散，最近的点最先确定）。用最小堆（heapq）把"挑最小"从 O(n) 降到 O(log n)，总复杂度 O((n+e) log n)。

import heapq

def dijkstra(g: dict, s) -> dict:
    """g[u] = [(v, w), ...] 表示 u->v 有一条权值为 w 的边（要求 w >= 0）
    返回 s 到各点的最短距离，不可达的点不在结果中"""
    dist = {s: 0}
    pq = [(0, s)]                      # (当前距离, 顶点)，最小堆
    done = set()                       # 已"定稿"的点
    while pq:
        d, u = heapq.heappop(pq)       # 挑出距离最小的点
        if u in done:                  # 坑：堆里可能有同一点的过期记录
            continue
        done.add(u)                    # 定稿：d 就是 s 到 u 的最短距离
        for v, w in g.get(u, []):
            if v not in done and d + w < dist.get(v, float('inf')):
                dist[v] = d + w        # 松弛：找到更短的路
                heapq.heappush(pq, (dist[v], v))
    return dist

# 示例：g = {'A': [('B', 5), ('C', 2)], 'B': [('C', 1)], 'C': [('B', 3)]}
# dijkstra(g, 'A') -> {'A': 0, 'C': 2, 'B': 5}

要点解释：

松弛：如果"经过 u 再到 v"比已知的 v 距离更短，就更新 v 的距离——dist[v] = d + w 那一行。
懒惰删除：堆里的记录可能已被更新（过期），出堆时用 done 集合跳过，避免入堆记录删不掉的麻烦。
想要具体路径而不只是距离？再维护一个 prev[v] = u 前驱字典，最后从终点倒推即可。

避坑 #11：Dijkstra 不能处理负权边（“定稿"假设一旦成立就被负边打破），有负权要用 Bellman-Ford。这是考研和面试的经典判断题。避坑 #12：拓扑排序排不完（输出点数 < 总点数）说明图中有环，工程上意味着任务依赖出现了死锁。

7. 查找

7.1 三种基本查找

方法	前提	平均复杂度	场景
顺序查找	无	O(n)	数据少、无序
二分查找	有序 + 顺序存储	O(log n)	静态有序数据
散列（哈希）查找	建哈希表	接近 O(1)	海量数据快速查询

7.2 简单实现：二分查找（正确写法）

def binary_search(a: list, key) -> int:
    """在有序数组 a 中找 key，找到返回下标，否则返回 -1"""
    l, r = 0, len(a) - 1
    while l <= r:
        mid = l + (r - l) // 2   # 通用写法，见避坑 #13
        if a[mid] == key:
            return mid
        elif a[mid] < key:
            l = mid + 1
        else:
            r = mid - 1
    return -1

避坑 #13：Python 的整数不会溢出，但 C/Java 里 mid = (l + r) / 2 在 l、r 很大时会整数溢出；统一写成 l + (r - l) // 2 是跨语言都安全的好习惯。（Python 工程代码直接用标准库 bisect 模块，但手写二分是基本功。）避坑 #14：二分的边界要全程统一——while l <= r 配 l = mid + 1 / r = mid - 1（闭区间写法），不要中途混用左闭右开的条件，否则差一错误（off-by-one）必现。

7.3 哈希的冲突处理

哈希查找快的前提是处理好冲突（两个关键字映射到同一位置）：

flowchart TD
    K[关键字 key] --> H[哈希函数 h key]
    H --> C{位置被占?}
    C -- 否 --> S[直接存放/命中]
    C -- 是 --> M1[开放定址法<br/>向后探测空位]
    C -- 是 --> M2[链地址法<br/>同位置挂链表]

开放定址法：冲突了就顺延找下一个空位（教材重点，删除要设"墓碑"标记）。
链地址法：同位置元素串成链表（工程主流，Python 的 dict 和 Java 的 HashMap 都用类似思路）。

避坑 #15：哈希表的效率取决于装填因子 α = 元素数 / 表长。α 越大冲突越多。工程上 α 超过 0.7 左右就该扩容了。

8. 排序：教材的重头戏

8.1 分类地图

flowchart TD
    S[内部排序] --> I[插入类]
    S --> X[交换类]
    S --> C[选择类]
    S --> M[归并类]
    I --> I1[直接插入 O n²]
    I --> I2[希尔排序 O n^1.3]
    X --> X1[冒泡 O n²]
    X --> X2[快速排序 O n log n<br/>平均最快]
    C --> C1[简单选择 O n²]
    C --> C2[堆排序 O n log n]
    M --> M1[归并排序 O n log n<br/>稳定]

8.2 一张表记住所有考点

排序	平均	最坏	空间	稳定?	一句话记忆
直接插入	O(n²)	O(n²)	O(1)	✅	打扑克插牌
希尔	O(n^1.3)	O(n²)	O(1)	❌	分组插入
冒泡	O(n²)	O(n²)	O(1)	✅	相邻交换，轻的浮上去
快速	O(n log n)	O(n²)	O(log n)	❌	分治：选定枢轴分两边
简单选择	O(n²)	O(n²)	O(1)	❌	每轮挑最小的放前面
堆	O(n log n)	O(n log n)	O(1)	❌	用堆反复取最值
归并	O(n log n)	O(n log n)	O(n)	✅	先分后合，合并两个有序段

避坑 #16：“稳定"指相等元素的相对顺序排序后不变。常见坑：快排、堆排、简单选择、希尔都不稳定；插入、冒泡、归并稳定。需要稳定性时（比如先按成绩排再按学号排），选归并。（Python 内置的 sorted() 是 Timsort，稳定，工程直接用它。）避坑 #17：快速排序在输入已基本有序 + 选第一个元素做枢轴时退化成 O(n²)，实际工程中要随机选枢轴或三数取中。

8.3 简单实现：快速排序

def quick_sort(a: list, l: int, r: int):
    """快排：分治思想。partition 把枢轴放到最终位置，左边都比它小，右边都比它大"""
    if l >= r:
        return
    p = partition(a, l, r)
    quick_sort(a, l, p - 1)   # 递归左半
    quick_sort(a, p + 1, r)   # 递归右半

def partition(a: list, l: int, r: int) -> int:
    pivot = a[l]              # 选首元素做枢轴（教学版）
    while l < r:
        while l < r and a[r] >= pivot:
            r -= 1
        a[l] = a[r]           # 小的补到左边
        while l < r and a[l] <= pivot:
            l += 1
        a[r] = a[l]           # 大的补到右边
    a[l] = pivot              # 枢轴归位
    return l

9. 算法思想：递归、分治、贪心、动态规划

教材后半部分的灵魂。四者关系一句话：递归是手段，分治是"拆开再合并”，贪心是"每步选当前最好”，动态规划是"记住算过的子问题别重算"。

flowchart TD
    P[大问题] --> D{能否拆成<br/>同类子问题?}
    D -- 能, 子问题独立 --> DC[分治<br/>如归并排序/快排]
    D -- 能, 子问题重叠 --> DP[动态规划<br/>存表避免重算]
    P --> G{每步局部最优<br/>能推出全局最优?}
    G -- 能 --> GR[贪心<br/>如赫夫曼/Kruskal]
    G -- 不能 --> DP

9.1 简单实现：爬楼梯（DP 入门第一题）

def climb_stairs(n: int) -> int:
    """一次爬 1 或 2 级台阶，n 级有多少种爬法？"""
    if n <= 2:
        return n
    a, b = 1, 2               # dp[1]=1, dp[2]=2
    for _ in range(3, n + 1):
        a, b = b, a + b       # dp[i] = dp[i-1] + dp[i-2]
    return b

避坑 #18：写动态规划先别动手写代码，先用一句中文说清"dp[i] 表示什么"（状态定义），再写状态转移方程。这两步想清楚了，代码是机械翻译。直接上手写代码的，十有八九死在边界初始化上。（递归版 DP 记得加 @functools.lru_cache，否则指数级重复计算。）

10. 典型问题速查表

典型问题	所属章节	解题钥匙
单链表反转 / 找倒数第 K 个结点	线性表	三指针原地反转 / 快慢指针
括号匹配、表达式求值	栈	左括号入栈，右括号出栈比对
约瑟夫问题	线性表/队列	循环链表模拟，或队列反复出队入队
汉诺塔	递归	把 n-1 个盘移到辅助柱 → 移大盘 → 再移回
判断/还原二叉树	树	前序+中序可唯一确定一棵树
求树高、叶子数	树	递归：`1 + max(左高, 右高)`
赫夫曼编码	树	每次合并最小两个权值（`heapq`）
迷宫问题	栈/DFS	栈记录路径，走不通就回溯
无权最短路	图/BFS	BFS 按层扩展
课程表能否修完	图/拓扑	拓扑排序 + 判环
前 K 大元素	堆	维护大小为 K 的小顶堆（`heapq`）
合并 K 个有序数组	归并	两两归并或堆

11. 全书避坑清单（考前/面试前过一遍）

复杂度只看最高阶，扔掉常数。
链表插入：先接后继，再改前驱；万能技巧：虚拟头结点。
括号匹配：查"栈空遇右括号"和"遍历完栈非空"两种漏判。
循环队列判满：(rear+1) % MAX == front；队列出队用 deque.popleft()。
KMP 的 next 数组要会手工推。
树的递归：先写递归出口；注意 Python 递归深度限制。
记住：BST 中序遍历 = 升序。
图遍历必须 visited，BFS 在入队时标记。
Dijkstra 不支持负权边；拓扑排不完 = 有环。
二分：mid = l + (r - l) // 2，区间定义全程统一。
哈希关注装填因子；开放定址法删除要打标记不能真删空。
快排/堆排/简单选择/希尔不稳定；快排怕有序输入。
动态规划：先说清 dp[i] 的含义，再写转移方程，最后处理初始化。

12. 学习路线建议

flowchart LR
    W1[第1-2周<br/>复杂度+线性表] --> W2[第3-4周<br/>栈/队列/串]
    W2 --> W3[第5-6周<br/>树与二叉树]
    W3 --> W4[第7-8周<br/>图]
    W4 --> W5[第9-10周<br/>查找+排序综合]

三点经验之谈：

每个结构都亲手实现一遍。看懂和会写之间隔着一条鸿沟，哪怕写得慢，也要自己敲出链表、栈、二叉树遍历、快排这"四大件"。
画图比读代码快。指针题、树题、图题，先在纸上画出结构变化，再翻译成代码，出错率低一半。
题做不出来别死磕。20 分钟没思路就看解析，重点搞懂"人家为什么想到用这个结构"，第二天独立重写一遍。吃透一类题，胜过囫囵刷一百道。

结语

《算法与数据结构》这本书看起来章节多，其实主线非常清晰：数据怎么组织（结构）→ 操作怎么实现（算法）→ 效率怎么评估（复杂度）。把这三问套到每一章，全书就从"一堆要背的知识"变成"一张可以推理的地图"。

希望这份笔记能帮你把地图先装进脑子里，剩下的，就是动手写、动手画、动手刷。

《数据结构与算法》教材笔记（树篇）：从二叉查找树一路推导到 B+ 树，为什么数据库索引非它不可

Wed, 02 Nov 2022 09:30:00 +0800

《数据结构与算法》教材笔记（树篇）：从二叉查找树一路推导到 B+ 树，为什么数据库索引非它不可

目标读者：学过一遍数据结构、能写二叉树遍历，但被问到"B 树和红黑树有什么区别、为什么 MySQL 用 B+ 树"就说不囫囵的同学。姊妹篇：《算法与数据结构入门学习总结》是刷题向的——讲双指针、滑动窗口、DP 模板，目标是过 LeetCode。这篇是教材向的——讲每种结构"为什么被发明出来"，目标是看懂工程世界。两篇文章覆盖的内容几乎不重叠，建议先读哪篇都行。实战印证：《MySQL 实战指南》里讲的索引失效、覆盖索引，《MongoDB 从入门到精通》里讲的 WiredTiger B 树页、页分裂，底层原理都在这篇里。

0. 这篇只讲一件事：树是怎么一步步被逼成 B+ 树的

教材里的结构很多，数组、链表、栈、队列、哈希、图……但刷题篇已经覆盖了大部分，这篇把 70% 的篇幅压在一根主线上——树的进化链：

flowchart LR
    A["二叉查找树 BST<br/>有序 但会退化"] -->|"痛点: 退化成链表"| B["AVL 树<br/>严格平衡"]
    B -->|"痛点: 旋转太频繁<br/>写多读少顶不住"| C["红黑树<br/>近似平衡 工程妥协"]
    C -->|"痛点: 再高也是二叉<br/>树太高 磁盘 I/O 多"| D["2-3 树<br/>一个节点放多个 key"]
    D -->|"推广"| E["m 阶 B 树<br/>阶数对齐磁盘页"]
    E -->|"痛点: 内节点存数据<br/>范围扫描难"| F["B+ 树<br/>内节点纯索引<br/>叶节点链表"]
    style F fill:#ffd699

每一步都不是"更高级"，而是上一步在某个具体场景下撑不住了。记住这条链上的每个箭头，你就永远不会把 B 树讲成背定义。

另外教材里还有两个刷题篇没覆盖的点——哈希冲突的两种解法、图的最短路径与最小生成树——放在最后简单补全。

1. 二叉查找树：一切的开始，和它的死穴

二叉查找树（BST）的规则一句话：左子树所有值 < 根 < 右子树所有值。查找、插入、删除平均都是 O(log n)，看起来很美。

死穴：它不管自己的形状。 按 1, 2, 3, 4, 5, 6, 7 的顺序插入，你会得到：

flowchart TD
    A[1] --> B[2]
    B --> C[3]
    C --> D[4]
    D --> E[5]
    E --> F[6]
    F --> G[7]
    style A fill:#ffcccc

这棵树退化成了链表，查找变成 O(n)。而"按顺序插入"在真实世界里太常见了——自增 ID、时间戳，天然就是有序的。BST 的平均复杂度是拿"数据随机到达"换来的，工程上没人敢赌这个。

所以需要平衡：插入删除时主动调整形状，保证树高稳定在 log n。怎么调？教材给了两个答案，一个完美主义，一个实用主义。

2. AVL 树：完美主义的代价

AVL 的规则：任意节点的左右子树高度差不超过 1。这是最严格的平衡，树高被死死压在约 1.44 log n，查找最快。

代价是：每次插入删除破坏平衡时，要做旋转来修复。四种失衡形态：

flowchart TB
    subgraph LL["LL 型：左孩子的左子树插入"]
        direction LR
        L1["  30        右旋        20<br/>  /           →        /  \<br/>20                 10   30<br/>/<br/>10"]
    end
    subgraph RR["RR 型：右孩子的右子树插入"]
        direction LR
        R1["10          左旋          20<br/>  \\          →         /  \<br/>  20                 10   30<br/>    \\<br/>    30"]
    end
    subgraph LRRL["LR / RL 型：拐弯失衡 → 先转成 LL/RR 再转<br/>（两次旋转）"]
        LR1["先对子树反向旋转<br/>再对根旋转"]
    end

旋转本身不复杂，麻烦的是频率：插入最多旋 2 次就停，但删除可能要从底向上旋 O(log n) 次。读多写少的场景没问题，写多读少的场景（比如频繁更新的索引）旋转本身就吃掉了平衡带来的收益。

学习心得：我当年把四种旋转的图背得滚瓜烂熟，考试一过全忘了。后来发现根本不用背——LR 就是"先左旋成 LL，再右旋"，四种形态只是"一次还是两次、往哪边转"的组合。理解失衡的方向比记图重要。

3. 红黑树：工程妥协的胜利

红黑树放弃了"严格平衡"，换成一组染色规则：

每个节点非红即黑；
根和叶子（NIL）是黑；
红色节点的孩子必须是黑（不能有两个红挨着）;
任意节点到其所有后代叶子的路径上，黑节点数量相同（黑高一致）。

这四条合起来保证的不是"左右一样高"，而是一个更弱的结论：最长路径不超过最短路径的 2 倍。树高 ≈ 2 log n，比 AVL 略高，但换来的是插入删除平均只需 O(1) 次旋转。

flowchart TB
    subgraph AVL对比["AVL vs 红黑树"]
        direction LR
        V1["AVL<br/>高 1.44·log n<br/>查得快<br/>删最多旋 log n 次"]
        V2["红黑树<br/>高 2·log n<br/>查得稍慢<br/>旋 O(1) 次收工"]
    end
    V1 -.->|"读写均衡时<br/>工程选它"| V2
    style V2 fill:#e8f4e8

红黑树是工程世界的宠儿：Java 的 TreeMap、Linux 内核的 CFS 调度器、epoll 的就绪队列、C++ 的 std::map，全是它。面试被问"为什么用红黑树不用 AVL"，标准答案就是这一句：读多写少用 AVL（查得快），读写均衡用红黑树（调整便宜）。

踩坑故事 1：手撕红黑树是最不值的投入 面试准备期我花了一周想手写红黑树的删除——三种 Case、镜像三种、还有双重黑的修复，写完 200 行测试还是漏了一个分支。后来和做了十年基础设施的朋友聊，他说：“我工作里一次都没写过红黑树，但我每周都在做红黑树式的决策——在’严格’和’够用’之间选够用。“那一周的真正收获不是会写了，而是看懂了工程权衡的形状。

4. 2-3 树：B 树的真身，换个方向解决平衡

AVL 和红黑树都是"二叉 + 旋转修复”。2-3 树换了个思路：允许一个节点放多个 key，靠节点分裂来维持平衡。

规则：

节点分两种：2-节点（1 个 key，2 个孩子）、3-节点（2 个 key，3 个孩子）；
所有叶子在同一层（绝对平衡，比 AVL 还狠）；
插入永远发生在叶子：叶子满了（临时变成 3 个 key）就中间 key 向上分裂，父节点跟着调整，可能一路裂到根——树是这样"从下往上长"的。

一次分裂长这样：

flowchart TB
    subgraph BEFORE["插入 7，叶子已有 5 6，临时三 key 超载"]
        B1["      [9]<br/>  [5,6]  ← 插入7后变 [5,6,7]"]
    end
    subgraph AFTER["中间 key 6 上提，裂成两个节点"]
        A1["        [6,  9]<br/>   /     |      \\<br/> [5]   [7]   [...]"]
    end
    BEFORE --> AFTER

2-3 树的意义不在它自己（几乎没人直接用），而在于它证明了一件事：平衡不一定靠旋转，也可以靠"节点容量 + 向上分裂”。把这个思路的容量从 2 个 key 放大到几百个，就是 B 树。

顺带一提：红黑树其实就是 2-3 树的二叉表示——把 3-节点的两个 key 用一条红色边连起来，就是红黑树。理解了 2-3 树再回头看红黑树规则，“不能两个红挨着"就是"一个 3-节点最多两个 key”，瞬间全部通顺。这是教材推导最美的一段。

5. B 树：为磁盘而生的矮胖树

5.1 为什么二叉树到了磁盘上就不行了

到这里要引入这篇的真正主角：磁盘 I/O。内存里比较一次是纳秒级，磁盘读一次是毫秒级（机械盘）到几十微秒级（SSD），差着 4~6 个数量级。所以磁盘世界的复杂度单位不是"比较次数"，而是"读了几个磁盘页"。

一棵 100 万个 key 的平衡二叉树，高约 20 层——查一个 key 最坏要 20 次磁盘 I/O。这就是为什么二叉平衡树统治内存、却进不了磁盘。

B 树的解法简单粗暴：把每个节点做到一个磁盘页那么大（InnoDB 默认 16KB）。一页能放几百个 key，树高立刻塌下来：

flowchart TB
    subgraph BTREE["一棵 m 阶 B 树（每个节点 = 一个 16KB 磁盘页）"]
        ROOT["根页<br/>[k1 | k2 | ... | k400]<br/>1 次 I/O"]
        ROOT --> L2A["内页<br/>400 个 key<br/>1 次 I/O"]
        ROOT --> L2B["内页 ..."]
        ROOT --> L2C["内页 ..."]
        L2A --> L3["叶页层<br/>每页 400 条记录<br/>1 次 I/O"]
    end
    NOTE["100 万 key：树高 ≈ 2~3<br/>= 最多 3 次磁盘 I/O"]

算一笔账：每页 400 个 key，两层就是 400 × 400 = 16 万，三层就是 6400 万。1 亿条数据的索引，3 次 I/O 定位——这就是"千万级数据 B 树也就 4 层"（MongoDB 篇里的那句话）的出处。

5.2 m 阶 B 树的定义（五条，一条都不能少）

每个节点最多 m 个孩子（m 阶）；
非根节点至少有 ⌈m/2⌉ 个孩子（保证节点不会太空）；
有 k 个孩子的节点恰好有 k-1 个 key，key 排序，充当孩子之间的"路标"；
所有叶子在同一层；
根至少 2 个孩子（除非是叶子）。

插入和删除是 2-3 树逻辑的放大版：

flowchart LR
    subgraph 插入["插入：叶子满了就分裂"]
        I1["叶子 key 数 = m<br/>超载"] --> I2["中间 key 上提<br/>裂成两半<br/>各留 ⌈m/2⌉-1 个"]
        I2 --> I3["父节点也满？<br/>继续向上裂<br/>最坏裂到根 树高+1"]
    end
    subgraph 删除["删除：节点太空就借/并"]
        D1["key 数 < ⌈m/2⌉-1"] --> D2{"兄弟有富余？"}
        D2 -->|有| D3["向兄弟借一个<br/>（父key下来 兄弟key上去）"]
        D2 -->|没有| D4["和兄弟合并<br/>父key拉下来<br/>可能连锁合并"]
    end

B 树的树高增长只有一种方式：根节点分裂。 这保证了它永远不会退化——这是比 BST 强在根上的地方。

踩坑故事 2：自增主键 vs UUID，B 树结构的真实代价 早年在 MySQL 里给一张日志表用了 UUID 做主键，量小的时候没感觉，过了 5000 万行插入速度腰斩再腰斩。原因就在 B 树的插入路径：自增主键永远往最右的叶子追加，页满了裂一次，顺序 I/O；UUID 是随机落到任意叶子，每插一条都可能读一个冷页、裂一个热页，还伴随着页分裂后的空间碎片（页利用率掉到 60% 多）。换回自增 BIGINT 后写入吞吐翻了近 3 倍。这不是玄学，就是 B 树分裂频率的差。这也是为什么分布式 ID 方案（雪花 ID）都强调"趋势递增"——在讨好 B+ 树。

6. B+ 树：补上最后一刀，数据库的终点站

B 树已经很好了，B+ 树只改了两处，却是数据库索引的定论：

flowchart TB
    subgraph B树["B 树：key 和数据混在一起"]
        BR["内节点<br/>[key+data | key+data]"]
        BR --> BL1["叶节点<br/>key+data"]
        BR --> BL2["叶节点<br/>key+data"]
        BN1["一个 key 的数据<br/>可能在内节点<br/>范围查询要跨层<br/>中序遍历上蹿下跳"]
    end
    subgraph BPLUS树["B+ 树：内节点纯索引，数据全在叶子"]
        PR["内节点<br/>[key | key | key]<br/>只当路标 不放数据"]
        PR --> PL1["叶节点<br/>key+data"]
        PR --> PL2["叶节点<br/>key+data"]
        PR --> PL3["叶节点<br/>key+data"]
        PL1 -->|"双向链表"| PL2
        PL2 -->|"双向链表"| PL3
        PN1["范围查询：定位起点后<br/>顺着链表扫<br/>全是顺序 I/O"]
    end
    style BPLUS树 fill:#e8f4e8

两处改动，每一处都打在磁盘场景的七寸上：

改动一：内节点不存数据，只存 key。 同样 16KB 一页，存"key+数据指针"可能只能放 100 个，纯 key 能放 1000 个。阶数 ×10，树再矮一层。而且内节点少且热，整个上层索引经常能全塞进内存，真实查询只有最后一步读叶子才碰磁盘。

改动二：叶子之间串成双向链表。 WHERE age BETWEEN 20 AND 30、ORDER BY ... LIMIT 这类范围扫描，B 树要在层间来回跳（随机 I/O），B+ 树定位到起点后顺着链表扫，顺序 I/O。机械盘时代这是百倍差距，SSD 时代预读和缓存依然偏爱顺序访问。

再附赠两个由此推出的性质，都是 MySQL 篇里出现过的实战规则：

聚簇索引下，叶子就是数据行本身，所以按主键查 = 一次定位，而二级索引叶子存的是主键值，要回表再查一次——这就是"覆盖索引为什么快"；
B+ 树的有序性 + 左前缀路标结构，决定了 LIKE '%abc' 没法走索引（开头通配，路标失效），LIKE 'abc%' 可以——MySQL 篇那句"会全表扫描"的底层解释就在这。

一句话记住 B 树 vs B+ 树：B 树是"查到什么都是赚"（内节点也可能命中数据），B+ 树是"每次都老实走到叶子，但换来更矮的树和丝滑的范围扫描"。数据库查询里范围扫描是家常便饭，所以 B+ 树赢了。

7. 顺手补两个教材盲点

7.1 哈希冲突：链地址 vs 开放寻址

刷题篇讲过哈希表"用空间换时间"，教材会多问一步：两个 key 撞进同一个桶怎么办？

flowchart LR
    subgraph 链地址["链地址法（Java HashMap）"]
        A1["桶 0 → k1 → k2 → k3<br/>（Java 8 后链表超 8 个转红黑树）"]
    end
    subgraph 开放寻址["开放寻址法（Redis dict 扩容期 / Python dict）"]
        B1["桶被占？<br/>按探查序列找下一个空位<br/>线性 +1 / 二次 +i² / 双重哈希"]
    end

取舍：链地址实现简单、删除容易，但链表指针追逐对 CPU 缓存不友好；开放寻址数据紧凑缓存友好，但负载因子一高（>0.7）探查序列雪崩，且删除要打墓碑标记。Java 选前者，Python 选后者，没有谁对谁错，又是"看场景"。

7.2 图的两个经典算法家族

最短路径：单源无负权用 Dijkstra（贪心 + 优先队列，O(E log V)）；有负权边用 Bellman-Ford（松弛 V-1 轮，顺带能检测负环）；全源用 Floyd（三层循环的 DP，O(V³)，图小图稠才用）。
最小生成树：Kruskal 按边排序 + 并查集判环（适合稀疏图）；Prim 从点出发贪心扩边（适合稠密图）。

工程里 Dijkstra 出场率最高——导航、网络路由（OSPF）都是它的变体。并查集在刷题篇讲过，这里正好闭环。

8. 把整条链放回工程世界

学完整条进化链，回头看各个系统的选型，会发现全部是这条链上的位置决策：

flowchart TB
    MEM["纯内存 读写均衡<br/>Java TreeMap / epoll / CFS"] -->|红黑树| R1["近似平衡 旋转便宜"]
    MEM2["纯内存 读极多<br/>静态字典"] -->|AVL| R2["严格平衡 查得最快"]
    DISK["磁盘 点查为主<br/>MongoDB WiredTiger"] -->|B 树| R3["页对齐 矮胖<br/>内节点也能命中数据"]
    DISK2["磁盘 点查+海量范围扫描<br/>MySQL InnoDB / 绝大多数关系库"] -->|B+ 树| R4["叶子链表<br/>范围扫描顺序 I/O"]
    LOG["写极多 追加型<br/>LevelDB / RocksDB / HBase"] -->|LSM 树| R5["干脆放弃原地更新<br/>写全部顺序化"]
    style DISK2 fill:#ffd699

最后一行 LSM 树是题外话但值得一提：当写压力大到 B+ 树的页分裂和随机写都扛不住时，LevelDB/RocksDB 们干脆换了世界观——不原地改，只追加，把随机写变成顺序写，读的时候多层合并。这是"B 树家族应付不了的场景长出了新物种"的又一例，思路和本篇主线一脉相承：没有最好的结构，只有最匹配 I/O 模式的结构。

思考与感悟

1. 数据结构课的隐藏主线是"权衡"，不是"结构"。 教材目录按结构分章，但真正的线索是：每个结构都在某个维度上多要了一点、在另一个维度上让了一步。AVL 要了查询速度让了写入成本，红黑树反过来；B+ 树要了范围扫描让了内节点命中。考试考结构，工作考权衡。

2. “为什么"比"怎么做"值钱。 红黑树的旋转规则我忘光了，但"为什么不能两个红挨着 = 2-3 树节点容量"这个理解我记了十年。背规则应付考试，理解动机应付工作——工作中没人让你手写 B 树分裂，但天天有人问"这个索引为什么这么建”。

3. 磁盘那节课值整门课的一半。 很多人学完数据结构，认知还停留在"比较次数"的世界。B 树这一课的真正教学目的，是把你的复杂度单位从"操作次数"切换到"I/O 次数"。这个切换一旦完成，后面学数据库、学存储引擎、学缓存，全是同一件事的不同切面。

4. 这条链还没完。 B+ 树不是终点——LSM 树在写密集场景抢了它的地盘，跳表在 Redis 里用更简单的实现达到了类似的效果，AI 时代的向量索引（HNSW）干脆用图结构解决相似度搜索。数据结构这门课永远在续写，但写法永远是一样的：一个新场景出现，旧结构哪里疼，新结构就长在哪里。

算法与数据结构入门学习总结：从零看懂核心原理与 LeetCode 避坑技巧

Thu, 09 Aug 2018 11:04:39 +0800

算法与数据结构入门学习总结

目标读者：刚开始刷题、想系统梳理基础的同学。
参考文档：D:\doc\算法\combined_document.md（《剑指 Offer（专项突破版）》题解合集）。
阅读目标：理解核心原理、记住常用模板、少踩常见坑。

0. 写在前面：为什么要先建立“知识地图”

刷题最怕两种情况：

拿到题完全没思路，只能硬写暴力，时间超了也不知道怎么优化。
大概知道方向，但细节错一堆：数组越界、整数溢出、指针空指针、边界条件漏掉。

这篇博客想解决的就是这两个问题：先搭好知识框架，再集中火力避坑。只要你知道“这道题可能考什么数据结构/算法思想”，就能快速定位解法。

0.1 学习路线图

flowchart LR
    A[语言基础] --> B[复杂度分析]
    B --> C[线性结构<br/>数组/链表/栈/队列]
    C --> D[非线性结构<br/>树/堆/图]
    D --> E[高级结构<br/>哈希/并查集/Trie]
    E --> F[基础算法思想]
    F --> G[专项刷题]
    F --> H[面试/竞赛]

建议学习顺序：

先学 复杂度分析，它是评判代码好坏的尺子。
再学 数组、链表、栈、队列，它们是后续所有结构的“建筑材料”。
进入 树、堆、图，理解非线性结构的遍历方式。
最后系统学习 算法思想：双指针、滑动窗口、二分、前缀和、回溯、动态规划、BFS/DFS。

1. 复杂度：衡量算法的尺子

1.1 时间复杂度

时间复杂度描述的是算法运行时间随输入规模增长的趋势，不是真正的秒数。

常见复杂度（从小到大）：

复杂度	名称	典型场景
O(1)	常数	哈希表查询、数组随机访问
O(log n)	对数	二分查找、倍增
O(n)	线性	一次遍历
O(n log n)	线性对数	快排、归并排序
O(n²)	平方	双重循环、朴素 DP
O(2ⁿ) / O(n!)	指数/阶乘	回溯、全排列

估算口诀：看循环层数 + 看每次循环内部有没有“折半”操作。

1.2 空间复杂度

空间复杂度描述算法额外占用的内存。注意：

输入数组本身不计入额外空间。
递归调用栈深度也要算空间。

flowchart TD
    A[分析代码] --> B[有没有开辟新数组/哈希表?]
    A --> C[有没有递归?]
    B --> D[空间 = 数据结构大小]
    C --> E[空间 = 递归最大深度]
    D --> F[取最大值]
    E --> F

2. 数据结构全景图

mindmap
  root((数据结构与算法))
    线性结构
      数组
      链表
      栈
      队列
    非线性结构
      树
        二叉树
        二叉搜索树
      堆
      图
    集合与映射
      哈希表
      并查集
    字符串专属
      前缀树 Trie
    算法思想
      双指针/滑动窗口
      二分/前缀和
      递归/回溯
      动态规划
      贪心/分治

2.1 各数据结构的核心能力

数据结构	核心能力	最适合解决的问题
数组	随机访问 O(1)	按索引查询、前缀和、双指针
链表	动态增删 O(1)	反转、合并、环检测
栈	后进先出 LIFO	括号匹配、表达式求值、单调栈
队列	先进先出 FIFO	BFS、滑动窗口、单调队列
哈希表	快速查找 O(1)	去重、计数、两数之和
树/ BST	分层、有序	遍历、最近公共祖先、中序有序
堆	快速取最值 O(log n)	TopK、合并 K 个有序数组
图	描述多对多关系	最短路径、拓扑排序、连通性
Trie	前缀匹配	单词前缀、最大异或、自动补全

3. 线性结构：数组、链表、栈、队列

3.1 数组：最朴素但最万能

数组的特点是连续内存 + 随机访问。数组题最常见的套路是：

双指针：相向（两数之和）、同向（滑动窗口）。
前缀和：把“区间求和”变成“两个前缀和相减”。
排序后处理：很多题先排序，复杂度就从 O(n²) 降到 O(n log n)。

双指针模板

flowchart TD
    A[初始化 left, right] --> B{指针方向?}
    B -->|相向| C[left=0, right=n-1]
    B -->|同向| D[left=0, right=0]
    C --> E[while left < right]
    D --> F[for right in 0..n-1]
    E --> G[根据条件移动 left 或 right]
    F --> H[按需收缩 left 扩展窗口]
    G --> I[更新答案]
    H --> I

例题思路串讲：

题目	核心技巧	关键记忆点
排序数组中两数之和	相向双指针	和大了 `right--`，和小了 `left++`
三数之和	排序 + 双指针 + 去重	外层和内层都要 `while` 跳过重复值
和 ≥ target 的最短子数组	同向双指针/滑动窗口	右扩左缩，记录最小长度
乘积 < K 的子数组	同向双指针	满足条件时新增 `right-left+1` 个子数组
和为 K 的子数组	前缀和 + 哈希表	`map.put(0, 1)` 必不可少
0 和 1 个数相同的子数组	0 变 -1 后转“和为 0”	`map.put(0, -1)` 处理从开头开始的子数组
二维子矩阵的和	二维前缀和	`sum[i+1][j+1] = sum[i][j+1] + rowSum`

三数之和去重是新人重灾区，一定要记住：排序后，如果当前值和上一个值相同，就跳过，否则会产生重复三元组。

3.2 链表：虚拟头节点 + 快慢指针

链表不像数组能随机访问，所以核心技巧是：

虚拟头节点（dummy）：方便删除头节点，统一代码。
快慢指针：找中点、找环、找倒数第 K 个。
反转链表：三指针 pre / now / next 一遍完成。

// 反转链表模板
public ListNode reverseList(ListNode head) {
    ListNode pre = null, now = head;
    while (now != null) {
        ListNode next = now.next;
        now.next = pre;
        pre = now;
        now = next;
    }
    return pre;
}

链表常见坑：

忘记处理空链表或单节点。
移动指针时把 next 覆盖了，后面没法继续遍历。
找中点时快慢指针初始化/终止条件写错（建议画图手推一次）。

3.3 栈：后进先出 + 单调栈

栈的两个高频用法：

辅助计算：括号匹配、后缀表达式、进制转换。
单调栈：找“下一个更大/更小元素”、直方图最大矩形。

flowchart LR
    A[遍历元素] --> B{栈顶与新元素关系?}
    B -->|满足单调性| C[压栈]
    B -->|破坏单调性| D[弹出栈顶并计算]
    D --> B
    C --> E[继续遍历]

3.4 队列：先进先出 + BFS 利器

队列最经典的应用是 BFS（广度优先搜索）：一层一层扩展，天然适合“最短路径/最浅结果”。

flowchart TD
    A[起点入队] --> B[while 队列非空]
    B --> C[队首出队]
    C --> D[扩展所有邻居]
    D --> E[未访问的邻居入队]
    E --> B

4. 非线性结构：树、堆、图

4.1 二叉树：递归是王道

二叉树题目 90% 都能用递归解决，核心想清楚三件事：

当前节点要做什么？
递归返回什么？
边界条件是什么？（通常是 node == null）

flowchart TD
    A[处理当前节点] --> B[递归左子树]
    A --> C[递归右子树]
    B --> D[合并左右结果]
    C --> D

二叉树遍历：

前序：根 → 左 → 右
中序：左 → 根 → 右（BST 中序有序）
后序：左 → 右 → 根

二叉搜索树（BST）性质：左子树所有节点 < 根 < 右子树所有节点。利用这个性质可以 O(h) 查找、插入、删除。

4.2 堆：优先队列 = 动态最值

堆通常用优先队列实现。核心能力：

插入 O(log n)
取最值 O(log n)
看最值 O(1)

TopK 问题（找前 K 大/小）是堆最经典的面试题。思路：维护一个大小为 K 的小根堆，堆里保存目前最大的 K 个数。

4.3 图：BFS vs DFS

图是最灵活的数据结构，几乎所有图算法都基于 BFS 或 DFS。

flowchart TD
    A[图的遍历] --> B{要最短/分层?}
    B -->|是| C[BFS 队列]
    B -->|否| D[DFS 递归/栈]
    C --> E[visited 集合防重复]
    D --> E

图的常见题型：

问题	首选算法
岛屿数量、连通分量	DFS / 并查集
最短路径（无权图）	BFS
拓扑排序	Kahn 算法（入度）/ DFS 后序逆序
最小生成树	Kruskal / Prim
单源最短路（带权）	Dijkstra / Bellman-Ford

5. 高级结构与技巧

5.1 哈希表：用空间换时间

哈希表能把“查找”从 O(n) 降到 O(1)。刷题时常见的哈希用法：

计数：统计字符/数字出现次数。
去重：判断元素是否出现过。
记录位置：LRU、两数之和、前缀和下标。

经典设计题：

RandomizedSet：数组 + 哈希表，删除时把末尾元素 swap 到被删位置，保证 O(1)。
LRU Cache：哈希表 + 双向链表，get/put 都把节点移到尾部，超出容量时删头部。

5.2 前缀树 Trie

Trie 用于高效处理字符串前缀、自动补全、最大异或等问题。

flowchart TD
    A[root] --> B[a]
    A --> C[b]
    B --> D[p]
    B --> E[p2]
    C --> F[e]
    D --> G[p<br/>isEnd=true]
    E --> H[p<br/>isEnd=true]
    F --> I[e<br/>isEnd=true]

每个节点代表一个字符前缀；叶子或标记节点表示完整单词。

5.3 并查集

并查集解决“连通性”问题，三个操作：

find(x)：找到 x 的根。
union(x, y)：合并两个集合。
connected(x, y)：判断是否同根。

配合 路径压缩 和 按秩合并，单次操作近似 O(α(n))，可以认为接近 O(1)。

6. 算法思想：把题归类

6.1 二分查找：不是只能查有序数组

二分查找的精髓是：找到一个可以判定“答案是否可行”的条件，然后不断缩小答案区间。

flowchart TD
    A[确定二分对象] --> B[写出 canmid 判定]
    B --> C[初始化 l, r]
    C --> D[while l < r]
    D --> E{canmid?}
    E -->|true| F[答案在左半区<br/>r = mid]
    E -->|false| G[答案在右半区<br/>l = mid + 1]
    F --> D
    G --> D
    D --> H[返回 l]

二分查找避坑：

循环条件写成 l <= r 还是 l < r，取决于你要不要包含右端点。
mid = l + (r - l) / 2 比 (l + r) / 2 更安全，防止整数溢出。
左/右边界更新要对称：左闭右闭就 l = mid + 1, r = mid - 1；左闭右开要相应调整。

6.2 滑动窗口：双指针的高级形态

滑动窗口适合处理子数组/子串问题，前提是“右指针右移时，窗口内某种性质单调变化”。

flowchart LR
    A[初始化 left=0] --> B[right 从左到右遍历]
    B --> C[扩大窗口 更新状态]
    C --> D{窗口是否合法?}
    D -->|不合法| E[移动 left 收缩窗口]
    D -->|合法| F[更新答案]
    E --> F
    F --> B

什么时候不能用滑动窗口？ 当数组不是单调（例如有负数）时，和/积不具备单调性，要改用前缀和 + 哈希表。

6.3 前缀和：区间查询的利器

前缀和把“区间和”问题变成“差分”：

sum(i, j) = prefix[j+1] - prefix[i]

二维前缀和公式：

prefix[i][j] = matrix[i-1][j-1]
             + prefix[i-1][j] + prefix[i][j-1]
             - prefix[i-1][j-1]

一维前缀和 + 哈希表 可以把“和为 K 的子数组”从 O(n²) 降到 O(n)。

6.4 递归与回溯：暴力枚举的艺术

回溯 = 递归 + 做选择 + 撤销选择。模板：

void backtrack(路径, 选择列表) {
    if (满足结束条件) {
        result.add(路径);
        return;
    }
    for (选择 in 选择列表) {
        做选择;
        backtrack(路径, 选择列表);
        撤销选择;
    }
}

graph TD
    A[开始 backtrack] --> B{剪枝/终止?}
    B -->|是| C[记录答案]
    B -->|否| D[做选择]
    D --> E[递归下一层]
    E --> F[撤销选择]
    F --> G[尝试下一个选择]
    G --> D
    C --> H[返回]

回溯常见题型：子集、组合、排列、N 皇后、括号生成、复原 IP。

6.5 动态规划：找状态转移

DP 是很多新人的噩梦。其实套路很固定：

flowchart LR
    A["定义状态 dp[i] 或 dp[i][j]"] --> B[写状态转移方程]
    B --> C[确定初始状态]
    C --> D[确定遍历顺序]
    D --> E[空间优化可选]

入门 DP 分类：

类型	特征	例题
线性 DP	一维数组递推	爬楼梯、房屋偷盗、最长递增子序列
区间 DP	区间 [i,j] 状态	最长回文子序列、最少回文分割
背包 DP	选或不选	分割等和子集、最少硬币
路径 DP	二维网格	不同路径、最小路径和
状态压缩 DP	用二进制表示集合	旅行商问题、棋盘覆盖

DP 避坑：

状态定义不清晰就开始写，写到一半发现转移不了。
遍历顺序搞反，导致用到还没计算出来的状态。
忘记初始化 dp[0] 或边界行/列。

6.6 贪心：每次局部最优

贪心没有通用模板，关键是证明局部最优能推导出全局最优。常见贪心场景：

区间问题：按结束时间排序选最多不重叠区间。
跳跃游戏：每次选能跳最远的位置。
哈夫曼编码：每次合并最小的两个。

如果你不确定贪心对不对，建议先用 DP 或回溯验证小例子。

7. 位运算与整数技巧

参考文档第一章专门讲整数，里面有很多位运算技巧，面试题也常考。

7.1 常用位运算技巧

技巧	含义	例题
`n & (n-1)`	把 n 最右侧的 1 变成 0	统计二进制 1 的个数
`n & (-n)`	只保留最右侧的 1	判断是否是 2 的幂
`a ^ a = 0`	相同数异或为 0	只出现一次的数字
`a ^ 0 = a`	与 0 异或不变	两数交换

7.2 整数除法：倍增法

最朴素的除法是不断减，最坏 O(n)。倍增法的思想是：判断被除数能容纳除数的 1 倍、2 倍、4 倍……直到不能容纳，然后减去最大的倍数，重复这个过程。

复杂度：O(log n)。

避坑：

Integer.MIN_VALUE / -1 会溢出。
为了处理符号，通常把两个数都转成负数计算，最后再加符号。
累加时要判断是否超过 0xc0000000（即最小负数的一半），防止溢出。

7.3 状态压缩：用 int 表示集合

当数据范围只有 26 个小写字母、或 20 个以内的元素时，可以用一个 int 的每一位表示“选/没选”。

例如“单词长度的最大乘积”中，用 int 的低 26 位表示一个单词包含哪些字母，两个单词的位掩码 & 为 0 就说明没有公共字母。

8. 排序算法回顾

排序	平均时间	空间	稳定性	特点
冒泡/选择/插入	O(n²)	O(1)	稳定（插入）	简单，数据量小可用
快速排序	O(n log n)	O(log n)	不稳定	平均最快
归并排序	O(n log n)	O(n)	稳定	链表排序、逆序对
堆排序	O(n log n)	O(1)	不稳定	TopK、优先队列
计数/桶/基数	O(n+k)	O(k)	稳定	数据范围有限

实战建议：

数组排序直接用语言内置函数（Java Arrays.sort()）。
链表排序适合归并（自顶向下或自底向上）。
找第 K 大可以用快速选择（平均 O(n)）或堆。

9. LeetCode 刷题闭坑指南（重点）

这部分把参考文档里反复出现的“坑”集中整理出来，刷题前先看一遍，能少错很多。

9.1 拿到题后先做什么

flowchart TD
    A[拿到题目] --> B[读三遍题意]
    B --> C[列出所有边界条件]
    C --> D[手写 2-3 个小例子]
    D --> E[判断数据结构与算法]
    E --> F[写代码]
    F --> G[脑内跑一遍边界]
    G --> H[提交]

9.2 整数与边界

坑	案例
整数溢出	`Integer.MIN_VALUE / -1` 返回 `Integer.MAX_VALUE`
越界累加	除法倍增时判断 `value >= 0xc0000000`
负数右移	负数算术右移最高位永远补 1
`mid` 溢出	二分写 `mid = l + (r - l) / 2`

9.3 数组与字符串

坑	案例
下标越界	`right = n` 还是 `right = n-1` 要统一
左/右边界更新	注意是 `++left` 还是 `left++`（三数之和去重用 `nums[++left]`）
前缀和初始化	和为 K 子数组必须 `map.put(0, 1)`
二维前缀和	通常多开一行一列避免边界判断
字符串变位词	用长度 26/58 的 int 数组模拟哈希表

9.4 链表

坑	解决方案
头节点可能被删	使用 dummy 节点
空指针	访问 `node.next` 前先判空
找中点/环	快慢指针初始化和终止条件画图确认
反转丢失 next	先用临时变量保存 `now.next`

9.5 递归与回溯

坑	解决方案
终止条件漏写	先写边界，再写递归体
共享状态被污染	回溯时记得“撤销选择”
重复结果	排序后跳过相同元素，或用 `visited` 数组
栈溢出	深度太大时考虑改迭代 + 栈

9.6 动态规划

坑	解决方案
状态定义错误	先用一句话描述“dp[i] 表示什么”
遍历顺序错误	画依赖图，确保计算 dp[i] 时所需状态已算好
边界没初始化	先填第 0 行/列，或 `dp[0]`
空间可以优化	滚动数组、一维降维

9.7 二分查找

坑	解决方案
循环条件写错	根据开闭区间选择 `l < r` 或 `l <= r`
边界更新不对称	`l = mid + 1` 对应 `r = mid` 或 `r = mid - 1`
死循环	左中点 `mid = l + (r-l)/2` 与右中点 `mid = l + (r-l+1)/2` 选清楚

10. 一张图串联所有知识点

flowchart TD
    A[算法题] --> B{看到什么关键词?}
    B -->|子数组/子串<br/>和/积/去重| C[双指针 / 滑动窗口]
    B -->|区间和/连续和| D[前缀和 + 哈希表]
    B -->|有序 / 最大化最小值| E[二分查找]
    B -->|所有组合/排列/子集| F[回溯]
    B -->|最优子结构| G[动态规划]
    B -->|最短路径/层序| H[BFS]
    B -->|连通/全遍历| I[DFS / 并查集]
    B -->|TopK / 动态最值| J[堆]
    B -->|前缀匹配| K[Trie]
    C --> L[写代码]
    D --> L
    E --> L
    F --> L
    G --> L
    H --> L
    I --> L
    J --> L
    K --> L

11. 给新人的刷题路线建议

第 1-2 周：数组 + 链表
- 两数之和、三数之和、反转链表、合并两个有序链表、环形链表。
第 3-4 周：栈 + 队列 + 哈希表
- 有效的括号、最小栈、LRU 缓存、字母异位词。
第 5-6 周：树 + 递归
- 二叉树前中后序遍历、二叉树层序遍历、二叉搜索树验证、路径总和。
第 7-8 周：回溯 + 动态规划
- 全排列、组合总和、爬楼梯、最长公共子序列、不同路径。
第 9-10 周：图 + 高级结构
- 岛屿数量、课程表（拓扑排序）、数据流第 K 大、实现 Trie。
持续：按标签二刷 + 总结错题本

刷题原则：

第一遍不要死磕，20 分钟没思路直接看题解，重点理解“为什么这样想”。
第二天再独立写一遍，一周后回来再写一遍。
把每道题的“思路关键词”写进错题本，考前只看错题本。

12. 结语

算法和数据结构不是背代码，而是建立**“看到题目 → 识别模式 → 套用模板 → 处理边界”**的条件反射。希望这篇总结能帮你把零散的知识点串成一张网，刷题时少踩坑、多 AC。

最后送一句话：慢即是快。把一类题真正搞懂，比囫囵吞枣刷一百道更有效。

参考文档：`（《剑指 Offer（专项突破版）》题解合集）。
本文已整理成博客，欢迎在留言区补充你踩过的坑。

jphotoshop：用 Java Swing 手写一个 Photoshop——架构与算法全解析

Fri, 18 May 2018 10:00:00 +0800

jphotoshop：用 Java Swing 手写一个 Photoshop——架构与算法全解析

把多年前的一个练手项目整理开源了：jphotoshop，一个用纯 Java Swing 手写的 Photoshop 模拟器。不写不知道，写一个"简化版 PS"几乎把计算机图形学、数据结构和设计模式都过了一遍，这篇文章既是功能介绍，也是一次技术复盘。

开源地址：https://gitee.com/soulnew/jphotoshop
技术栈：Java + Swing（Swing Application Framework / JSR-296），NetBeans Ant 工程
规模：197 个 Java 文件，约 1.8 万行（自研约 1.4 万行），开发周期约半年

一、功能概览：一个"简化版 PS"能做什么

UI 形态上和老版 PS 一致：MDI 多文档界面——每张图片一个内部编辑窗口，图层面板、导航缩放面板都是可拖动的浮动内窗。

1.1 图层系统

多图层编辑：图像图层、文字图层、浮动选区层（拖动选区内容时的临时层）；
图层面板带 40×30 实时缩略图，支持拖拽换序（基于 Swing TransferHandler 的 DnD）、复制粘贴为新图层；
透明区域用经典的灰白棋盘格打底。

1.2 选区工具（7 个）

工具	说明
魔棒	容差可调（默认 23），支持多连通区域一次选中
色彩范围	全图相似色选取
多边形套索	逐点勾勒
自由套索	鼠标轨迹勾勒
磁性套索	局部窗口内吸附边缘（完成度不高）
贝塞尔选区	双击闭合时自动做曲线拟合，生成平滑选区
移动工具	把选区内容提成浮动层，拖动实时合成，松手落回底层

选区还支持：羽化（可调半径）、反选、平移/缩放（AffineTransform）、以及标志性的蚂蚁线动画。

1.3 滤镜（24 个，分 5 大类）

模糊：均值平滑、高斯模糊（3×3 高斯核 {1,2,1;2,4,2;1,2,1}/16）、中值滤波；
锐化：Sharpen / SharpenMore（拉普拉斯卷积核 {0,-1,0;-1,5,-1;0,-1,0}）；
艺术：曝光过度、冰晶、熔岩、暗调（平方衰减）、漫画等 8 种风格化效果；
简单：反色、怀旧（sepia 矩阵 0.393/0.769/0.189...）、灰度；
扭曲：挤压、球面化、正/反旋转、正弦波浪、摩尔纹——扭曲类全部带多段滑块实时预览，取消可还原。

1.4 图像调整与文字

HSB 调整：先把整图 RGB 转成 HSB 三维 float 数组，色相/饱和度/亮度三个滑块实时调节再转回 RGB；
对比度调整；
文字工具：点击图片任意位置就地出现透明输入框 + 字体选择面板，完成后生成为独立的文字图层。

1.5 文件与工程

打开 jpg / png / gif / bmp；
自定义 .jps 工程格式（类似 PSD）：整个图层模型实现 Serializable，用 ObjectOutputStream 套 GZIPOutputStream 序列化保存，可以随时回来继续编辑；
复制 / 剪切 / 粘贴、导航缩放窗口、中文界面。

二、架构总览

graph TD
    A["JPhotoShop 入口<br/>EDT 中构建主窗口"] --> B["JDesktopPane MDI 主框架"]
    B --> C["EditFrame 编辑窗口<br/>每张图一个"]
    B --> D["LayerControl 图层面板"]
    B --> E["ViewSizeFrame 导航/缩放"]
    C --> F["EditModel<br/>像素模型 + MemoryImageSource 渲染"]
    F --> G["ImageModel<br/>LinkedList 图层栈"]
    G --> H["ImagePaintLayer / TextPaintLayer / TempImageLayer"]
    H --> I["LayerPlug 混合样式<br/>Alpha 合成"]
    C --> J["ToolManager<br/>工具代理/状态切换"]
    J --> K["Tool 抽象类<br/>魔棒/套索/贝塞尔/移动/文字..."]
    C --> L["FilterManager<br/>properties + 反射装配"]
    L --> M["PicFilter 滤镜即 Action"]
    M --> N["Math 包<br/>CoverOp 卷积 / FeatherSide 羽化<br/>FindSide 轮廓追踪 / PointConnection 并查集"]

整体分四层：UI 层（MDI 窗口与面板）、模型层（图层栈与像素数据）、工具/滤镜层（操作入口）、算法层（jphotoshop.Math 包）。工具和滤镜都通过 properties 配置 + 反射装配，下面详细说。

三、技术亮点

3.1 自绘像素管线：int[][] + MemoryImageSource

核心存储没有用 BufferedImage，而是直接操作 int[][] ARGB 二维数组——所有算法（卷积、混合、羽化）都在裸数组上做，直观且没有额外封装开销。

显示侧用了一个当年很典型的 Swing 高性能技巧：MemoryImageSource + setAnimated(true)，像素变化后调 newPixels() 增量刷新屏幕图像，避免每次重绘都重建整个 Image 对象。编辑、拖选区、调滤镜滑块时的实时反馈都靠它撑着。

3.2 链式图层合成缓存

多图层合成是最频繁的操作，朴素实现是每次重绘把所有层从头合一遍。这里的做法是给每个图层挂一个"本层与下面所有层合成结果的缓存 cacheData"，层与层之间用 backLayer 引用连成链：

graph LR
    BG["背景层<br/>棋盘格"] -->|"合成"| L1["图层1<br/>cacheData"]
    L1 -->|"合成"| L2["图层2<br/>cacheData"]
    L2 -->|"合成"| L3["图层3<br/>cacheData"]
    L3 --> OUT["最终显示图像"]
    style L2 fill:#f96
    L2 -. "仅从此层向上重建" .-> L3

某一层像素变化时，只从该层向上依次 reBuild，下面的层缓存不动。层数多、图大时，这个收益非常明显。

3.3 手写 Alpha 混合

AlphaLayerStyle 实现了逐像素的经典混合公式 C = α·Cf + (1-α)·Cb，并且处理了任意偏移（含负坐标裁剪）——浮动选区拖到画布边缘外也能正确合成。羽化后的选区掩码是 short 型 alpha 权重，抠图粘贴时按权重衰减，边缘不会出现生硬的锯齿。

3.4 魔棒：一条完整的算法链

魔棒是整个项目里算法含量最高的功能，完整链路分三步：

graph TD
    A["用户点击图片某点"] --> B["Flood Fill 泛洪填充<br/>8邻域 + 容差判断<br/>ΔR+ΔG+ΔB ＜ range"]
    B --> C["PointConnection 并查集<br/>id 数组 + sz 数组按秩合并<br/>分离多个互不连通的区域"]
    C --> D["FindSide 8方向轮廓追踪<br/>沿区域边界走一圈<br/>每3步抽稀路径点"]
    D --> E["GeneralPath 选区路径"]
    E --> F["蚂蚁线动画<br/>Timer 500ms 切换两条相位差3的虚线"]

几个细节：

泛洪填充用 LinkedList 当队列，容差判断用曼哈顿距离（|ΔR|+|ΔG|+|ΔB|），比欧氏距离省开方；
一次点击可能选中多个互不连通的区域（比如图片里分散的几块蓝天），用并查集把连通域分组，每个域独立生成轮廓；
轮廓追踪把面状的 boolean 掩码转成线状的路径点列，这一步直接决定蚂蚁线的平滑程度；
蚂蚁线动画是两条相位差为 3 的虚线 BasicStroke 用 500ms 的 Timer 交替绘制——朴素但效果完全对味。

3.5 通用卷积引擎 CoverOp

所有卷积类滤镜（模糊、锐化背后是同一个引擎 CoverOp，提供三种重载：

全图卷积；
掩码限定区域卷积——滤镜只在选区内生效，这是 PS 的基本体验；
short alpha 掩码卷积——配合羽化选区做渐变处理。

RGB 三通道分离卷积 + 边界 clamp，滤镜类只需要给一个卷积核就完事。新增一个模糊变体的成本是十几行代码。

3.6 贝塞尔选区：Schneider 曲线拟合

自由手绘的选区轨迹是抖动的折线，直接当选区很难看。贝塞尔选区工具在双击闭合时调用 JHotDraw 的 Bezier.fitCurve（Schneider 的经典拟合算法），把鼠标点列拟合成平滑的三次贝塞尔曲线段——这就是 PS 里"钢笔工具"的底层原理。

3.7 声明式装配：properties + 反射的原始"插件化"

工具和滤镜都不写死在代码里，而是从 properties 读类名、Class.forName 反射实例化：

# resource/filters.properties
filters.Kinds=模糊,锐化,艺术效果,简单,扭曲
模糊=Smooth,GaussBlur,Median

加一个新滤镜 = 写一个类 + 改一行配置，菜单自动按分类分组生成。工具栏同理（ToolManager.initTool）。项目里还专门有一个 plug 包在探索真正的外部插件机制（虽然只是个雏形）。在 2007 年没有 OSGi、没有 IoC 框架依赖的纯 Swing 工程里，这是最务实的可扩展方案。

3.8 工具架构：Proxy + State 的混合

Tool 抽象类把底层 MouseEvent 翻译成语义化回调（click / pressed / dragged / release / rightClick / clickDouble / move），子类只关心语义。ToolManager 本身也是 Tool 的子类，作为代理把事件转发给当前激活的工具——选中哪个工具，事件流就切到哪个状态机上。每个工具还可以自带 getPlugPanel() 参数面板，选中时挂到选项栏上，和 PS 的交互完全一致。

3.9 扭曲滤镜的"预览-取消"模式

扭曲类滤镜（球面、旋转、波浪……）都是坐标重映射：对每个目标像素做逆极坐标变换，找它在原图的取样点。为了支持滑块实时预览又能取消还原，ContortFilter 在打开对话框时先备份 tempData，滑块每次变化都在备份基础上重算，点取消直接把备份拷回——一个廉价的 Memento 模式。配套的 MultiSlider 多段滑块控件也是自绘的。

3.10 滤镜即 Action

PicFilter extends AbstractAction，滤镜本身就是可以挂进菜单/工具栏的 Action：actionPerformed 里自动取当前窗口、当前图层、当前选区掩码，还处理了选区坐标系到图层坐标系的换算（start -= layerStart），执行完触发 rePaintEdit 刷新。框架把脏活都干了，滤镜作者只需要关注像素算法。

四、诚实的复盘：留下了什么遗憾

开源的代码就是当年的样子，包括未完成的部分，如实列出：

撤销/重做是空架子：UndoRedoManager 的骨架搭好了，但 propertyChange 三个分支全是空的——这是当时没啃下来的硬骨头，现在看应该用 Command 模式重做，而不是当初设想的 property 监听方案；
历史面板、通道面板、外部插件机制都只有雏形；
磁性套索完成度不高；
若干小 bug，比如 FindSide 里找最近点写成了找最远点（if (temp > MinLength) 应为 <）、"undo".endsWith(...) 应为 startsWith、几处类名 typo（WaveFiler、getSize 拼写）——权当留给读者的"考古彩蛋"。

五、写在最后

写 jphotoshop 的半年收获远超预期：并查集、轮廓追踪、卷积、贝塞尔拟合这些算法不再是教科书上的名词，而是要亲手调到能跑的东西；合成缓存、声明式装配、Action 抽象这些设计，也都是被真实需求逼出来的。如果你也想扎实练一次"算法 + 工程"的综合功，手写一个图像编辑器是我能想到的最好题目之一。

源码在 https://gitee.com/soulnew/jphotoshop，欢迎 Star、Fork，更欢迎把那个空着的 UndoRedoManager 补上。