diff --git a/CLAUDE.md b/CLAUDE.md index 903dc25..e61a882 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -10,6 +10,12 @@ Read this file end to end before touching anything. with a 中文 toggle, so user-facing copy is authored as `{ en, zh }` pairs (type `Loc` from `lib/i18n.tsx`) — never English-only, never Chinese-only. - Chinese inside a `zh:` value is content, not a comment. Never "clean it up". +- Keep a Chinese sentence in JSX on one line, or break it only next to a tag or + a `{…}` expression. JSX joins the lines of a text block with a space, and + Chinese shows it as a stray gap ("算。 建议"). Spaces belong only between + Chinese and Latin letters, digits or expressions ("第 3 章", "O(1) 随机访问"), + around "——" and around math operators — never after full-width punctuation. + `test/unit/zh-copy-spacing.test.ts` fails on any other. ## What this is diff --git a/app/advanced/page.tsx b/app/advanced/page.tsx index c62cfcf..5e61bee 100644 --- a/app/advanced/page.tsx +++ b/app/advanced/page.tsx @@ -97,8 +97,7 @@ const F146: ArrayFrame[] = [ ), zh: ( <> - put(2,2):2:2 头插,1:1 被挤到尾部 —— 它现在是最久未使用的那个, - 也是下一个被淘汰的候选。 + put(2,2):2:2 头插,1:1 被挤到尾部 —— 它现在是最久未使用的那个,也是下一个被淘汰的候选。 ), }, @@ -143,8 +142,7 @@ const F146: ArrayFrame[] = [ ), zh: ( <> - put(3,3):容量已满,尾部的 2:2 被淘汰 —— 链表 O(1) 摘除, - 再用节点里存的 key 在哈希表里 O(1) 删掉条目,然后 3:3 头插。 + put(3,3):容量已满,尾部的 2:2 被淘汰 —— 链表 O(1) 摘除,再用节点里存的 key 在哈希表里 O(1) 删掉条目,然后 3:3 头插。 ), }, @@ -333,8 +331,7 @@ const F307: ArrayFrame[] = [ ), zh: ( <> - tree[6] 管 [5,6]:s = 2+14 = 16;6−lowbit(6) = 6−2 = 4。 - 注意各段首尾相接、互不重叠 —— 所以直接相加就是答案。 + tree[6] 管 [5,6]:s = 2+14 = 16;6−lowbit(6) = 6−2 = 4。注意各段首尾相接、互不重叠 —— 所以直接相加就是答案。 ), }, @@ -353,8 +350,7 @@ const F307: ArrayFrame[] = [ ), zh: ( <> - tree[4] 管 [1,4](已经含刚才的 +2):s = 16+11 = 27;4−4 = 0,停。 - 三段拼出前缀和 27 = 3+1+6+1+5+9+2 ✓ —— 拆的正是 7 = 4+2+1 的二进制。 + tree[4] 管 [1,4](已经含刚才的 +2):s = 16+11 = 27;4−4 = 0,停。三段拼出前缀和 27 = 3+1+6+1+5+9+2 ✓ —— 拆的正是 7 = 4+2+1 的二进制。 ), }, @@ -419,8 +415,7 @@ const F380: ArrayFrame[] = [ ), zh: ( <> - remove(8):哈希表查到 8 住在下标 1。数组中间删除通常要 O(n) 搬移后面的元素, - 但集合不在乎顺序 —— 直接把末尾的 3 抄过来盖掉 8。 + remove(8):哈希表查到 8 住在下标 1。数组中间删除通常要 O(n) 搬移后面的元素,但集合不在乎顺序 —— 直接把末尾的 3 抄过来盖掉 8。 ), }, @@ -480,8 +475,7 @@ const F380: ArrayFrame[] = [ zh: ( <> getRandom():在 [0, size) 里随机取一个下标,数组 O(1) 随机访问 —— - 每个元素被选中的概率恰好是 1/size。这就是必须有数组的原因: - 哈希表内部有空桶,做不到 O(1) 的等概率抽样。 + 每个元素被选中的概率恰好是 1/size。这就是必须有数组的原因:哈希表内部有空桶,做不到 O(1) 的等概率抽样。 ), }, @@ -533,8 +527,7 @@ export default function AdvancedChapter() { zh: ( <> 前 12 章学的是单个结构;这一章把它们拼成 - 能用的机器:LRU 缓存、线段树、跳表、布隆过滤器。 - 真实系统里跑着的很少是单个结构,而是两个结构互相补上对方的短板。 + 能用的机器:LRU 缓存、线段树、跳表、布隆过滤器。真实系统里跑着的很少是单个结构,而是两个结构互相补上对方的短板。 ), }} @@ -584,17 +577,14 @@ export default function AdvancedChapter() { zh={ <>

- 回头看这门课:数组(第 1 章)给你 O(1) 随机访问,链表(第 3 章) - 在拿到节点后给你 O(1) 摘除和插入,哈希表(第 6 章)给你 O(1) - 按 key 定位,堆(第 9 章)给你 O(log n) 取最值。 - 每个结构都只有一两招快,别的操作就慢。 + 回头看这门课:数组(第 1 章)给你 O(1) 随机访问,链表(第 3 章)在拿到节点后给你 O(1) 摘除和插入,哈希表(第 6 章)给你 O(1) + 按 key 定位,堆(第 9 章)给你 O(log n) 取最值。每个结构都只有一两招快,别的操作就慢。

真实需求却很少只要一招:「缓存要能 O(1) 读并且 O(1) 淘汰最久未用的」、「数组要能改并且能快速查区间和」—— 任何单一结构都会在其中一个操作上卡住。常见的解法不是发明新结构,而是 - 把两个结构拼在一起,让每个只干自己快的那件事。 - 本章的六台机器全部是这么拼出来的。 + 把两个结构拼在一起,让每个只干自己快的那件事。本章的六台机器全部是这么拼出来的。

} @@ -722,8 +712,7 @@ export default function AdvancedChapter() { } zh={ <> - 每次操作必须在同一步里把所有成员都改到位:删链表节点就必须删哈希条目。 - 丢掉这个同步,是组合结构最常见的 bug 来源。 + 每次操作必须在同一步里把所有成员都改到位:删链表节点就必须删哈希条目。丢掉这个同步,是组合结构最常见的 bug 来源。 } /> @@ -754,8 +743,7 @@ export default function AdvancedChapter() {

拿到「设计一个 XX」:第一步列出全部操作 (get/put/delete/random…);第二步给每个操作定 - 复杂度预算(题目要求 O(1) 还是 O(log n)?); - 第三步看单一结构在哪一步超预算, + 复杂度预算(题目要求 O(1) 还是 O(log n)?);第三步看单一结构在哪一步超预算, 再补一个结构专门负责那个操作。本章每一节都是这套方法的一次完整演练。

} @@ -817,23 +805,17 @@ export default function AdvancedChapter() { zh={ <>

- 先从需求说起。缓存(cache)是一块「快但小」的存储: - 内存比磁盘快得多,却装不下全部数据,所以只放最可能被再次用到的那部分。 - 小就带来一个绕不开的问题 ——{" "} + 先从需求说起。缓存(cache)是一块「快但小」的存储:内存比磁盘快得多,却装不下全部数据,所以只放最可能被再次用到的那部分。小就带来一个绕不开的问题 ——{" "} 满了以后,腾谁的位置?

经典答案:淘汰最久没被用过的那条数据,即{" "} - LRU(least recently used,最近最少使用)。 - 它之所以有效,是因为程序访问数据有 - 时间局部性(temporal locality): - 刚读过的数据很可能马上又要读,很久没碰的大概率短期内也用不上。 + LRU(least recently used,最近最少使用)。它之所以有效,是因为程序访问数据有 + 时间局部性(temporal locality):刚读过的数据很可能马上又要读,很久没碰的大概率短期内也用不上。

于是需求清单出炉,这正是 LC 146 的原题: - get(key) 读缓存、put(key, value) 写缓存, - 容量满时自动淘汰最久未用的那条 —— 并且两个操作都必须 O(1)。 - 缓存本身是为「快」而生的,如果缓存操作自己是 O(n),它就失去了意义。 + get(key) 读缓存、put(key, value) 写缓存,容量满时自动淘汰最久未用的那条 —— 并且两个操作都必须 O(1)。缓存本身是为「快」而生的,如果缓存操作自己是 O(n),它就失去了意义。

} @@ -904,8 +886,7 @@ export default function AdvancedChapter() { <> 只用数组或链表(按访问时间排) 把数据按最近使用排成一排:谁被访问就搬到最前面,末尾就是该淘汰的 - —— 顺序有了。但 get(key) 要先找到这条数据: - 没有下标可算、没有哈希可查,只能从头扫,O(n),出局。 + —— 顺序有了。但 get(key) 要先找到这条数据:没有下标可算、没有哈希可查,只能从头扫,O(n),出局。 } /> @@ -933,8 +914,7 @@ export default function AdvancedChapter() { zh={ <> 数组 + 哈希表(哈希存下标) - 哈希 O(1) 定位到数组下标,顺序也有 —— 可「把刚访问的元素搬到最前」 - 是数组的中间删除 + 头部插入:第 1 章数过,后面所有元素都要搬移, + 哈希 O(1) 定位到数组下标,顺序也有 —— 可「把刚访问的元素搬到最前」是数组的中间删除 + 头部插入:第 1 章数过,后面所有元素都要搬移, O(n),还会让哈希表里一大片下标失效。出局。 } @@ -965,9 +945,7 @@ export default function AdvancedChapter() { zh={ <> 单链表 + 哈希表(哈希存节点引用) - 最接近了。哈希表存「key → 链表节点」,一步定位到节点, - 拿到节点后链表插删又是 O(1)……但把节点从链表中间摘下来, - 要把前驱的 next 指到自己的 next 上 ——{" "} + 最接近了。哈希表存「key → 链表节点」,一步定位到节点,拿到节点后链表插删又是 O(1)……但把节点从链表中间摘下来,要把前驱的 next 指到自己的 next 上 ——{" "} 单链表的节点拿不到自己的前驱,找前驱只能从头扫,O(n)。就差一根指针。 } @@ -1024,10 +1002,7 @@ export default function AdvancedChapter() { } zh={

- 这是错的。LRU 里从来没有人遍历链表去查找节点: - 定位永远走哈希表(key → 节点引用,一步到位), - 链表只在「已经拿到节点」之后做摘除和头插 —— 全是改几根指针的 O(1) 操作。 - 两个结构各做各自快的那件事。 + 这是错的。LRU 里从来没有人遍历链表去查找节点:定位永远走哈希表(key → 节点引用,一步到位),链表只在「已经拿到节点」之后做摘除和头插 —— 全是改几根指针的 O(1) 操作。两个结构各做各自快的那件事。

} /> @@ -1536,10 +1511,7 @@ class LRUCache { zh={

JDK 里的 LinkedHashMap,名字就说明了一切:Linked - (双向链表)+ HashMap(哈希表)。它的每个 Entry 除了挂在哈希桶里, - 还带 before/after 指针串成一条双向链表 —— 就是我们刚手写的那台机器。 - 构造参数 accessOrder = true 让链表按访问序而不是插入序排列, - 再覆写一个钩子方法就成了。 + (双向链表)+ HashMap(哈希表)。它的每个 Entry 除了挂在哈希桶里,还带 before/after 指针串成一条双向链表 —— 就是我们刚手写的那台机器。构造参数 accessOrder = true 让链表按访问序而不是插入序排列,再覆写一个钩子方法就成了。

} /> @@ -1630,14 +1602,10 @@ class LRUCache { } zh={

- Redis:配置 maxmemory-policy allkeys-lru 后, - 内存吃紧时按 LRU 淘汰。它用的是近似 LRU: - 给几亿个 key 维护一条全局链表,光指针就太费内存, - 所以 Redis 每次随机采样几个 key,淘汰其中最久未用的 —— + Redis:配置 maxmemory-policy allkeys-lru 后,内存吃紧时按 LRU 淘汰。它用的是近似 LRU:给几亿个 key 维护一条全局链表,光指针就太费内存,所以 Redis 每次随机采样几个 key,淘汰其中最久未用的 —— 用一点点精度换大量内存。 - 浏览器:HTTP 缓存、图片解码缓存的容量控制都是 LRU 的变体。 - 操作系统:物理内存不够时要选一个页面换出到磁盘, - 主流的页面置换算法(如 Clock)同样是 LRU 的近似 —— + 浏览器:HTTP 缓存、图片解码缓存的容量控制都是 LRU 的变体。 + 操作系统:物理内存不够时要选一个页面换出到磁盘,主流的页面置换算法(如 Clock)同样是 LRU 的近似 —— 精确 LRU 要求每次内存访问都更新链表,代价太高。

} @@ -1685,17 +1653,10 @@ class LRUCache { zh={ <>

- LRU 看「多久没用」,LFU 看「用了多少次」: - 淘汰访问次数最少的;次数打平时,再淘汰其中最久未用的那个。 - 它适合热点长期稳定的场景 —— 一条被反复访问的数据即使最近 10 分钟没人碰, - 也不该被一批一次性访问挤出缓存。 + LRU 看「多久没用」,LFU 看「用了多少次」:淘汰访问次数最少的;次数打平时,再淘汰其中最久未用的那个。它适合热点长期稳定的场景 —— 一条被反复访问的数据即使最近 10 分钟没人碰,也不该被一批一次性访问挤出缓存。

- 为什么 LFU 比 LRU 难一档?LRU 里「最旧」永远躺在链表尾部,天然就绪; - 而 LFU 的频次每访问一次就变:key 的频次 +1, - 它在「按频次排序」里的位置就要挪。用堆(第 9 章)维护最小频次? - 每次调整是 O(log n),而且相同频次还要再比时间,做不到全 O(1)。 - 正解是按频次分桶(frequency buckets)。 + 为什么 LFU 比 LRU 难一档?LRU 里「最旧」永远躺在链表尾部,天然就绪;而 LFU 的频次每访问一次就变:key 的频次 +1,它在「按频次排序」里的位置就要挪。用堆(第 9 章)维护最小频次?每次调整是 O(log n),而且相同频次还要再比时间,做不到全 O(1)。正解是按频次分桶(frequency buckets)。

} @@ -1727,12 +1688,8 @@ class LRUCache {

三份状态:① key → (value, freq) 哈希表;②{" "} freq → 桶 哈希表,每个桶按时间序存该频次的所有 key - (桶内天然是个小 LRU);③ 一个 minFreq 变量记录当前最小频次。 - 访问某 key = 把它从 freq 桶搬进 freq+1 桶(两次 O(1) 链表操作); - 淘汰 = 移除 minFreq 桶里最老的 key,也就是「频次最低者中最久未用的那个」。 - minFreq 同样不需要搜索:只有两种时刻它会变 —— - 旧桶被搬空时 +1(刚搬走的 key 正是 minFreq 桶里最后一个), - 插入新 key 时归 1(新 key 频次必为 1,不可能更小)。 + (桶内天然是个小 LRU);③ 一个 minFreq 变量记录当前最小频次。访问某 key = 把它从 freq 桶搬进 freq+1 桶(两次 O(1) 链表操作);淘汰 = 移除 minFreq 桶里最老的 key,也就是「频次最低者中最久未用的那个」。minFreq 同样不需要搜索:只有两种时刻它会变 —— + 旧桶被搬空时 +1(刚搬走的 key 正是 minFreq 桶里最后一个),插入新 key 时归 1(新 key 频次必为 1,不可能更小)。

} /> @@ -1846,8 +1803,7 @@ class LRUCache { zh: ( <> LinkedHashSet = 哈希表 + 双向链表(又是这对组合), - iterator().next() 拿到的就是桶里最老的 key。 - 高亮的两处是全代码中唯二会改动 minFreq 的地方。 + iterator().next() 拿到的就是桶里最老的 key。高亮的两处是全代码中唯二会改动 minFreq 的地方。 ), }, @@ -1941,8 +1897,7 @@ class LFUCache: ), zh: ( <> - popitem(last=False) 从 OrderedDict 头部弹出, - 正是桶里最老的 key。整份代码没有一处循环 —— 这就是全 O(1) 的直接证据。 + popitem(last=False) 从 OrderedDict 头部弹出,正是桶里最老的 key。整份代码没有一处循环 —— 这就是全 O(1) 的直接证据。 ), }, @@ -2048,8 +2003,7 @@ class LFUCache: ), zh: ( <> - JS 的 Set / Map 都记住插入顺序, - 所以 Set 直接就能当「按时间排序的桶」用, + JS 的 Set / Map 都记住插入顺序,所以 Set 直接就能当「按时间排序的桶」用, values().next().value 拿到的就是最老的成员。 ), @@ -2081,12 +2035,7 @@ class LFUCache: } zh={

- LFU 的软肋:旧热点退役慢 —— 一条昨天被读了几万次、 - 今天再没人碰的数据,频次依然很高,新数据要很久才能把它挤出去 - (工程上用「频次随时间衰减」来修,Redis 的 LFU 策略就带衰减因子)。 - LRU 的软肋:怕一次全量扫描 —— 一次全表遍历把每行都读一遍, - 会把真正的热数据全部冲出缓存。所以 Redis 两种策略都提供, - 按业务的访问模式选。 + LFU 的软肋:旧热点退役慢 —— 一条昨天被读了几万次、今天再没人碰的数据,频次依然很高,新数据要很久才能把它挤出去(工程上用「频次随时间衰减」来修,Redis 的 LFU 策略就带衰减因子)。LRU 的软肋:怕一次全量扫描 —— 一次全表遍历把每行都读一遍,会把真正的热数据全部冲出缓存。所以 Redis 两种策略都提供,按业务的访问模式选。

} /> @@ -2125,10 +2074,7 @@ class LFUCache: zh={

换一类需求。给一个数组,反复问「下标 l 到 r 的 - 区间和是多少」——前缀和就能解决: - 先算 pre[i] = a[0] + … + a[i−1],区间和 = pre[r+1] − pre[l], - 预处理一遍,每次查询 O(1)。 - 但加一个条件:数组元素还会被修改。改一个{" "} + 区间和是多少」——前缀和就能解决:先算 pre[i] = a[0] + … + a[i−1],区间和 = pre[r+1] − pre[l],预处理一遍,每次查询 O(1)。但加一个条件:数组元素还会被修改。改一个{" "} a[i],它后面的所有前缀和全部作废,重建要 O(n) —— 改 10 万次就是 10 万次重建,前缀和不再可用。

@@ -2182,11 +2128,8 @@ class LFUCache: } zh={

- 两个极端之间,需要一个「改和查都不太差」的方案。做法是把整个区间对半劈开, - 一直劈到每段只剩一个元素,于是得到一棵二叉树(第 7 章), - 每个节点存自己那段区间的和。 - 这样「和的信息」被分摊到 O(n) 个节点上,任何一次修改或查询, - 都只需要动其中 O(log n) 个。 + 两个极端之间,需要一个「改和查都不太差」的方案。做法是把整个区间对半劈开,一直劈到每段只剩一个元素,于是得到一棵二叉树(第 7 章), + 每个节点存自己那段区间的和。这样「和的信息」被分摊到 O(n) 个节点上,任何一次修改或查询,都只需要动其中 O(log n) 个。

} /> @@ -2216,9 +2159,7 @@ class LFUCache: } zh={ <> - 要改 a[i]:从根一路二分下潜找到那片叶子并改掉, - 回溯时把路径上每个祖先的和重算一遍(= 左孩子 + 右孩子)。 - 被动到的节点数 = 树高 = O(log n);其余节点存的和依然正确 —— + 要改 a[i]:从根一路二分下潜找到那片叶子并改掉,回溯时把路径上每个祖先的和重算一遍(= 左孩子 + 右孩子)。被动到的节点数 = 树高 = O(log n);其余节点存的和依然正确 —— 这正是它比前缀和强的地方。 } @@ -2245,8 +2186,7 @@ class LFUCache: <> 问 [l,r] 的和,每个节点只有三种处境:① 完全不相交 → 返回 0; ② 整段落在 [l,r] 内 → 直接返回存好的和,不再下探; - ③ 部分相交 → 劈开问两个孩子。每层最多有 2 个节点落到情况 ③, - 所以总访问量是 O(log n)。 + ③ 部分相交 → 劈开问两个孩子。每层最多有 2 个节点落到情况 ③,所以总访问量是 O(log n)。 } /> @@ -2265,8 +2205,7 @@ class LFUCache: } zh={

- 亲手试一遍:改值模式点一个叶子,看一条「从叶到根」的更新路径; - 查询模式圈定一个区间,看哪些节点被整段命中 —— + 亲手试一遍:改值模式点一个叶子,看一条「从叶到根」的更新路径;查询模式圈定一个区间,看哪些节点被整段命中 —— 绿色节点直接交出存好的和,一次都不用下探到叶子。

} @@ -2296,11 +2235,8 @@ class LFUCache: zh={

树直接存在一个数组里:tree[1] 是根,节点 i 的孩子是 2i 和 2i+1 —— - 和第 9 章的堆同款存法,不用真的创建节点对象。数组开 4n。 - 为什么是 4n 而不是 2n:如果 n 是 2 的幂,这棵树是满的, - n 个叶子 + n−1 个内部节点,用到的最大下标不超过 2n; - 但 n 不是 2 的幂时,最底层不满,递归可能把叶子放到再深一层的位置上。 - 最坏情况下用到的最大下标小于 4n,所以开 4n 永远安全,也不用分情况讨论。 + 和第 9 章的堆同款存法,不用真的创建节点对象。数组开 4n。为什么是 4n 而不是 2n:如果 n 是 2 的幂,这棵树是满的, + n 个叶子 + n−1 个内部节点,用到的最大下标不超过 2n;但 n 不是 2 的幂时,最底层不满,递归可能把叶子放到再深一层的位置上。最坏情况下用到的最大下标小于 4n,所以开 4n 永远安全,也不用分情况讨论。

} /> @@ -2419,8 +2355,7 @@ class LFUCache: ), zh: ( <> - 这三行就是查询的全部:不相交、全包住、部分相交。 - 任何线段树题都是这个骨架。 + 这三行就是查询的全部:不相交、全包住、部分相交。任何线段树题都是这个骨架。 ), }, @@ -2665,13 +2600,8 @@ class LFUCache: zh={

把代码里的 + 换成 Math.max,同一棵树就能回答 - 区间最值查询 —— 任何满足结合律的操作(和 / 最值 / GCD / 矩阵乘) - 都能挂上去,这来自树结构本身的通用性。第二个延伸是 - 懒标记(lazy propagation):「把 [l,r] 里每个元素都 +5」 - 这类批量修改,先把标记贴在覆盖该区间的大节点上, - 等后面的操作真的要用到孩子时才下推。没有懒标记时, - 区间修改等于对每个元素做一次单点修改,是 O(n log n); - 有了懒标记,区间修改降到 O(log n)。竞赛常用,面试少见。 + 区间最值查询 —— 任何满足结合律的操作(和 / 最值 / GCD / 矩阵乘)都能挂上去,这来自树结构本身的通用性。第二个延伸是 + 懒标记(lazy propagation):「把 [l,r] 里每个元素都 +5」这类批量修改,先把标记贴在覆盖该区间的大节点上,等后面的操作真的要用到孩子时才下推。没有懒标记时,区间修改等于对每个元素做一次单点修改,是 O(n log n);有了懒标记,区间修改降到 O(log n)。竞赛常用,面试少见。

} /> @@ -2730,18 +2660,11 @@ class LFUCache:

线段树好用,但要几十行。如果需求只是 单点修改 + 前缀和查询,有一个小得多的结构: - 树状数组(Binary Indexed Tree,又叫 Fenwick Tree)。 - 它只保留一个数组 tree[1..n],规则一句话: + 树状数组(Binary Indexed Tree,又叫 Fenwick Tree)。它只保留一个数组 tree[1..n],规则一句话: tree[i] 存的是「以 i 结尾、长度为 lowbit(i)」那一段的和。

- lowbit(i) = i 的二进制里最低位那个 1 所代表的值。 - 求它只要一个位运算:lowbit(x) = x & (-x)。 - 为什么成立:补码里 -x = ~x + 1。 - 取反把最低位的 1 变成 0、其后各位全变 1; - 再 +1 时进位穿过这些位,恰好停在原来那个 1 的位置。 - 于是在这一位之上,x 与 -x 各位互反,按位与为 0;这一位之下两者都是 0;只有这一位两者都是 1,按位与就只剩这一位。 - 拿 6 验算:6 = 0110,-6 = 1010,0110 & 1010 = 0010 = 2。 + lowbit(i) = i 的二进制里最低位那个 1 所代表的值。求它只要一个位运算:lowbit(x) = x & (-x)。为什么成立:补码里 -x = ~x + 1。取反把最低位的 1 变成 0、其后各位全变 1;再 +1 时进位穿过这些位,恰好停在原来那个 1 的位置。于是在这一位之上,x 与 -x 各位互反,按位与为 0;这一位之下两者都是 0;只有这一位两者都是 1,按位与就只剩这一位。拿 6 验算:6 = 0110,-6 = 1010,0110 & 1010 = 0010 = 2。

} @@ -2841,11 +2764,9 @@ class LFUCache: zh={

看这张表里的规律: - i 的二进制末尾 0 越多,它管的那一段越长。 - 求前缀和 a[1..7] 时,7 = 0111 = 4+2+1,和恰好拆成 tree[7](1 个元素)+ + i 的二进制末尾 0 越多,它管的那一段越长。求前缀和 a[1..7] 时,7 = 0111 = 4+2+1,和恰好拆成 tree[7](1 个元素)+ tree[6](2 个)+ tree[4](4 个),三段首尾相接、互不重叠。 - i -= lowbit(i) 每次剥掉一个最低位的 1,正是在做这个二进制拆分, - 最多做 log n 次。修改则相反:i += lowbit(i){" "} + i -= lowbit(i) 每次剥掉一个最低位的 1,正是在做这个二进制拆分,最多做 log n 次。修改则相反:i += lowbit(i){" "} 跳到所有包含位置 i 的更大段,同样最多 log n 次。精讲 B 会逐帧走一遍这两条路径。

} @@ -2987,8 +2908,7 @@ class LFUCache: ), zh: ( <> - Python 的负数同样是补码语义,x & -x 照常工作; - 而且 Python 整数是无限精度的,不用担心溢出。 + Python 的负数同样是补码语义,x & -x 照常工作;而且 Python 整数是无限精度的,不用担心溢出。 ), }, @@ -3056,8 +2976,7 @@ class LFUCache: ), zh: ( <> - JS 的位运算按 32 位有符号整数进行,所以只要 n 不超过 2^31, - 下标运算就是正确的。注意这个限制针对的是下标,而不是数组里存的和。 + JS 的位运算按 32 位有符号整数进行,所以只要 n 不超过 2^31,下标运算就是正确的。注意这个限制针对的是下标,而不是数组里存的和。 ), }, @@ -3148,15 +3067,12 @@ class LFUCache: <>

第 3 章留下的限制:有序链表查找是 O(n) —— - 数据明明有序,却不能二分,因为二分需要 O(1) 随机访问,而链表没有 - (第 1 章)。只能一格一格 next,有序性被浪费掉了。 + 数据明明有序,却不能二分,因为二分需要 O(1) 随机访问,而链表没有(第 1 章)。只能一格一格 next,有序性被浪费掉了。

跳表的做法是在链表上面加几层「快线」: - 最底层 L0 是完整的有序链表,往上每一层只保留下一层大约一半的节点。 - 层数越高节点越少,一步跨得越远。查找从最顶层出发,规则只有一条: - 右邻还比目标小就向右走,否则下楼一层。 - 走到 L0 时,已经停在目标旁边了。 + 最底层 L0 是完整的有序链表,往上每一层只保留下一层大约一半的节点。层数越高节点越少,一步跨得越远。查找从最顶层出发,规则只有一条: + 右邻还比目标小就向右走,否则下楼一层。走到 L0 时,已经停在目标旁边了。

} @@ -3181,12 +3097,8 @@ class LFUCache: } zh={

- 每层节点数大约是下层的一半,所以层数约 log₂n; - 在每一层通常只走一两步就下楼 —— 如果能在某一层走很多步, - 说明上一层本可以带你走得更远。因此查找的期望代价是 - O(log n)。n = 100 万时,普通有序链表平均要比较约 50 万次, - 跳表大约几十次 —— 和二分、平衡树同一量级, - 同时保留了链表「插删只改几根指针」的优点。 + 每层节点数大约是下层的一半,所以层数约 log₂n;在每一层通常只走一两步就下楼 —— 如果能在某一层走很多步,说明上一层本可以带你走得更远。因此查找的期望代价是 + O(log n)。n = 100 万时,普通有序链表平均要比较约 50 万次,跳表大约几十次 —— 和二分、平衡树同一量级,同时保留了链表「插删只改几根指针」的优点。

} /> @@ -3218,12 +3130,7 @@ class LFUCache: } zh={ <> - 「上层严格隔一抽一」看起来最理想,但一次插入就会破坏它: - 新节点挤进来,后面所有节点的位置全变,索引要 O(n) 重建。 - 跳表改成让每个新节点抛硬币决定高度: - 正面就再长一层,反面就停,所以每多长一层的概率是 1/2。 - 没人维护那个精确模式,但在期望意义上每层依然是下层的一半: - 单个节点的期望层数是 1 + 1/2 + 1/4 + … = 2, + 「上层严格隔一抽一」看起来最理想,但一次插入就会破坏它:新节点挤进来,后面所有节点的位置全变,索引要 O(n) 重建。跳表改成让每个新节点抛硬币决定高度:正面就再长一层,反面就停,所以每多长一层的概率是 1/2。没人维护那个精确模式,但在期望意义上每层依然是下层的一半:单个节点的期望层数是 1 + 1/2 + 1/4 + … = 2, n 个节点整体的期望高度约 log₂n。 } @@ -3254,10 +3161,7 @@ class LFUCache: } zh={ <> - 这一点很重要:O(log n) 的期望是对抛硬币的随机性取的, - 不是对输入数据取的。跳表没有「最坏输入」,因为结构完全不依赖数据。 - 运气极差的一串硬币确实会让它变慢,但那个概率小到可以忽略。 - 这和快速排序随机选轴、哈希函数打散 key(第 6 章)是同一种权衡: + 这一点很重要:O(log n) 的期望是对抛硬币的随机性取的,不是对输入数据取的。跳表没有「最坏输入」,因为结构完全不依赖数据。运气极差的一串硬币确实会让它变慢,但那个概率小到可以忽略。这和快速排序随机选轴、哈希函数打散 key(第 6 章)是同一种权衡: 用随机性换掉昂贵的确定性维护。 } @@ -3294,12 +3198,8 @@ class LFUCache: zh={

两者的查 / 插 / 删都是 O(log n)。Redis 作者 Salvatore Sanfilippo - 给过三个理由:① 实现简单一个量级 —— 红黑树插入、删除合起来有十几种旋转和变色 - 的情况,跳表插入就是「普通链表插入 × 层数」;② 范围操作天然顺滑 —— - ZRANGE 取的是排名区间,跳表定位到起点后沿 L0 一路往前走即可, - 而树要反复做中序遍历;③ 更容易改造(Redis 在跳表节点上加了 span 字段做排名)。 - LevelDB / RocksDB 的内存写缓冲(MemTable)也用跳表, - 还因为它对无锁并发友好:改几根指针比旋转整棵树更容易做成原子操作。 + 给过三个理由:① 实现简单一个量级 —— 红黑树插入、删除合起来有十几种旋转和变色的情况,跳表插入就是「普通链表插入 × 层数」;② 范围操作天然顺滑 —— + ZRANGE 取的是排名区间,跳表定位到起点后沿 L0 一路往前走即可,而树要反复做中序遍历;③ 更容易改造(Redis 在跳表节点上加了 span 字段做排名)。LevelDB / RocksDB 的内存写缓冲(MemTable)也用跳表,还因为它对无锁并发友好:改几根指针比旋转整棵树更容易做成原子操作。

} /> @@ -3320,11 +3220,8 @@ class LFUCache: } zh={

- 实现思路(LC 1206 原题):每个节点带一个 next[] 指针数组, - 第 i 格 = 它在第 i 层的后继。三个操作共用同一段导航逻辑 —— - 从顶层开始,每层在「右邻还比目标小」时向右走, - 并把每层最后停留的节点记进 update[]; - 插入和删除就是在这些记录点之后做普通的链表指针操作。 + 实现思路(LC 1206 原题):每个节点带一个 next[] 指针数组,第 i 格 = 它在第 i 层的后继。三个操作共用同一段导航逻辑 —— + 从顶层开始,每层在「右邻还比目标小」时向右走,并把每层最后停留的节点记进 update[];插入和删除就是在这些记录点之后做普通的链表指针操作。

} /> @@ -3475,8 +3372,7 @@ class LFUCache: ), zh: ( <> - search / add / erase 的前半段是同一段代码:从顶层往下, - 每层尽量向右走。看懂一个就看懂了全部三个。 + search / add / erase 的前半段是同一段代码:从顶层往下,每层尽量向右走。看懂一个就看懂了全部三个。 ), }, @@ -3614,8 +3510,7 @@ class Skiplist: zh: ( <> update = [self.head] * MAX_LEVEL 存的是同一个 head - 的多个引用 —— 这里没问题:这些格子本来就都应指向 head, - 共享同一个对象正是想要的效果(与需要独立对象的 [[]] * n 不同)。 + 的多个引用 —— 这里没问题:这些格子本来就都应指向 head,共享同一个对象正是想要的效果(与需要独立对象的 [[]] * n 不同)。 ), }, @@ -3787,9 +3682,7 @@ class Skiplist {

跳表出自 William Pugh 1990 年的论文,标题就是结论: Skip Lists: A Probabilistic Alternative to Balanced Trees - (跳表:平衡树的概率替代品)。论文的论点是:平衡树很难写对, - 而一个更简单的随机化结构能给出同样的期望性能。 - 三十多年后 Redis、LevelDB 都在用跳表,算是对这个论点的支持。 + (跳表:平衡树的概率替代品)。论文的论点是:平衡树很难写对,而一个更简单的随机化结构能给出同样的期望性能。三十多年后 Redis、LevelDB 都在用跳表,算是对这个论点的支持。

} /> @@ -3840,16 +3733,13 @@ class Skiplist {

最后一台机器回答一个非常朴素的问题: 这个东西我见过吗? - 爬虫要判断某个 URL 是否抓过 —— 100 亿个 URL,每个平均 60 字节, - 用哈希集合(第 6 章)存需要约 600 GB,还没算每条记录的额外开销。存不下。 + 爬虫要判断某个 URL 是否抓过 —— 100 亿个 URL,每个平均 60 字节,用哈希集合(第 6 章)存需要约 600 GB,还没算每条记录的额外开销。存不下。

布隆过滤器(Bloom filter)的做法是 - 根本不存数据本身,只记录哈希位置: - 一个 m 位的位数组(bit array)加 k 个不同的哈希函数。 + 根本不存数据本身,只记录哈希位置:一个 m 位的位数组(bit array)加 k 个不同的哈希函数。 - 注意它做不到什么:布隆过滤器取不回存进去的值, - 也无法确定地告诉你某个元素在里面。它不是「更快的集合」。 + 注意它做不到什么:布隆过滤器取不回存进去的值,也无法确定地告诉你某个元素在里面。它不是「更快的集合」。

@@ -3873,8 +3763,7 @@ class Skiplist { } zh={ <> - k 个哈希函数算出 k 个位置,把这些位全部置 1。 - x 本身不存。一个元素最多只占 k 个比特,而且这些位是所有元素共享的。 + k 个哈希函数算出 k 个位置,把这些位全部置 1。x 本身不存。一个元素最多只占 k 个比特,而且这些位是所有元素共享的。 } /> @@ -3927,9 +3816,7 @@ class Skiplist {

注意这个不对称:回答只有「一定不在」和 「可能在」两种。原因是 - 位只会从 0 变 1,永远不会被清零: - 别的元素可能顺手点亮你的位,这就产生假阳性; - 但没有任何操作会把已点亮的位熄灭,所以 + 位只会从 0 变 1,永远不会被清零:别的元素可能顺手点亮你的位,这就产生假阳性;但没有任何操作会把已点亮的位熄灭,所以 永远不会有假阴性。亲手制造一次假阳性:

} @@ -3961,15 +3848,10 @@ class Skiplist { } zh={

- 误判率不是固定的,它取决于三个量:位数组大小 m、哈希函数个数 k, - 以及实际插入的元素个数 n。两条定性规律: - 相对元素数而言位数组越大(m/n 越大),误判率越低, - 因为位被填满得更慢; + 误判率不是固定的,它取决于三个量:位数组大小 m、哈希函数个数 k,以及实际插入的元素个数 n。两条定性规律: + 相对元素数而言位数组越大(m/n 越大),误判率越低,因为位被填满得更慢; 哈希函数个数 k 存在一个最优值 —— - 太少,每个元素留下的「指纹」太小,容易撞; - 太多,每个元素占的位太多,数组很快全亮,误判率反而升高。 - 工程上按目标误判率反推 m 和 k:比如每元素 10 个比特、k = 7, - 误判率约 1%。而哈希集合每个元素要几百比特,所以内存能省一到两个数量级。 + 太少,每个元素留下的「指纹」太小,容易撞;太多,每个元素占的位太多,数组很快全亮,误判率反而升高。工程上按目标误判率反推 m 和 k:比如每元素 10 个比特、k = 7,误判率约 1%。而哈希集合每个元素要几百比特,所以内存能省一到两个数量级。

} /> @@ -4006,12 +3888,9 @@ class Skiplist {

爬虫去重:100 亿 URL × 10 bit ≈ 12 GB,单机就装得下; 1% 的误判只意味着漏抓极少数新页面。 - 缓存穿透防护:大量请求查询数据库里根本不存在的 key, - 每次都穿过缓存直接打到数据库 —— - 把全量 key 装进布隆过滤器挡在缓存前面, - 被判定为「一定不在」的请求直接拒绝。 - 垃圾邮件 / 恶意网址名单:黑名单太大放不进内存, - 先用布隆过滤器判断值不值得做一次昂贵的精确校验。共同模式是: + 缓存穿透防护:大量请求查询数据库里根本不存在的 key,每次都穿过缓存直接打到数据库 —— + 把全量 key 装进布隆过滤器挡在缓存前面,被判定为「一定不在」的请求直接拒绝。 + 垃圾邮件 / 恶意网址名单:黑名单太大放不进内存,先用布隆过滤器判断值不值得做一次昂贵的精确校验。共同模式是: 插入过的绝不会被误拒,少量被误放行的再交给慢的精确查询复核。

} @@ -4042,12 +3921,8 @@ class Skiplist { zh={

① 标准布隆过滤器不支持删除。 - 一个位可能被多个元素共享,把它清零等于把别的元素也从过滤器里抹掉, - 会制造假阴性,破坏它唯一的那条保证。需要删除就用计数布隆过滤器 - (每个位置换成一个小计数器)或布谷鸟过滤器。 - ② 误判率会随插入量上涨。 - 按 1000 万条设计容量却塞进 1 亿条,位数组几乎全亮, - 任何查询都会得到「可能在」,过滤器就没用了 —— + 一个位可能被多个元素共享,把它清零等于把别的元素也从过滤器里抹掉,会制造假阴性,破坏它唯一的那条保证。需要删除就用计数布隆过滤器(每个位置换成一个小计数器)或布谷鸟过滤器。② 误判率会随插入量上涨。 + 按 1000 万条设计容量却塞进 1 亿条,位数组几乎全亮,任何查询都会得到「可能在」,过滤器就没用了 —— 事先估算元素数量是使用它的前提。

} @@ -4070,10 +3945,7 @@ class Skiplist { } zh={

- Burton Bloom 在 1970 年提出这个结构,当时内存以 KB 计, - 「牺牲一点点准确性换大量内存」是刚需。此后内存便宜了很多, - 但这个结构反而用得更多 —— 因为数据规模涨得比内存更快。 - Redis、HBase、Cassandra、Chrome 里都有它。 + Burton Bloom 在 1970 年提出这个结构,当时内存以 KB 计,「牺牲一点点准确性换大量内存」是刚需。此后内存便宜了很多,但这个结构反而用得更多 —— 因为数据规模涨得比内存更快。Redis、HBase、Cassandra、Chrome 里都有它。

} /> @@ -4129,10 +4001,8 @@ class Skiplist { zh={

题意:实现容量固定的 LRU 缓存,get / put 都是 O(1),满了淘汰最久未用的。 - 为什么这样拼:§02 已经完整推导过 —— - 哈希表 O(1) 回答「在哪」,双向链表回答「多旧」并支持 O(1) 摘除和插入, - 各自 O(n) 的那件事由对方来做;完整手写实现也在 §02。 - 这里先用官方样例把执行过程逐帧走一遍,再补一个面试省时间的快写版。 + 为什么这样拼:§02 已经完整推导过 —— + 哈希表 O(1) 回答「在哪」,双向链表回答「多旧」并支持 O(1) 摘除和插入,各自 O(n) 的那件事由对方来做;完整手写实现也在 §02。这里先用官方样例把执行过程逐帧走一遍,再补一个面试省时间的快写版。

} /> @@ -4205,8 +4075,7 @@ class LRUCache extends LinkedHashMap { ), zh: ( <> - 面试时先问「能不能用标准库」。要求手写就写 §02 的完整版; - 允许用库就写这个,并主动讲出它内部的两个结构。 + 面试时先问「能不能用标准库」。要求手写就写 §02 的完整版;允许用库就写这个,并主动讲出它内部的两个结构。 ), }, @@ -4364,8 +4233,7 @@ class LRUCache: get / put 时间 O(1),空间 O(capacity)。高频追问: ①「为什么必须双向链表?」摘除需要前驱,见 §02 的方案 4; ②「节点里为什么要存 key?」淘汰尾节点时要用它删掉对应的哈希条目; - ③「多线程安全怎么做?」整体加一把锁最简单; - 更好的答案是分片、每片一把锁,或者像 Redis 那样用单线程处理命令来回避; + ③「多线程安全怎么做?」整体加一把锁最简单;更好的答案是分片、每片一把锁,或者像 Redis 那样用单线程处理命令来回避; ④「容量非常大怎么办?」改用采样的近似 LRU,省掉链表 —— Redis 的做法。

} @@ -4404,11 +4272,9 @@ class LRUCache: zh={

题意:update(i, val) 单点改值,sumRange(l, r) 查区间和,两者交替出现。 - 为什么这样拼:前缀和查 O(1) 但改 O(n),裸数组改 O(1) 但查 O(n) —— - 两个操作都频繁时,任一极端都无法满足要求,需要一个两边都 O(log n) 的结构, - 这正是 §04 和 §05 的主场。 - 逐帧:线段树的路径动画已在 §04 实验室里演示过, - 这里走一遍树状数组版,看 lowbit 怎么在 tree 数组上跳。 + 为什么这样拼:前缀和查 O(1) 但改 O(n),裸数组改 O(1) 但查 O(n) —— + 两个操作都频繁时,任一极端都无法满足要求,需要一个两边都 O(log n) 的结构,这正是 §04 和 §05 的主场。 + 逐帧:线段树的路径动画已在 §04 实验室里演示过,这里走一遍树状数组版,看 lowbit 怎么在 tree 数组上跳。

} /> @@ -4495,8 +4361,7 @@ class LRUCache: ), zh: ( <> - 易错点:update 给的是「新值」而不是「增量」, - 直接把 val 加进去是错的 —— 先算{" "} + 易错点:update 给的是「新值」而不是「增量」,直接把 val 加进去是错的 —— 先算{" "} delta = val − a[i],再把 delta 加上去。 ), @@ -4566,8 +4431,7 @@ class LRUCache: ), zh: ( <> - 建树还有一种 O(n) 的写法(先算前缀和再相减), - 但做题时用逐个 add 的 O(n log n) 已经够了。 + 建树还有一种 O(n) 的写法(先算前缀和再相减),但做题时用逐个 add 的 O(n log n) 已经够了。 ), }, @@ -4663,12 +4527,9 @@ class LRUCache: } zh={

- 两个版本的 update / query 都是 O(log n); - 树状数组占 n+1 空间,线段树占 4n。追问: - ①「什么时候必须用线段树?」区间最值、区间修改, - 或任何「结果无法用两个前缀相减还原」的合并; - ②「二维怎么办?」LC 304 不可变,用二维前缀和; - 可变就用二维树状数组,两重 lowbit 循环; + 两个版本的 update / query 都是 O(log n);树状数组占 n+1 空间,线段树占 4n。追问: + ①「什么时候必须用线段树?」区间最值、区间修改,或任何「结果无法用两个前缀相减还原」的合并; + ②「二维怎么办?」LC 304 不可变,用二维前缀和;可变就用二维树状数组,两重 lowbit 循环; ③「为什么 update 要先算 delta?」因为树的原语是「加」而不是「赋值」—— 每个格子存的是一段的和,不能直接用某个元素的新值覆盖。

@@ -4720,15 +4581,10 @@ class LRUCache: zh={

题意:设计一个集合,insert / remove / getRandom(等概率随机返回一个成员) - 全部 O(1)。哈希那一章可能见过它,这次用 §01 的组合方法重新推一遍: - 列出操作 → 找出单一结构在哪超预算 → 补一个结构专门做那件事。 - 排除:只用哈希集合,insert / remove 是 O(1),但 getRandom 不行 —— - 桶数组里布满空桶,随机探桶可能连续踩空,做不到 O(1) 的等概率抽样。 - 只用数组,getRandom 完美(随机下标),但 remove 要先找到值(O(n)), - 再把洞补上(又 O(n))。 - 组合:数组存值,负责随机;哈希表存 值 → 下标,负责定位。 - 还剩一个问题:数组中间删除要搬移元素。 - 解法正是第 6 章 LC 380 题解里的办法 —— 先和末尾元素交换,再删末尾。 + 全部 O(1)。哈希那一章可能见过它,这次用 §01 的组合方法重新推一遍:列出操作 → 找出单一结构在哪超预算 → 补一个结构专门做那件事。 + 排除:只用哈希集合,insert / remove 是 O(1),但 getRandom 不行 —— + 桶数组里布满空桶,随机探桶可能连续踩空,做不到 O(1) 的等概率抽样。只用数组,getRandom 完美(随机下标),但 remove 要先找到值(O(n)),再把洞补上(又 O(n))。 + 组合:数组存值,负责随机;哈希表存 值 → 下标,负责定位。还剩一个问题:数组中间删除要搬移元素。解法正是第 6 章 LC 380 题解里的办法 —— 先和末尾元素交换,再删末尾。

} /> @@ -4814,8 +4670,7 @@ class LRUCache: <> 易错点:idx.put(last, i) 必须写在{" "} idx.remove(val) 之前。如果被删的恰好是末尾元素, - last 就等于 val,顺序反了会把刚删掉的条目又加回来。 - 这里的顺序在两种情况下都正确。 + last 就等于 val,顺序反了会把刚删掉的条目又加回来。这里的顺序在两种情况下都正确。 ), }, @@ -4967,8 +4822,7 @@ class RandomizedSet: ), zh: ( <> - 核心就是三行:把末尾元素补到洞里、更新哈希表、尾删。 - 很多需要「从无序集合中 O(1) 删除」的题目都用这个办法。 + 核心就是三行:把末尾元素补到洞里、更新哈希表、尾删。很多需要「从无序集合中 O(1) 删除」的题目都用这个办法。 ), }, @@ -5002,13 +4856,7 @@ class RandomizedSet: zh={

三个操作全是 O(1)(insert 是均摊),空间 O(n)。追问: - ①「允许重复元素呢?」那是 LC 381:哈希表的 value 改成「下标集合」, - 交换时要小心两个值相等的情况;难度明显更高,值得一做。 - ②「为什么哈希表单独做不了 getRandom?」 - 桶数组里有空槽,等概率抽样要么扫描 O(容量) 个桶, - 要么用拒绝采样、尝试次数没有上界。 - ③「怎么证明 getRandom 是等概率的?」数组没有空洞, - 每个下标被选中的概率恰好是 1/size。注意这道题和 LRU 的共同点: + ①「允许重复元素呢?」那是 LC 381:哈希表的 value 改成「下标集合」,交换时要小心两个值相等的情况;难度明显更高,值得一做。②「为什么哈希表单独做不了 getRandom?」桶数组里有空槽,等概率抽样要么扫描 O(容量) 个桶,要么用拒绝采样、尝试次数没有上界。③「怎么证明 getRandom 是等概率的?」数组没有空洞,每个下标被选中的概率恰好是 1/size。注意这道题和 LRU 的共同点: 组合里的每个成员各提供一个 O(1) 操作,合起来覆盖题目要求的全部操作。

} @@ -5072,8 +4920,7 @@ class RandomizedSet: zh: ( <> 组合设计的方法:先列出全部操作和每个操作的复杂度预算,再挑能互相补位的基础结构 - —— 每个成员只做自己 O(1)/O(log n) 的操作, - 两者通过「互存引用 + 同一步更新所有成员」连接起来。 + —— 每个成员只做自己 O(1)/O(log n) 的操作,两者通过「互存引用 + 同一步更新所有成员」连接起来。 ), }, @@ -5093,9 +4940,7 @@ class RandomizedSet: zh: ( <> LRU = 哈希表(回答「在哪」)+ 双向链表(回答「多旧」),get/put 全 O(1)。 - 必须双向:摘除节点要改前驱的 next,而单链表的节点拿不到前驱; - 节点里要存 key,淘汰时才能删掉对应的哈希条目。 - Java 的 LinkedHashMap 配 accessOrder = true 就是同一台机器。 + 必须双向:摘除节点要改前驱的 next,而单链表的节点拿不到前驱;节点里要存 key,淘汰时才能删掉对应的哈希条目。Java 的 LinkedHashMap 配 accessOrder = true 就是同一台机器。 ), }, @@ -5110,9 +4955,7 @@ class RandomizedSet: ), zh: ( <> - LFU 比 LRU 难,因为频次每访问一次就变。做到 O(1) 需要三样东西: - 频次哈希表、每个频次一条按时间排序的链表、以及一个 minFreq 变量。 - 淘汰规则是:频次最低者中最久未用的那个。 + LFU 比 LRU 难,因为频次每访问一次就变。做到 O(1) 需要三样东西:频次哈希表、每个频次一条按时间排序的链表、以及一个 minFreq 变量。淘汰规则是:频次最低者中最久未用的那个。 ), }, @@ -5137,13 +4980,11 @@ class RandomizedSet: <> 区间统计三种情况: - 只查不改 → 前缀和,查询 O(1);又改又查 → 线段树或树状数组, - 两者都是 O(log n) + 只查不改 → 前缀和,查询 O(1);又改又查 → 线段树或树状数组,两者都是 O(log n) 。线段树能挂任何满足结合律的合并,配懒标记后区间修改是 O(log n) 而不是 O(n log n)。树状数组约 25 行,靠{" "} - lowbit = x & (−x) 取出最低位的 1, - 但只适用于「答案能由两个前缀相减还原」的运算,而且必须 1-based。 + lowbit = x & (−x) 取出最低位的 1,但只适用于「答案能由两个前缀相减还原」的运算,而且必须 1-based。 ), }, @@ -5161,9 +5002,7 @@ class RandomizedSet: ), zh: ( <> - 跳表 = 有序链表 + 抛硬币长出来的多层索引:期望 O(log n), - 而且期望是对抛硬币取的、与输入无关,所以没有「最坏输入」。 - 用随机化替掉平衡树的旋转维护 —— + 跳表 = 有序链表 + 抛硬币长出来的多层索引:期望 O(log n),而且期望是对抛硬币取的、与输入无关,所以没有「最坏输入」。用随机化替掉平衡树的旋转维护 —— Redis zset(跳表 + 哈希表)和 LevelDB MemTable 的骨架。 ), @@ -5185,9 +5024,7 @@ class RandomizedSet: zh: ( <> 布隆过滤器 = 位数组 + k 个哈希函数: - 说「不在」是确定的,说「在」只是可能,因为位只会从 0 变 1。 - 普通布隆过滤器不能删除;误判率取决于位数组大小、哈希函数个数、 - 以及实际插入的元素个数。它是一道前置过滤门,不是更快的集合。 + 说「不在」是确定的,说「在」只是可能,因为位只会从 0 变 1。普通布隆过滤器不能删除;误判率取决于位数组大小、哈希函数个数、以及实际插入的元素个数。它是一道前置过滤门,不是更快的集合。 ), }, @@ -5210,8 +5047,7 @@ class RandomizedSet: 这六台机器没有用到任何新的基础结构 —— 数组、链表、哈希表、树、位运算全部来自前 12 章。 - 面试设计题的做法:先复述操作需求和复杂度目标,再报出结构组合, - 最后主动指出两个结构之间必须同步的地方 + 面试设计题的做法:先复述操作需求和复杂度目标,再报出结构组合,最后主动指出两个结构之间必须同步的地方 。 diff --git a/app/advanced/viz.tsx b/app/advanced/viz.tsx index 0f5c73b..ebb5161 100644 --- a/app/advanced/viz.tsx +++ b/app/advanced/viz.tsx @@ -184,8 +184,7 @@ export function LRUAnatomy() { } zh={ <> - 哈希表存的不是值,而是链表节点的引用:查找交给哈希(不用遍历链表), - 顺序交给链表(不用扫描哈希)—— 两个结构各自只负责自己那部分 O(1) 的工作。 + 哈希表存的不是值,而是链表节点的引用:查找交给哈希(不用遍历链表),顺序交给链表(不用扫描哈希)—— 两个结构各自只负责自己那部分 O(1) 的工作。 } /> @@ -251,8 +250,7 @@ export function LRULab() { } zh={ <> - put({k},{v}):哈希表里已有 {k} → O(1) 拿到节点引用,原地改值, - 再把节点搬到头部(它刚被用过,变成最新)。 + put({k},{v}):哈希表里已有 {k} → O(1) 拿到节点引用,原地改值,再把节点搬到头部(它刚被用过,变成最新)。 } />, @@ -301,8 +299,7 @@ export function LRULab() { } zh={ <> - 新节点 {k}:{v} 挂到链表头部(最新),哈希表写入 {k} → 节点引用。 - 整个 put 没有出现任何一次 O(n) 扫描。 + 新节点 {k}:{v} 挂到链表头部(最新),哈希表写入 {k} → 节点引用。整个 put 没有出现任何一次 O(n) 扫描。 } />, @@ -330,8 +327,7 @@ export function LRULab() { } zh={ <> - get({k}) = -1:哈希表 O(1) 查无此 key —— 链表碰都不用碰。 - (它可能从未 put 过,也可能已经被淘汰了。) + get({k}) = -1:哈希表 O(1) 查无此 key —— 链表碰都不用碰。(它可能从未 put 过,也可能已经被淘汰了。) } />, @@ -581,8 +577,7 @@ export function LFUBuckets() { } zh={ <> - 每个桶是一条按时间排序的链表(桶内就是一个小 LRU);再配两张哈希表 - (key → 值和频次、freq → 桶)和一个 minFreq 变量 —— 访问 = 从 freq 桶搬进 + 每个桶是一条按时间排序的链表(桶内就是一个小 LRU);再配两张哈希表(key → 值和频次、freq → 桶)和一个 minFreq 变量 —— 访问 = 从 freq 桶搬进 freq+1 桶,淘汰 = 移除 minFreq 桶里最老的。每一步都是 O(1)。 } @@ -709,10 +704,7 @@ export function SegAnatomy() { } zh={ <> - 根节点 = 整个数组的和(24);每往下一层,区间对半分;叶子 = 单个元素。 - [0,2] 这种奇数长度的区间就让左边多分一个:mid = (0+2)/2 = 1 → 左孩子 [0,1]、 - 右孩子 [2,2]。这棵树共 ⌈log₂6⌉ + 1 = 4 层,按边数算树高是 3, - 所有操作都只沿着一条自顶向下的路径走。 + 根节点 = 整个数组的和(24);每往下一层,区间对半分;叶子 = 单个元素。[0,2] 这种奇数长度的区间就让左边多分一个:mid = (0+2)/2 = 1 → 左孩子 [0,1]、右孩子 [2,2]。这棵树共 ⌈log₂6⌉ + 1 = 4 层,按边数算树高是 3,所有操作都只沿着一条自顶向下的路径走。 } /> @@ -932,8 +924,7 @@ export function SegLab() { } zh={ <> - sum({l},{r}) = {sum}:{pack.length} 个「整段被包住」的节点(绿色)直接给出答案, - 黄色节点只是路过时被劈开 —— 访问节点数 O(log n),而不是把 {r - l + 1} 个叶子逐个相加。 + sum({l},{r}) = {sum}:{pack.length} 个「整段被包住」的节点(绿色)直接给出答案,黄色节点只是路过时被劈开 —— 访问节点数 O(log n),而不是把 {r - l + 1} 个叶子逐个相加。 } />, @@ -1293,8 +1284,7 @@ const SKIP_FRAMES: SkipFrame[] = [ } zh={ <> - L2 上 19 的右邻是 ∞ > 23 —— 会走过头,于是原地下楼到 L1。 - 下一层节点更密,能走得更细。 + L2 上 19 的右邻是 ∞ > 23 —— 会走过头,于是原地下楼到 L1。下一层节点更密,能走得更细。 } /> @@ -1348,8 +1338,7 @@ const SKIP_FRAMES: SkipFrame[] = [ } zh={ <> - L0 上 19 的右邻是 23 = 23,找到了。全程只做了 4 次比较; - 普通有序链表要从 3 开始一格格比。n 越大差距越大: + L0 上 19 的右邻是 23 = 23,找到了。全程只做了 4 次比较;普通有序链表要从 3 开始一格格比。n 越大差距越大: O(log n) vs O(n)。 } @@ -1670,8 +1659,7 @@ export function BloomLab() { } zh={ <> - 位 {zero} 还是 0 → "{word}" 一定不在。这是确定的: - 如果它插入过,这一位必然已被置 1,而位从来不会被清零。 + 位 {zero} 还是 0 → "{word}" 一定不在。这是确定的:如果它插入过,这一位必然已被置 1,而位从来不会被清零。 } />, @@ -1688,8 +1676,7 @@ export function BloomLab() { } zh={ <> - 3 个位全是 1 → 报告「可能在」。这次它确实插入过(真阳性), - 但布隆过滤器自己分辨不出来,它只看位。 + 3 个位全是 1 → 报告「可能在」。这次它确实插入过(真阳性),但布隆过滤器自己分辨不出来,它只看位。 } />, @@ -1738,8 +1725,7 @@ export function BloomLab() { } zh={ <> - 在候选词表里暂时找不到假阳性 —— 位数组还太「空」。再插入一两个词 - (位越满,误判率越高),然后再点我。 + 在候选词表里暂时找不到假阳性 —— 位数组还太「空」。再插入一两个词(位越满,误判率越高),然后再点我。 } />, diff --git a/app/array/page.tsx b/app/array/page.tsx index 5f83551..bb04c27 100644 --- a/app/array/page.tsx +++ b/app/array/page.tsx @@ -47,8 +47,7 @@ const F283: ArrayFrame[] = [ } zh={ <> - 初始:slow 指向「下一个非零元素该放的位置」,fast 负责逐个读。 - 目标是把非零元素前移,零自然落到末尾。 + 初始:slow 指向「下一个非零元素该放的位置」,fast 负责逐个读。目标是把非零元素前移,零自然落到末尾。 } /> @@ -115,8 +114,7 @@ const F283: ArrayFrame[] = [ } zh={ <> - 交换完成,slow 前移到 1。fast=2 又遇到 0,跳过。 - 前缀 [1] 现在只含非零元素。 + 交换完成,slow 前移到 1。fast=2 又遇到 0,跳过。前缀 [1] 现在只含非零元素。 } /> @@ -215,8 +213,7 @@ const F11: ArrayFrame[] = [ } zh={ <> - L=0(高 1)、R=8(高 7):面积 = min(1,7) × 宽 8 = 8。 - 较矮的一边在左侧,所以 L 右移。 + L=0(高 1)、R=8(高 7):面积 = min(1,7) × 宽 8 = 8。较矮的一边在左侧,所以 L 右移。 } /> @@ -239,8 +236,7 @@ const F11: ArrayFrame[] = [ } zh={ <> - L=1(高 8)、R=8(高 7):面积 = min(8,7) × 7 = 49,当前最优。 - 这次较矮的一边在右侧,所以 R 左移。 + L=1(高 8)、R=8(高 7):面积 = min(8,7) × 7 = 49,当前最优。这次较矮的一边在右侧,所以 R 左移。 } /> @@ -332,10 +328,8 @@ const F11: ArrayFrame[] = [ } zh={ <> - L、R 已经相邻:比较完这最后一组,两者相遇,循环结束,答案是 49。 - 为什么可以跳过这么多组合?因为任何 - 仍然保留那条较矮线的组合,宽度更小、高度不会更高,面积不可能超过刚算过的值。 - 丢掉较矮的一端不会丢掉答案,这就是 O(n²) 降到 O(n) 的依据。 + L、R 已经相邻:比较完这最后一组,两者相遇,循环结束,答案是 49。为什么可以跳过这么多组合?因为任何 + 仍然保留那条较矮线的组合,宽度更小、高度不会更高,面积不可能超过刚算过的值。丢掉较矮的一端不会丢掉答案,这就是 O(n²) 降到 O(n) 的依据。 } /> @@ -464,8 +458,7 @@ const F209: ArrayFrame[] = [ } zh={ <> - 移出 3:sum = 7,仍然 ≥ 7,长度 3 成为新的最优解。 - 再收缩一次 sum = 6,停止。 + 移出 3:sum = 7,仍然 ≥ 7,长度 3 成为新的最优解。再收缩一次 sum = 6,停止。 } /> @@ -490,9 +483,7 @@ const F209: ArrayFrame[] = [ } zh={ <> - r=5 使 sum 变为 9。收缩一次移出 2,窗口变为 [4, 3],和为 7,长度 2 —— 最终答案; - 再收缩一次移出 4,和降到 7 以下。 - l 和 r 各自最多走 n 步,总步数不超过 2n,所以是 O(n) 而不是 O(n²)。 + r=5 使 sum 变为 9。收缩一次移出 2,窗口变为 [4, 3],和为 7,长度 2 —— 最终答案;再收缩一次移出 4,和降到 7 以下。l 和 r 各自最多走 n 步,总步数不超过 2n,所以是 O(n) 而不是 O(n²)。 } /> @@ -556,8 +547,7 @@ export default function ArrayChapter() { ), zh: ( <> - 内存里一排连续的格子,门牌号就是下标。它用「中间插删要搬动后面所有元素」的代价, - 换来了整个数据结构世界里最快的一件事:O(1) 随机访问。 + 内存里一排连续的格子,门牌号就是下标。它用「中间插删要搬动后面所有元素」的代价,换来了整个数据结构世界里最快的一件事:O(1) 随机访问。 ), }} @@ -598,8 +588,7 @@ export default function ArrayChapter() { zh={ <>

- 想象健身房门口那排储物柜:柜子一个挨一个、大小一致、 - 从 0 开始编号。你拿着 5 号钥匙,不需要从 0 号一路看过去 —— + 想象健身房门口那排储物柜:柜子一个挨一个、大小一致、从 0 开始编号。你拿着 5 号钥匙,不需要从 0 号一路看过去 —— 直接走到 5 号柜前开门。这就是数组被设计出来要做好的那件事: 给我下标,我立刻给你元素。

@@ -627,8 +616,7 @@ export default function ArrayChapter() { } zh={

- 所有元素在内存里一个挨一个,中间没有空隙。好处:任意位置都能用公式算出来; - 代价:中间插入或删除必须搬动其他元素。 + 所有元素在内存里一个挨一个,中间没有空隙。好处:任意位置都能用公式算出来;代价:中间插入或删除必须搬动其他元素。

} /> @@ -670,8 +658,7 @@ export default function ArrayChapter() { } zh={

- 建好后长度不可变 —— 紧挨着它的那块内存不一定是空的。想「变长」, - 只能整体搬到一块更大的内存里,这就是 §04 的动态数组。 + 建好后长度不可变 —— 紧挨着它的那块内存不一定是空的。想「变长」,只能整体搬到一块更大的内存里,这就是 §04 的动态数组。

} /> @@ -694,9 +681,7 @@ export default function ArrayChapter() { } zh={

- 你的照片是像素数组,这个网页上的文字是字符数组,数据库的一页记录也是一条接一条存放的。 - 数组是最贴近硬件的结构,也是后面哈希表、堆、动态数组的地基。 - 把这一章学扎实,后面几章会轻松很多。 + 你的照片是像素数组,这个网页上的文字是字符数组,数据库的一页记录也是一条接一条存放的。数组是最贴近硬件的结构,也是后面哈希表、堆、动态数组的地基。把这一章学扎实,后面几章会轻松很多。

} /> @@ -731,8 +716,7 @@ export default function ArrayChapter() { zh={

内存是一条编了门牌号的长街。数组向系统申请的是 - 一段连续的门牌号。假设一个 int 数组从地址 1000 开始、 - 每个 int 占 4 字节,那么第 i 个元素住在哪,不用找 —— 用算的: + 一段连续的门牌号。假设一个 int 数组从地址 1000 开始、每个 int 占 4 字节,那么第 i 个元素住在哪,不用找 —— 用算的:

} /> @@ -818,10 +802,8 @@ export default function ArrayChapter() { zh={

CPU 不是一个字节一个字节地读内存,而是一次搬一整块 —— - 这一块叫缓存行,通常 64 字节。数组的元素紧挨着,元素是 4 字节 int 时, - 读 arr[0] 会顺便把 arr[1..15]{" "} - 一起带进缓存,顺序遍历几乎全程命中。注意这是缓存效应,不是复杂度差异: - 遍历数组和遍历链表都是 O(n),但实际运行时数组常常快上几倍。 + 这一块叫缓存行,通常 64 字节。数组的元素紧挨着,元素是 4 字节 int 时,读 arr[0] 会顺便把 arr[1..15]{" "} + 一起带进缓存,顺序遍历几乎全程命中。注意这是缓存效应,不是复杂度差异:遍历数组和遍历链表都是 O(n),但实际运行时数组常常快上几倍。

} /> @@ -963,8 +945,7 @@ export default function ArrayChapter() { } zh={

- 表格里最重要的不是结论,是那列「为什么」。亲手做几次插入删除, - 数一数搬动了几次,你就不会再记错: + 表格里最重要的不是结论,是那列「为什么」。亲手做几次插入删除,数一数搬动了几次,你就不会再记错:

} /> @@ -1019,9 +1000,7 @@ export default function ArrayChapter() {

表里那行 O(log n) 的有序查找值得单独写一遍代码。 二分查找(binary search) - 的做法是反复把剩余区间砍掉一半:拿中间元素和目标比一次,就能丢掉一半。 - 想象猜数字游戏:1~100 之间,对方只回答「大了 / 小了」,每次都猜中间值, - 最多 7 次必中(2⁷ = 128 > 100)。一百万个元素只要 20 次,十亿个只要 30 次 + 的做法是反复把剩余区间砍掉一半:拿中间元素和目标比一次,就能丢掉一半。想象猜数字游戏:1~100 之间,对方只回答「大了 / 小了」,每次都猜中间值,最多 7 次必中(2⁷ = 128 > 100)。一百万个元素只要 20 次,十亿个只要 30 次 —— 这就是对数的意义。

} @@ -1068,8 +1047,7 @@ public int search(int[] nums, int target) { <> 易错点:Java 的 int 会溢出 —— 两个数都接近 2³¹ − 1 时,(left + right) / 2{" "} - 会变成负数。标准写法是 left + (right - left) / 2, - 两数之差一定放得下。 + 会变成负数。标准写法是 left + (right - left) / 2,两数之差一定放得下。 ), }, @@ -1163,9 +1141,7 @@ var search = function (nums, target) { zh: ( <> 细节:很多示例写 (left + right) >> 1。 - >> 会先把操作数转成 32 位有符号整数, - 只有在和小于 2³¹ 时才安全。JavaScript 的数字是双精度浮点, - 能精确表示 2⁵³ 以内的整数,远超任何数组长度,所以{" "} + >> 会先把操作数转成 32 位有符号整数,只有在和小于 2³¹ 时才安全。JavaScript 的数字是双精度浮点,能精确表示 2⁵³ 以内的整数,远超任何数组长度,所以{" "} Math.floor((left + right) / 2) 始终正确。 ), @@ -1202,17 +1178,13 @@ var search = function (nums, target) { } zh={

- 上面的代码用的是闭区间 [left, right], - 两个端点都还是候选。循环不变量是: - 如果 target 在数组里,它的下标一定落在 [left, right] 内。 - 每个分支都在维持这条:nums[mid] < target{" "} + 上面的代码用的是闭区间 [left, right],两个端点都还是候选。循环不变量是: + 如果 target 在数组里,它的下标一定落在 [left, right] 内。每个分支都在维持这条:nums[mid] < target{" "} 排除了 mid 及其左边,nums[mid] > target{" "} 排除了 mid 及其右边。由不变量可以推出三个细节:① 循环条件是{" "} left <= right,因为只剩一个元素的区间也必须检查; - ② 收缩必须写 mid + 1 或 mid - 1, - 把 mid 留在区间里可能死循环;③ 二分同时需要有序和 - O(1) 随机访问,所以链表上没法二分。 - 对应练习:LC 704(模板题)、LC 35(找不到时 left 停在哪)。 + ② 收缩必须写 mid + 1 或 mid - 1,把 mid 留在区间里可能死循环;③ 二分同时需要有序和 + O(1) 随机访问,所以链表上没法二分。对应练习:LC 704(模板题)、LC 35(找不到时 left 停在哪)。

} /> @@ -1253,10 +1225,8 @@ var search = function (nums, target) { zh={

普通数组定长,但我们天天在用「能一直 push 的数组」。它的做法很朴素: - 内部维护一个定长数组 + 一个记录已用多少的 size。 - 有空位就直接写进下一格(O(1));满了就申请一个 - 更大的数组(通常是原来的 1.5 到 2 倍), - 把旧元素全部拷贝过去,再继续。亲手触发一次扩容: + 内部维护一个定长数组 + 一个记录已用多少的 size。有空位就直接写进下一格(O(1));满了就申请一个 + 更大的数组(通常是原来的 1.5 到 2 倍),把旧元素全部拷贝过去,再继续。亲手触发一次扩容:

} /> @@ -1283,15 +1253,10 @@ var search = function (nums, target) { } zh={

- 一次扩容确实是实打实的 O(n),凭什么说尾部追加是 O(1)? - 别看单次,看总账:容量从 1 按倍增涨到 n,所有扩容的总拷贝量是 + 一次扩容确实是实打实的 O(n),凭什么说尾部追加是 O(1)?别看单次,看总账:容量从 1 按倍增涨到 n,所有扩容的总拷贝量是 1 + 2 + 4 + … + n/2,小于 n。也就是说, - n 次追加总共最多做约 2n 单位的工作, - 平均每次 2 个单位,是常数。这种记账方式叫 - 均摊分析(amortized analysis), - 上面实验室里的「均摊操作数」一直在替你验证它。这里的说法要准确: - 单次追加在最坏情况下不是 O(1),扩容那一次就是 O(n); - 它是均摊 O(1) —— 昂贵的那几次足够稀少,任意 n + n 次追加总共最多做约 2n 单位的工作,平均每次 2 个单位,是常数。这种记账方式叫 + 均摊分析(amortized analysis),上面实验室里的「均摊操作数」一直在替你验证它。这里的说法要准确:单次追加在最坏情况下不是 O(1),扩容那一次就是 O(n);它是均摊 O(1) —— 昂贵的那几次足够稀少,任意 n 次追加的总代价仍是 O(n)。只要扩容倍数大于 1 就成立,不必非得翻倍。

} @@ -1412,8 +1377,7 @@ var search = function (nums, target) {

常听到「动态数组都是翻倍扩容」,这是简化说法。Java 的{" "} ArrayList 大约按 1.5 倍增长;CPython 是按新长度的约 - 1/8 再加一个小常数来超额分配,倍数小得多,而且随规模变化。 - 它们真正的共同点是:增长量与当前规模成比例 —— + 1/8 再加一个小常数来超额分配,倍数小得多,而且随规模变化。它们真正的共同点是:增长量与当前规模成比例 —— 均摊 O(1) 的论证只需要这一条性质。

} @@ -1457,8 +1421,7 @@ var search = function (nums, target) {

读到这里,动态数组的三块零件你都认识了:一个定长数组、 一个记录已用多少的 size、 - 一段满了就扩容的逻辑。现在把它们拼起来。 - 下面的实现虽小但完整:支持读写、尾部追加、任意位置插入删除。 + 一段满了就扩容的逻辑。现在把它们拼起来。下面的实现虽小但完整:支持读写、尾部追加、任意位置插入删除。

建议做法:先盖住代码,自己写一遍 push 和{" "} @@ -1575,8 +1538,7 @@ public class DynArray { zh: ( <> 真实 ArrayList 的差异:按约 1.5 倍扩容、用{" "} - System.arraycopy(比 Java 层的 for 循环快)、 - 存的是 Object[]。骨架完全一样。 + System.arraycopy(比 Java 层的 for 循环快)、存的是 Object[]。骨架完全一样。 ), }, @@ -1686,8 +1648,7 @@ class DynArray: ), zh: ( <> - 真实 CPython list 的差异:每次超额分配约 1/8 再加一个小常数, - 底层是一个存对象指针的 C 数组。逻辑完全一致。 + 真实 CPython list 的差异:每次超额分配约 1/8 再加一个小常数,底层是一个存对象指针的 C 数组。逻辑完全一致。 ), }, @@ -1794,9 +1755,7 @@ class DynArray { ), zh: ( <> - JavaScript 的 Array 本身就会自动增长, - 这里刻意用「定长思维」来写,是为了看清引擎替你做了什么。 - V8 的底层存储大约按 1.5 倍 + 16 增长。 + JavaScript 的 Array 本身就会自动增长,这里刻意用「定长思维」来写,是为了看清引擎替你做了什么。V8 的底层存储大约按 1.5 倍 + 16 增长。 ), }, @@ -1822,8 +1781,7 @@ class DynArray {

合上代码回答三个问题:① insert 为什么从后往前搬? ② removeAt 为什么从前往后补? - ③ 如果扩容改成「每次只 +1 个格子」,连续 n 次追加的总代价是多少? - 第三问的答案是 1 + 2 + … + n = O(n²) —— 这正是容量必须按 + ③ 如果扩容改成「每次只 +1 个格子」,连续 n 次追加的总代价是多少?第三问的答案是 1 + 2 + … + n = O(n²) —— 这正是容量必须按 倍数增长、而不是按固定量增长的原因。

} @@ -1862,10 +1820,8 @@ class DynArray { zh={ <>

- 矩阵就是数组的数组:matrix[i][j] 表示第 i 行第 j 列。 - 内存里没有行列,矩阵必须铺成一条线。常见的铺法是 - 一行接一行,叫行优先(row-major), - 定位公式因此只是升了一个维度: + 矩阵就是数组的数组:matrix[i][j] 表示第 i 行第 j 列。内存里没有行列,矩阵必须铺成一条线。常见的铺法是 + 一行接一行,叫行优先(row-major),定位公式因此只是升了一个维度: 一维下标 = 行号 × 列数 + 列号。点下面的格子验证:

@@ -1898,13 +1854,8 @@ class DynArray { } zh={

- 在 C 语言和 NumPy 里,二维数组是一整块连续内存, - 上面那条公式就是编译器实际用的寻址方式。而 Java 的{" "} - int[][] 是一个存放各行引用的数组: - 每一行内部连续,但两行之间不一定相邻,各行长度甚至可以不同。 - Python 的嵌套 list、JavaScript 的嵌套 Array 也是同样的结构。 - 当你自己把矩阵压平成一维数组时(很多题目就是这么做的), - 这条公式描述的正是那种布局。 + 在 C 语言和 NumPy 里,二维数组是一整块连续内存,上面那条公式就是编译器实际用的寻址方式。而 Java 的{" "} + int[][] 是一个存放各行引用的数组:每一行内部连续,但两行之间不一定相邻,各行长度甚至可以不同。Python 的嵌套 list、JavaScript 的嵌套 Array 也是同样的结构。当你自己把矩阵压平成一维数组时(很多题目就是这么做的),这条公式描述的正是那种布局。

} /> @@ -1926,10 +1877,7 @@ class DynArray { } zh={

- 先行后列(for i → for j)读到的是内存里相邻的元素, - 绝大多数读取都命中缓存;先列后行则每一步跳过一整行, - 大矩阵下能慢好几倍。两者复杂度同为 O(mn),差别是缓存效应, - 不是复杂度差异(回到 §02 的缓存行)。 + 先行后列(for i → for j)读到的是内存里相邻的元素,绝大多数读取都命中缓存;先列后行则每一步跳过一整行,大矩阵下能慢好几倍。两者复杂度同为 O(mn),差别是缓存效应,不是复杂度差异(回到 §02 的缓存行)。

} /> @@ -1962,8 +1910,7 @@ class DynArray { dirs = [[-1,0],[1,0],[0,-1],[0,1]]{" "} 一个循环就能完成,不用写四段 if;② 先做边界检查( 0 ≤ i < m 且 0 ≤ j < n)再读格子; - ③ 想要 O(1) 额外空间,就用矩阵自身的第一行和第一列当标记(LC 73)。 - 矩阵同时也是「网格图」,图那一章会把它当图来遍历。 + ③ 想要 O(1) 额外空间,就用矩阵自身的第一行和第一列当标记(LC 73)。矩阵同时也是「网格图」,图那一章会把它当图来遍历。

} /> @@ -2002,13 +1949,10 @@ class DynArray { } zh={

- 三种语言里抽象是一致的:元素按下标排列、 - 按下标访问 O(1)、中间插删 O(n)。但 - 内存布局并不保证相同。Java 给你两个类型: - 定长的 int[] 和动态的 ArrayList; + 三种语言里抽象是一致的:元素按下标排列、按下标访问 O(1)、中间插删 O(n)。但 + 内存布局并不保证相同。Java 给你两个类型:定长的 int[] 和动态的 ArrayList; Python 只有动态的 list,里面存的是对象指针; - JavaScript 的 Array 本质是一个键为「类下标字符串」的对象, - 只要保持稠密,V8 就用连续的 packed 存储,一旦不稠密就换成字典表示。 + JavaScript 的 Array 本质是一个键为「类下标字符串」的对象,只要保持稠密,V8 就用连续的 packed 存储,一旦不稠密就换成字典表示。

} /> @@ -2100,9 +2044,7 @@ for v in arr: # 遍历 ), zh: ( <> - 易错点:list 存的是对象指针而不是裸数值,切片会复制。 - 真要定长数值数组请用 array 模块或 NumPy。 - 初始化二维数组不要写 [[0]*m]*n —— + 易错点:list 存的是对象指针而不是裸数值,切片会复制。真要定长数值数组请用 array 模块或 NumPy。初始化二维数组不要写 [[0]*m]*n —— 这样 n 行会共享同一个内层 list。 ), @@ -2147,10 +2089,8 @@ for (const v of arr) console.log(v); // 遍历`, zh: ( <> 易错点:让数组变稀疏(在短数组上写{" "} - arr[1000] = 1)会让引擎切换成字典表示,访问明显变慢; - 另外 sort() 默认把元素当字符串比较 ——{" "} - [10,9,1].sort() 得到 [1,10,9], - 记得传比较函数。 + arr[1000] = 1)会让引擎切换成字典表示,访问明显变慢;另外 sort() 默认把元素当字符串比较 ——{" "} + [10,9,1].sort() 得到 [1,10,9],记得传比较函数。 ), }, @@ -2280,10 +2220,8 @@ for (const v of arr) console.log(v); // 遍历`, } zh={ <> - * Java 的 subList 返回的是视图(view)而不是拷贝: - 创建视图是 O(1),复制成新列表(如{" "} - new ArrayList<>(list.subList(a, b)))才是 O(k)。 - 改视图会改到原 list,这是三种语言的切片语义里最特殊的一个。 + * Java 的 subList 返回的是视图(view)而不是拷贝:创建视图是 O(1),复制成新列表(如{" "} + new ArrayList<>(list.subList(a, b)))才是 O(k)。改视图会改到原 list,这是三种语言的切片语义里最特殊的一个。 } /> @@ -2324,9 +2262,7 @@ for (const v of arr) console.log(v); // 遍历`,

数组题的暴力解通常是两层循环 O(n²):枚举所有下标对。而 双指针家族的做法,是让两个下标 - 各自只朝一个方向走, - 每一步都用问题本身的性质排除掉一批候选,把 O(n²) 压成 O(n)。 - 常见的有三种形式: + 各自只朝一个方向走,每一步都用问题本身的性质排除掉一批候选,把 O(n²) 压成 O(n)。常见的有三种形式:

} /> @@ -2349,8 +2285,7 @@ for (const v of arr) console.log(v); // 遍历`, } zh={

- fast 负责读,slow 负责写,slow 左侧始终是已整理好的区域。 - 原地删除和压缩类题目的标准写法,见 LC 283、26、27。 + fast 负责读,slow 负责写,slow 左侧始终是已整理好的区域。原地删除和压缩类题目的标准写法,见 LC 283、26、27。

} /> @@ -2372,8 +2307,7 @@ for (const v of arr) console.log(v); // 遍历`, } zh={

- 从两端向中间靠拢。利用有序性,或者「较矮的一端限制了结果」这一点, - 每一步都能安全丢掉一端,见 LC 11、167、15、42。 + 从两端向中间靠拢。利用有序性,或者「较矮的一端限制了结果」这一点,每一步都能安全丢掉一端,见 LC 11、167、15、42。

} /> @@ -2395,8 +2329,7 @@ for (const v of arr) console.log(v); // 遍历`, } zh={

- 连续子数组问题专用:右端加入、左端移出,窗口里维护一个可以逐步更新的量, - 见 LC 209、3、76。 + 连续子数组问题专用:右端加入、左端移出,窗口里维护一个可以逐步更新的量,见 LC 209、3、76。

} /> @@ -2430,9 +2363,9 @@ for (const v of arr) console.log(v); // 遍历`, zh={

题意:把所有 0 移到数组末尾,非零元素保持相对顺序,必须原地操作。 - 暴力:新建一个数组,先抄非零元素再补零 —— + 暴力:新建一个数组,先抄非零元素再补零 —— 时间 O(n) 但用了 O(n) 额外空间,不符合题目要求。 - 正解:换个目标:不搬 0,搬非零元素。 + 正解:换个目标:不搬 0,搬非零元素。

} /> @@ -2544,10 +2477,7 @@ for (const v of arr) console.log(v); // 遍历`, } zh={

- 时间 O(n)(fast 只走一遍),空间 O(1)。 - 面试官常追问:「如果要移动的不是 0 而是某个给定值?」(那就是 LC 27) - 「能否减少写操作?」(只在 fast ≠ slow 时才交换;或者先把非零元素依次写到前面,最后统一补 0)。 - 他们真正想听的是循环不变量:slow 左边恒为非零元素,且保持原有相对顺序。 + 时间 O(n)(fast 只走一遍),空间 O(1)。面试官常追问:「如果要移动的不是 0 而是某个给定值?」(那就是 LC 27)「能否减少写操作?」(只在 fast ≠ slow 时才交换;或者先把非零元素依次写到前面,最后统一补 0)。他们真正想听的是循环不变量:slow 左边恒为非零元素,且保持原有相对顺序。

} /> @@ -2584,11 +2514,9 @@ for (const v of arr) console.log(v); // 遍历`, } zh={

- 题意:给 n 条竖线,选两条,与 x 轴围成一个容器,求最大盛水面积 - (面积 = 两线间距 × 较矮的那条)。暴力:枚举所有线对,O(n²)。 - 正解:从最宽的一对开始向中间靠拢, - 每一步都移动较矮的那一端: - 宽度反正只会变小,只有换掉较矮的线,面积才有机会变大。 + 题意:给 n 条竖线,选两条,与 x 轴围成一个容器,求最大盛水面积(面积 = 两线间距 × 较矮的那条)。暴力:枚举所有线对,O(n²)。 + 正解:从最宽的一对开始向中间靠拢, + 每一步都移动较矮的那一端:宽度反正只会变小,只有换掉较矮的线,面积才有机会变大。

} /> @@ -2708,11 +2636,7 @@ for (const v of arr) console.log(v); // 遍历`, } zh={

- 设左边那条线较矮。考虑所有仍然保留这条左线的组合: - 另一条线只能落在当前两端之间,宽度更小,而高度仍被这条矮线限制。 - 这些组合的面积都不会超过刚刚算出的面积,可以整批丢弃。 - 所以每一步都在无损地排除一批候选,总共 n 步就能扫完:O(n²) 降为 O(n)。 - 这段论证就是面试时期待你说出来的答案。 + 设左边那条线较矮。考虑所有仍然保留这条左线的组合:另一条线只能落在当前两端之间,宽度更小,而高度仍被这条矮线限制。这些组合的面积都不会超过刚刚算出的面积,可以整批丢弃。所以每一步都在无损地排除一批候选,总共 n 步就能扫完:O(n²) 降为 O(n)。这段论证就是面试时期待你说出来的答案。

} /> @@ -2753,11 +2677,9 @@ for (const v of arr) console.log(v); // 遍历`,

题意:在正整数数组中,找出和 ≥ target 的 最短连续子数组的长度。 - 暴力:枚举所有起点和终点,O(n²)。 - 正解:滑动窗口。因为元素全为正,窗口和在右端右移时 - 只增不减、在左端右移时只减不增。 - 这正是保证正确性的不变量:一旦和降到 target 以下, - 继续右移左端只会更小,所以左端永远不需要回头。 + 暴力:枚举所有起点和终点,O(n²)。 + 正解:滑动窗口。因为元素全为正,窗口和在右端右移时 + 只增不减、在左端右移时只减不增。这正是保证正确性的不变量:一旦和降到 target 以下,继续右移左端只会更小,所以左端永远不需要回头。

} /> @@ -2880,12 +2802,8 @@ for (const v of arr) console.log(v); // 遍历`, zh={

虽然 for 里套了 while,但 l 和 r{" "} - 都只前进不后退,各自最多 n 步,总步数不超过 2n,时间是 O(n)。 - 任何窗口题都可以用三个问题来描述:① 窗口里维护什么量(这里是 sum)? - ② 什么时候扩(这里每一步都扩)?③ 什么时候缩(这里是 sum ≥ target)? - 想清这三问,LC 3、76、438 都是同一套写法。一个前提要记住: - 这个窗口成立是因为元素全为正;一旦允许负数,窗口和不再单调, - 就要改用前缀和的思路。 + 都只前进不后退,各自最多 n 步,总步数不超过 2n,时间是 O(n)。任何窗口题都可以用三个问题来描述:① 窗口里维护什么量(这里是 sum)? + ② 什么时候扩(这里每一步都扩)?③ 什么时候缩(这里是 sum ≥ target)?想清这三问,LC 3、76、438 都是同一套写法。一个前提要记住:这个窗口成立是因为元素全为正;一旦允许负数,窗口和不再单调,就要改用前缀和的思路。

} /> @@ -2961,8 +2879,7 @@ for (const v of arr) console.log(v); // 遍历`, ), zh: ( <> - 要不要搬动别的元素?这一个问题就决定了数组每种操作的成本: - 尾部 O(1),头部和中间 O(n) —— 代价来自搬动,不是来自查找。 + 要不要搬动别的元素?这一个问题就决定了数组每种操作的成本:尾部 O(1),头部和中间 O(n) —— 代价来自搬动,不是来自查找。 ), }, @@ -3000,10 +2917,7 @@ for (const v of arr) console.log(v); // 遍历`, ), zh: ( <> - 二分查找同时需要有序和 O(1) 随机访问。 - 闭区间写法的不变量是「答案若存在,必在 [left, right] 内」, - 由此得出 left <= right、mid ± 1, - 以及 Java 里防溢出的中点写法{" "} + 二分查找同时需要有序和 O(1) 随机访问。闭区间写法的不变量是「答案若存在,必在 [left, right] 内」,由此得出 left <= right、mid ± 1,以及 Java 里防溢出的中点写法{" "} left + (right - left) / 2。 ), @@ -3022,10 +2936,8 @@ for (const v of arr) console.log(v); // 遍历`, zh: ( <> 二维只是读法:行优先下{" "} - 一维下标 = 行号 × 列数 + 列号。 - C 和 NumPy 里确实是一整块连续内存,Java 的{" "} - int[][] 则是一个存放各行引用的数组。 - 按行遍历更快是缓存行带来的,不是复杂度的差别。 + 一维下标 = 行号 × 列数 + 列号。C 和 NumPy 里确实是一整块连续内存,Java 的{" "} + int[][] 则是一个存放各行引用的数组。按行遍历更快是缓存行带来的,不是复杂度的差别。 ), }, @@ -3045,10 +2957,8 @@ for (const v of arr) console.log(v); // 遍历`, ), zh: ( <> - 双指针三种形式:同向用于原地压缩,对撞用于有序数组或「较矮端限制结果」, - 滑动窗口用于连续子数组。三者背后是同一个思想: - 用单调性排除候选,把 O(n²) 压成 O(n), - 而且每种都要能说清它的不变量。 + 双指针三种形式:同向用于原地压缩,对撞用于有序数组或「较矮端限制结果」,滑动窗口用于连续子数组。三者背后是同一个思想: + 用单调性排除候选,把 O(n²) 压成 O(n),而且每种都要能说清它的不变量。 ), }, diff --git a/app/array/viz.tsx b/app/array/viz.tsx index 56b0120..822da58 100644 --- a/app/array/viz.tsx +++ b/app/array/viz.tsx @@ -69,8 +69,7 @@ export function IndexLab() { zh={ <> arr[{sel}] 的地址 = {BASE}(首地址) + {sel} × {SIZE} - (元素大小) = {BASE + sel * SIZE} —— 一次乘加,不用查找, - 这就是 O(1)。哪怕数组有一亿个元素,公式还是这一条。 + (元素大小) = {BASE + sel * SIZE} —— 一次乘加,不用查找,这就是 O(1)。哪怕数组有一亿个元素,公式还是这一条。 } /> @@ -254,8 +253,7 @@ export function ShiftLab() { } zh={ <> - 在下标 {pos} 插入 {v} 完成,一共搬动了 {done} 个元素。 - 数组越长、位置越靠前,搬动的越多,这就是 O(n)。 + 在下标 {pos} 插入 {v} 完成,一共搬动了 {done} 个元素。数组越长、位置越靠前,搬动的越多,这就是 O(n)。 } />, diff --git a/app/atlas/page.tsx b/app/atlas/page.tsx index de2ba2c..665090f 100644 --- a/app/atlas/page.tsx +++ b/app/atlas/page.tsx @@ -840,9 +840,7 @@ export default function AtlasChapter() { ), zh: ( <> - 十三种结构都认识了,最后一课只教一件事:看到问题的那一刻, - 你脑子里应该亮起哪盏灯。选型没有玄学 —— 把操作需求列出来, - 对着价格表挑就是了。 + 十三种结构都认识了,最后一课只教一件事:看到问题的那一刻,你脑子里应该亮起哪盏灯。选型没有玄学 —— 把操作需求列出来,对着价格表挑就是了。 ), }} @@ -882,8 +880,7 @@ export default function AtlasChapter() { zh={ <> 它不是标准答案,是提问顺序:先问「核心动作是什么」,再问「要不要有序 / - 前缀 / 动态修改」。真实题目常常要组合(LRU = 哈希+链表; - 前 K 个高频 = 哈希+堆)—— 先各自选型,再拼积木。 + 前缀 / 动态修改」。真实题目常常要组合(LRU = 哈希+链表;前 K 个高频 = 哈希+堆)—— 先各自选型,再拼积木。 } /> @@ -1123,8 +1120,7 @@ export default function AtlasChapter() { zh={ <> 沿着本课的伏笔继续:二分的边界变体(旋转数组/答案二分)→ - 回溯(递归树,你在二叉树章练过的思维)→ 贪心 → 动态规划 - (Kadane 算法你已经在 LC 53 的题解里见过,它就是 DP)。每个专题都建立在你手里的结构上。 + 回溯(递归树,你在二叉树章练过的思维)→ 贪心 → 动态规划(Kadane 算法你已经在 LC 53 的题解里见过,它就是 DP)。每个专题都建立在你手里的结构上。 } /> @@ -1149,8 +1145,7 @@ export default function AtlasChapter() { zh={ <> 把结构放大一万倍:哈希 → 一致性哈希与分片;跳表 → Redis zset; - B+ 树 → 数据库索引;布隆过滤器 → 缓存穿透防护;队列 → Kafka。 - 这门课的每个 Callout「工程现场」都是入口。 + B+ 树 → 数据库索引;布隆过滤器 → 缓存穿透防护;队列 → Kafka。这门课的每个 Callout「工程现场」都是入口。 } /> @@ -1175,8 +1170,7 @@ export default function AtlasChapter() { } zh={ <> - 回到 §04 的总表:先扫 Easy 建手感,再限时刷 Medium。 - 每道题做完问三句:复杂度多少?为什么能优化?换个数据结构会怎样? + 回到 §04 的总表:先扫 Easy 建手感,再限时刷 Medium。每道题做完问三句:复杂度多少?为什么能优化?换个数据结构会怎样? —— 面试考的就是这三句。 } @@ -1252,8 +1246,7 @@ export default function AtlasChapter() { ), zh: ( <> - 选型三步:列出操作需求 → 标出频率最高的操作 → 对着复杂度表挑 - 让它最便宜的结构。 + 选型三步:列出操作需求 → 标出频率最高的操作 → 对着复杂度表挑让它最便宜的结构。 ), }, @@ -1268,8 +1261,7 @@ export default function AtlasChapter() { ), zh: ( <> - 两条物理直觉贯穿一切:连续内存靠「首地址+偏移」公式(数组/哈希桶/堆), - 离散内存靠引用纸条(链表/树/图)。 + 两条物理直觉贯穿一切:连续内存靠「首地址+偏移」公式(数组/哈希桶/堆),离散内存靠引用纸条(链表/树/图)。 ), }, @@ -1284,8 +1276,7 @@ export default function AtlasChapter() { ), zh: ( <> - 复杂题拼积木:LRU = 哈希+双向链表;前 K 高频 = 哈希+堆; - 单词搜索 = Trie+回溯 —— 先各自选型,再组合。 + 复杂题拼积木:LRU = 哈希+双向链表;前 K 高频 = 哈希+堆;单词搜索 = Trie+回溯 —— 先各自选型,再组合。 ), }, @@ -1300,8 +1291,7 @@ export default function AtlasChapter() { ), zh: ( <> - 没有万能结构:每个 O(1) 都在别处付了账。能讲清楚「我为什么不用 X」, - 比会用 X 更能打动面试官。 + 没有万能结构:每个 O(1) 都在别处付了账。能讲清楚「我为什么不用 X」,比会用 X 更能打动面试官。 ), }, @@ -1315,8 +1305,7 @@ export default function AtlasChapter() { ), zh: ( <> - 这门课的终点是你的起点:把题单总表完整做三遍,让每一章都亮起绿灯, - 然后把学到的内容用到实际问题中去。 + 这门课的终点是你的起点:把题单总表完整做三遍,让每一章都亮起绿灯,然后把学到的内容用到实际问题中去。 ), }, diff --git a/app/binary-tree/page.tsx b/app/binary-tree/page.tsx index f1fa169..88bce31 100644 --- a/app/binary-tree/page.tsx +++ b/app/binary-tree/page.tsx @@ -95,10 +95,8 @@ export default function BinaryTreeChapter() { ), zh: ( <> - 链表节点只握着一个指向下一站的引用;让它握两个, - 链就长成了树。树是层级数据的天然形状,也是递归 - 第一次真正派上用场的地方 —— 记住「树 = 根 + 左子树 + 右子树」这一句, - 后面五章都是它的变奏。 + 链表节点只握着一个指向下一站的引用;让它握两个,链就长成了树。树是层级数据的天然形状,也是递归 + 第一次真正派上用场的地方 —— 记住「树 = 根 + 左子树 + 右子树」这一句,后面五章都是它的变奏。 ), }} @@ -155,21 +153,16 @@ export default function BinaryTreeChapter() { <>

到目前为止,我们的数据都排成一条线 - :数组、链表、栈、队列,每个元素最多有一个「下一个」。 - 但看看你身边的信息:文件夹里套着子文件夹、一位总监下面带着几个组、 - 家谱里一位祖先开枝散叶、这个网页本身(HTML 的 DOM)也是标签套标签 —— + :数组、链表、栈、队列,每个元素最多有一个「下一个」。但看看你身边的信息:文件夹里套着子文件夹、一位总监下面带着几个组、家谱里一位祖先开枝散叶、这个网页本身(HTML 的 DOM)也是标签套标签 —— 层级(hierarchy)无处不在,而一条线画不出层级。

怎么升级?回想链表:每个节点有一个 next{" "} 引用,指向下一站。现在允许它指向不止一个「下一站」 - —— 数据结构立刻从「一条链」长成「一棵倒挂的树」:最上面是根, - 往下逐层展开,末端是叶。如果每个节点最多指向两个,叫{" "} + —— 数据结构立刻从「一条链」长成「一棵倒挂的树」:最上面是根,往下逐层展开,末端是叶。如果每个节点最多指向两个,叫{" "} left 和 right,就是本章的主角 - 二叉树(binary tree)。为什么偏偏是两个? - 两个分支已经能表达任何「二选一」的决策 —— - 下一章二叉搜索树的地基就是它;而且任意多叉树都能改写成二叉形态: - 让 left 表示「第一个孩子」、right{" "} + 二叉树(binary tree)。为什么偏偏是两个?两个分支已经能表达任何「二选一」的决策 —— + 下一章二叉搜索树的地基就是它;而且任意多叉树都能改写成二叉形态:让 left 表示「第一个孩子」、right{" "} 表示「下一个兄弟」即可。所以二叉树是整个树家族的标准构件。

@@ -196,8 +189,7 @@ export default function BinaryTreeChapter() { zh={ <> 每个节点至多一个左孩子、一个右孩子,而且两个位置不能互换 - :只有左孩子的节点,和只有右孩子的节点,是两棵不同的树。 - 孩子可以缺,但不能多出第三个。 + :只有左孩子的节点,和只有右孩子的节点,是两棵不同的树。孩子可以缺,但不能多出第三个。 } /> @@ -221,8 +213,7 @@ export default function BinaryTreeChapter() { zh={ <> 除根以外,每个节点恰好有一个父节点 - ;顺着孩子引用一直走,永远不会绕回某个祖先。 - 去掉这条规则,结构就退化成图 —— 那是第 12 章的内容。 + ;顺着孩子引用一直走,永远不会绕回某个祖先。去掉这条规则,结构就退化成图 —— 那是第 12 章的内容。 } /> @@ -244,8 +235,7 @@ export default function BinaryTreeChapter() { } zh={ <> - 从任何一个节点往下看,看到的又是一棵合法的二叉树(它的子树)。 - 这条自相似性质正是递归能用在树上的原因,本章会反复用到它。 + 从任何一个节点往下看,看到的又是一棵合法的二叉树(它的子树)。这条自相似性质正是递归能用在树上的原因,本章会反复用到它。 } /> @@ -290,9 +280,7 @@ export default function BinaryTreeChapter() { (这也是主流约定):节点的深度 depth = 从根走到它经过的边数,所以根的深度是 0;节点的高度 height{" "} = 从它往下走到叶子的最长路径的边数,所以叶子的高度是 0; - 整棵树的高度 = 根的高度。于是只有一个根的树,树高为 0; - 空树按惯例记作 −1。第 8、9 章沿用同一套定义, - 两章的公式可以直接对照。 + 整棵树的高度 = 根的高度。于是只有一个根的树,树高为 0;空树按惯例记作 −1。第 8、9 章沿用同一套定义,两章的公式可以直接对照。

} /> @@ -343,11 +331,7 @@ export default function BinaryTreeChapter() {

把节点按层序从 0 开始编号,于是编号 i 的两个孩子恰好落在{" "} 2i+1 和 2i+2,父亲落在{" "} - (i-1)/2 向下取整 —— 算术完全替代了引用。 - 但这只有在「用到的编号是一段没有空洞的连续区间」时才划算, - 而这正是完全二叉树的定义:n 个节点用 n 格数组。 - 别的形状会留下空洞:一条始终向右倾斜的 n 节点链, - 最深的节点编号是 2n−2,要存下 n 个值就得开 2n−1 + (i-1)/2 向下取整 —— 算术完全替代了引用。但这只有在「用到的编号是一段没有空洞的连续区间」时才划算,而这正是完全二叉树的定义:n 个节点用 n 格数组。别的形状会留下空洞:一条始终向右倾斜的 n 节点链,最深的节点编号是 2n−2,要存下 n 个值就得开 2n−1 格。所以数组存树只对完全二叉树成立,第 9 章的堆也才要刻意维持「完全」。

} @@ -377,9 +361,7 @@ export default function BinaryTreeChapter() {

浏览器渲染页面 = 遍历 DOM 树;ls -R 列目录 = 遍历文件树;编译器先把源码变成语法树(AST)再翻译;JSON - 解析出来就是一棵树;数据库索引通常是 B+ 树 —— 它不是二叉的, - 但思路一样:每个节点孩子数有上限的层级结构。 - 只要数据是嵌套的,树就是它的形状 —— + 解析出来就是一棵树;数据库索引通常是 B+ 树 —— 它不是二叉的,但思路一样:每个节点孩子数有上限的层级结构。只要数据是嵌套的,树就是它的形状 —— 这也是树的遍历成为面试保留节目的原因。

} @@ -493,10 +475,8 @@ export default function BinaryTreeChapter() { 一棵二叉树,要么是空的,要么 = 一个根节点 + 一棵左子树 + 一棵右子树(而这两棵子树,又各自是一棵二叉树)。 - {" "} - 注意「空也是树」—— 它不是勉强容忍的特例,而是递归的地基: - 任何叶子的左右孩子都是空树,所以「空树怎么办」永远是递归的第一行代码。 - 这句话读三遍,本章剩下的一切都是它的翻译。 + + 注意「空也是树」—— 它不是勉强容忍的特例,而是递归的地基:任何叶子的左右孩子都是空树,所以「空树怎么办」永远是递归的第一行代码。这句话读三遍,本章剩下的一切都是它的翻译。

} /> @@ -515,11 +495,8 @@ export default function BinaryTreeChapter() { } zh={

- 一个有用的计数:n 个节点的二叉树一共有 2n 条「孩子插槽」, - 其中只用了 n−1 条(除根以外每个节点恰好当一次别人的孩子), - 剩下 n+1 条插槽是 null。null 比节点还多 —— - 这就是终止条件会被走到那么多次的原因,也说明它不是「写得整齐」的问题, - 而是不写就必错。 + 一个有用的计数:n 个节点的二叉树一共有 2n 条「孩子插槽」,其中只用了 n−1 条(除根以外每个节点恰好当一次别人的孩子),剩下 n+1 条插槽是 null。null 比节点还多 —— + 这就是终止条件会被走到那么多次的原因,也说明它不是「写得整齐」的问题,而是不写就必错。

} /> @@ -643,10 +620,7 @@ console.log(factorial(3)); // 6`, } zh={

- 「函数还没执行完,又调用了自己 —— 电脑不会晕吗?」不会, - 因为有调用栈(第 4 章的调用栈演示又出现了): - 每次调用压入一个新栈帧,各帧独立保存自己的参数和执行进度。 - 眼见为实,逐帧看 factorial(3) 的一生: + 「函数还没执行完,又调用了自己 —— 电脑不会晕吗?」不会,因为有调用栈(第 4 章的调用栈演示又出现了):每次调用压入一个新栈帧,各帧独立保存自己的参数和执行进度。眼见为实,逐帧看 factorial(3) 的一生:

} /> @@ -685,8 +659,7 @@ console.log(factorial(3)); // 6`, <> 用一句话说清函数到底返回什么,而且这句话对每个 节点都成立,不只对根成立。以数节点为例: - count(node) 返回「以 node 为根的子树里有多少个节点」。 - 这句话不先写下来,后面两个问题根本没法回答。 + count(node) 返回「以 node 为根的子树里有多少个节点」。这句话不先写下来,后面两个问题根本没法回答。 } /> @@ -713,8 +686,7 @@ console.log(factorial(3)); // 6`, zh={ <> 最小的、不用递归就能直接回答的输入。阶乘是 n ≤ - 1;树上几乎永远是空树,即 node == null。 - 它写在第一行,而且它返回的值必须满足问题一的承诺:count(null) = + 1;树上几乎永远是空树,即 node == null。它写在第一行,而且它返回的值必须满足问题一的承诺:count(null) = 0。 } @@ -746,8 +718,7 @@ console.log(factorial(3)); // 6`, zh={ <> 假设递归调用已经返回了正确答案,只管怎么用它们拼出当前答案: - count(node) = 1 + count(左) + count(右)。 - 这个假设是允许的,因为它就是数学归纳法的归纳假设,不是碰运气 —— + count(node) = 1 + count(左) + count(右)。这个假设是允许的,因为它就是数学归纳法的归纳假设,不是碰运气 —— 见本节末尾那条说明。三个问题里,只有这一步需要你真正动脑设计。 } @@ -773,11 +744,9 @@ console.log(factorial(3)); // 6`, zh={

现在回到树。§02 的钥匙说「树 = 根 + 左子树 + 右子树」,那么 - 数节点这个问题天然就是递归形状。 - 照着三个问题回答一遍:承诺是 + 数节点这个问题天然就是递归形状。照着三个问题回答一遍:承诺是 count(node) 返回「以 node 为根的子树里有多少个节点」 - ;终止条件是 count(null) = 0;合并是 1 + count(左) + count(右)。 - 看它在一棵 7 节点的树上怎么跑 —— + ;终止条件是 count(null) = 0;合并是 1 + count(左) + count(右)。看它在一棵 7 节点的树上怎么跑 —— 注意右侧调用栈的涨落,以及每个节点算完时亮出的返回值:

} @@ -807,8 +776,7 @@ console.log(factorial(3)); // 6`, zh={

没有 if (node == null) return 0;,代码就会试图读{" "} - null.left,抛空指针异常;换一种写法则会无限自我调用, - 栈帧堆到几万层 —— Java 和 JavaScript 抛栈溢出,Python 抛{" "} + null.left,抛空指针异常;换一种写法则会无限自我调用,栈帧堆到几万层 —— Java 和 JavaScript 抛栈溢出,Python 抛{" "} RecursionError。养成肌肉记忆: 第一行永远先问「空树怎么办」。§05 会给出各语言的递归深度红线。

@@ -840,12 +808,8 @@ console.log(factorial(3)); // 6`, } zh={

- 数学归纳法:先证 n = 1 成立(终止条件), - 再证「若 n−1 成立则 n 成立」(合并这一步), - 就证明了对一切 n 成立。递归是同一个论证的可执行版本。 - 它成立要满足两个条件:终止条件本身正确,且每次调用规模 - 严格变小,从而终止条件一定会被走到。 - 新手在脑子里追着展开三层就晕了;正确的做法是只检查一层: + 数学归纳法:先证 n = 1 成立(终止条件),再证「若 n−1 成立则 n 成立」(合并这一步),就证明了对一切 n 成立。递归是同一个论证的可执行版本。它成立要满足两个条件:终止条件本身正确,且每次调用规模 + 严格变小,从而终止条件一定会被走到。新手在脑子里追着展开三层就晕了;正确的做法是只检查一层: 假定孩子给的答案是对的,我这一层拼出来的答案对不对?

} @@ -898,16 +862,10 @@ console.log(factorial(3)); // 6`,

树是二维的,而打印、比较、序列化都需要一维序列 —— 按某种固定顺序走遍每个节点就叫 - 遍历(traversal)。深度优先(DFS)的路线只有一条: - 顺着一条分支扎到底,再回头走下一条。三种 DFS 遍历的差别只有一个: - 节点自己相对于两棵子树在什么时候被访问。 - 先访问自己 = 前序(根 → 左 → 右); - 在两棵子树之间访问 = 中序(左 → 根 → 右); - 最后访问 = 后序(左 → 右 → + 遍历(traversal)。深度优先(DFS)的路线只有一条:顺着一条分支扎到底,再回头走下一条。三种 DFS 遍历的差别只有一个: + 节点自己相对于两棵子树在什么时候被访问。先访问自己 = 前序(根 → 左 → 右);在两棵子树之间访问 = 中序(左 → 根 → 右);最后访问 = 后序(左 → 右 → 根)。左永远在右前面,这只是约定。第四种是广度优先(BFS)的 - 层序:先整个第一层,再整个第二层,每层从左到右。 - 它不「扎到底」,靠队列(第 5 章)驱动。 - 亲手把四种走法各放一遍: + 层序:先整个第一层,再整个第二层,每层从左到右。它不「扎到底」,靠队列(第 5 章)驱动。亲手把四种走法各放一遍:

} /> @@ -1077,8 +1035,7 @@ console.log(factorial(3)); // 6`, zh={

锚点一:DFS 三种遍历的名字说的都是根什么时候被访问 —— - pre(前)/ in(中)/ post(后);左永远在右前面,三种都一样。 - 锚点二:DFS 的额外空间花在栈上 + pre(前)/ in(中)/ post(后);左永远在右前面,三种都一样。锚点二:DFS 的额外空间花在栈上 (递归栈或自己维护的栈),所以是 O(h),h 是树的高度。 要写 O(h),不要写 O(log n) —— 只有树平衡时 h 才约等于 log n;退化成一条链时 h = n−1。BFS 的额外空间花在队列上 @@ -1122,12 +1079,9 @@ console.log(factorial(3)); // 6`, } zh={

- 对比三个递归版本,你会发现只有一行的位置不同: - 输出节点那行,分别落在两次递归调用之前、之间、之后 —— - 因为路线本来就一样。迭代版前序则把隐藏的栈搬到明面上: - 用自己的栈保存「待处理的节点」,并且先压右孩子 - —— 栈返回的是最后压入的那个,所以后压左孩子,左孩子才会先被弹出。 - 最下面的层序函数在内层循环之前记下了 size,§07 + 对比三个递归版本,你会发现只有一行的位置不同:输出节点那行,分别落在两次递归调用之前、之间、之后 —— + 因为路线本来就一样。迭代版前序则把隐藏的栈搬到明面上:用自己的栈保存「待处理的节点」,并且先压右孩子 + —— 栈返回的是最后压入的那个,所以后压左孩子,左孩子才会先被弹出。最下面的层序函数在内层循环之前记下了 size,§07 会讲清这一行为什么就是层与层的分界线。

} @@ -1282,8 +1236,7 @@ class Traversals { ), zh: ( <> - 栈深:JVM 默认线程栈在常见的 64 位平台上约为 1 MB(具体随平台而异), - 退化成一条链的百万节点树会抛 StackOverflowError —— + 栈深:JVM 默认线程栈在常见的 64 位平台上约为 1 MB(具体随平台而异),退化成一条链的百万节点树会抛 StackOverflowError —— 深树要么用迭代版,要么用 -Xss 调大栈。 ), @@ -1602,14 +1555,10 @@ function levelOrder(root) { } zh={

- 完整的回答:递归版读起来就是树的定义本身, - 代价是栈深有限(Python 默认约 1000 层,JVM 和 JS + 完整的回答:递归版读起来就是树的定义本身,代价是栈深有限(Python 默认约 1000 层,JVM 和 JS 引擎也各有几千到几万层的红线);极深或链状的树需要迭代版 —— - 它自己管栈,深度只受堆内存限制。两者时间复杂度都是 O(n)。 - 能顺手写出迭代前序,会让回答更完整。如果面试官进一步要求 - 额外空间 O(1),答案是 Morris 遍历: - 它借用节点闲置的右指针记住「回来时该去哪」,完全不需要栈。 - 代价是它运行期间会修改树,并在结束前把改过的指针全部复原。 + 它自己管栈,深度只受堆内存限制。两者时间复杂度都是 O(n)。能顺手写出迭代前序,会让回答更完整。如果面试官进一步要求 + 额外空间 O(1),答案是 Morris 遍历:它借用节点闲置的右指针记住「回来时该去哪」,完全不需要栈。代价是它运行期间会修改树,并在结束前把改过的指针全部复原。

} /> @@ -1648,9 +1597,7 @@ function levelOrder(root) {

数组、字典每个语言都自带,树却没有 —— 因为树的形状由具体问题决定,标准库给不出通用款(Java 的{" "} - TreeMap 内部虽是红黑树,但不暴露节点)。好消息: - 做题时 TreeNode 由题目提供,你只需要会读; - 本地调试时,下面的 buildTree 能把 LeetCode + TreeMap 内部虽是红黑树,但不暴露节点)。好消息:做题时 TreeNode 由题目提供,你只需要会读;本地调试时,下面的 buildTree 能把 LeetCode 的层序数组(例如 [3,9,20,null,null,15,7])变成一棵真树:

} @@ -1829,8 +1776,7 @@ print(root.right.left.val) # 15`, zh: ( <> 细节:判断空位要用 is None 而不是{" "} - not vals[i] —— 后者会把合法的节点值 0 也当成空位, - 这是做题时实际很常见的错误。 + not vals[i] —— 后者会把合法的节点值 0 也当成空位,这是做题时实际很常见的错误。 ), }, @@ -1916,8 +1862,7 @@ console.log(root.right.left.val); // 15`, zh: ( <> 细节:LeetCode 的 JS 模板用的是构造函数写法{" "} - function TreeNode(val, left, right), - 上面的 class 写法与它完全兼容 —— 两种都要认识。 + function TreeNode(val, left, right),上面的 class 写法与它完全兼容 —— 两种都要认识。 ), }, @@ -2125,9 +2070,7 @@ console.log(root.right.left.val); // 15`, 一棵树的答案 = 当前节点贡献什么 + 左子树的答案 + 右子树的答案 - 。所以拿到题先问同一个问题:「如果左右子树的答案已经在我手上, - 我该怎么拼出整棵树的答案?」拼法说得出来,再加上终止条件, - 代码就写完了。题与题之间真正不同的是 + 。所以拿到题先问同一个问题:「如果左右子树的答案已经在我手上,我该怎么拼出整棵树的答案?」拼法说得出来,再加上终止条件,代码就写完了。题与题之间真正不同的是 信息往哪个方向流,这决定了两种做法:

} @@ -2158,8 +2101,7 @@ console.log(root.right.left.val); // 15`, } zh={ <> - 信息从根流向叶:把「一路走来的状态」(当前深度、还差多少和、 - 走过的路径)装进参数带下去,在前序位置 + 信息从根流向叶:把「一路走来的状态」(当前深度、还差多少和、走过的路径)装进参数带下去,在前序位置 (进入节点时)干活,到叶子时结算。参见 LC 112、257、129。 } @@ -2234,9 +2176,7 @@ console.log(root.right.left.val); // 15`,

关于自底向上有一个提醒:函数的返回值 不一定就是你要的答案。最经典的是直径(题单 LC - 543):函数返回的是高度,因为那是父节点需要的东西; - 而直径存在递归之外的一个变量里,每个节点算完时去挑战它一次。 - 只要题目问的东西可以「在某个节点拐弯」,就要预料到这两者不同 —— + 543):函数返回的是高度,因为那是父节点需要的东西;而直径存在递归之外的一个变量里,每个节点算完时去挑战它一次。只要题目问的东西可以「在某个节点拐弯」,就要预料到这两者不同 —— 动手写之前先把两句话都说清楚。

@@ -2289,17 +2229,13 @@ console.log(root.right.left.val); // 15`, <>

题意:求这棵树的最大深度。先看清约定:LeetCode - 数的是从根到最远叶子这条路径上的节点数, - 所以单个节点的最大深度是 1,空树是 0 —— 这比 §01 - 定义的「数边」深度大 1(那里根的深度是 0)。 - 两种约定都很常见,说的时候务必讲清用的是哪一种。 + 数的是从根到最远叶子这条路径上的节点数,所以单个节点的最大深度是 1,空树是 0 —— 这比 §01 + 定义的「数边」深度大 1(那里根的深度是 0)。两种约定都很常见,说的时候务必讲清用的是哪一种。

函数的承诺:maxDepth(node) 返回「从 node 往下到叶子的最长路径上有几个节点」。终止条件: - maxDepth(null) = 0。合并这一步:1 + max(左边的答案, - 右边的答案)—— 节点自己占一层,而最长路径只可能由更深的那一侧决定。 - 三个问题都答完了,函数也就写完了。这是本章第一道自底向上的题: + maxDepth(null) = 0。合并这一步:1 + max(左边的答案,右边的答案)—— 节点自己占一层,而最长路径只可能由更深的那一侧决定。三个问题都答完了,函数也就写完了。这是本章第一道自底向上的题:

} @@ -2389,10 +2325,7 @@ console.log(root.right.left.val); // 15`, zh={

每个节点访问一次,时间 O(n);递归栈最深等于树高,额外空间{" "} - O(h) —— 平衡时约 log n,退化成链时是 n。追问一: - 「用 BFS 怎么求?」层序遍历数层数,有几层深度就是几。追问二: - 「最小深度呢?」小心叶子陷阱(题单 LC 111): - 只有一个孩子的节点不是叶子,空的那一侧不能把它的 0 算进来。 + O(h) —— 平衡时约 log n,退化成链时是 n。追问一:「用 BFS 怎么求?」层序遍历数层数,有几层深度就是几。追问二:「最小深度呢?」小心叶子陷阱(题单 LC 111):只有一个孩子的节点不是叶子,空的那一侧不能把它的 0 算进来。

} /> @@ -2432,10 +2365,7 @@ console.log(root.right.left.val); // 15`, 题意:把整棵树左右镜像。函数的承诺:invertTree(node) 返回「同一棵子树,但已经镜像好了」。终止条件: 空树返回 null。合并这一步: - 交换当前节点的两个孩子引用,再让递归去镜像两棵子树。 - 交换写入的只是两根引用(§02), - 一次赋值就带动整棵子树;子树内部的顺序交给递归。 - 交换写在两次递归调用之前还是之后,结果都一样: + 交换当前节点的两个孩子引用,再让递归去镜像两棵子树。交换写入的只是两根引用(§02),一次赋值就带动整棵子树;子树内部的顺序交给递归。交换写在两次递归调用之前还是之后,结果都一样:

} /> @@ -2532,9 +2462,7 @@ console.log(root.right.left.val); // 15`, zh={

Mac 开发者人手一个的包管理器 Homebrew,其作者 Max Howell - 当年面试谷歌被拒后发推谈到这件事:谷歌说, - 虽然他们绝大多数工程师都在用他写的软件, - 但他在白板上翻转不出一棵二叉树。这条推特让 LC 226 + 当年面试谷歌被拒后发推谈到这件事:谷歌说,虽然他们绝大多数工程师都在用他写的软件,但他在白板上翻转不出一棵二叉树。这条推特让 LC 226 成了全站最有名的 Easy 题。现在你会写了 —— 而且还能说出它是 O(n) 时间、O(h) 空间,交换的是引用而不是值。

@@ -2585,8 +2513,7 @@ console.log(root.right.left.val); // 15`, 返回「子树 L 与子树 R 互为镜像」。终止条件: 两个都空 → true;只有一个空 → false。合并这一步: 值必须相等,并且L 的左与 R 的右互为镜像(外侧)、 - L 的右与 R 的左互为镜像(内侧)。 - 两个指针在树的两半上镜像同步走: + L 的右与 R 的左互为镜像(内侧)。两个指针在树的两半上镜像同步走:

} /> @@ -2706,9 +2633,7 @@ console.log(root.right.left.val); // 15`,

时间 O(n),栈空间 O(h)。这题真正可迁移的技巧是: 递归函数的参数不必只有一个节点。双树同步递归正是 LC 100 - (相同的树)、本题、LC 572(另一棵树的子树)共同的骨架。追问: - 「迭代怎么写?」把该成对比较的 (L, R) 成对放进容器, - 每轮取出一对 —— 用栈还是队列都行,关键是两个节点必须成对。 + (相同的树)、本题、LC 572(另一棵树的子树)共同的骨架。追问:「迭代怎么写?」把该成对比较的 (L, R) 成对放进容器,每轮取出一对 —— 用栈还是队列都行,关键是两个节点必须成对。

} /> @@ -2755,10 +2680,8 @@ console.log(root.right.left.val); // 15`, [[3],[9,20],[15,7]])。已知: 队列能按层的顺序把节点吐出来,但吐出来是一维的 —— 层与层的边界在哪?回答这个问题的一步: - 每一层开始的那一刻,队列里装着的恰好是这一层的全部节点,不多不少。 - 所以先记下 size = 当前队列长度,本轮只出队这么多个 - ;这一轮期间入队的孩子排在它们后面,自然属于下一层。 - 没有这一步,循环就分不清层的边界 —— 因为你读队列的同时它还在变长: + 每一层开始的那一刻,队列里装着的恰好是这一层的全部节点,不多不少。所以先记下 size = 当前队列长度,本轮只出队这么多个 + ;这一轮期间入队的孩子排在它们后面,自然属于下一层。没有这一步,循环就分不清层的边界 —— 因为你读队列的同时它还在变长:

} /> @@ -2919,9 +2842,7 @@ class Solution: } zh={

- 时间 O(n);队列里最多装一层,空间 O(w)。「先记 size」这一步撑起了: - 锯齿形层序(LC 103,隔层反转)、右视图(LC 199,取每层最后一个)、 - 每层最大值(LC 515)、最小深度(LC 111,出队遇到叶子立刻返回)—— + 时间 O(n);队列里最多装一层,空间 O(w)。「先记 size」这一步撑起了:锯齿形层序(LC 103,隔层反转)、右视图(LC 199,取每层最后一个)、每层最大值(LC 515)、最小深度(LC 111,出队遇到叶子立刻返回)—— 每一道都是这个模板改两行。树上的 BFS,学到这一题就完整了。

} @@ -2985,8 +2906,7 @@ class Solution: zh: ( <> 整章的钥匙: - 一棵树要么是空的,要么 = 根 + 左子树 + 右子树。 - 结构是递归定义的,处理它的代码自然也是递归的。 + 一棵树要么是空的,要么 = 根 + 左子树 + 右子树。结构是递归定义的,处理它的代码自然也是递归的。 ), }, @@ -3006,9 +2926,7 @@ class Solution: <> 递归的三个问题:它承诺返回什么、终止条件是什么 (树上就是空树,写在第一行)、 - 怎么用孩子的答案拼出我的答案。 - 每次调用的规模必须严格变小,否则永远走不到终止条件,栈就会溢出 - (Python 默认只允许约 1000 层)。 + 怎么用孩子的答案拼出我的答案。每次调用的规模必须严格变小,否则永远走不到终止条件,栈就会溢出(Python 默认只允许约 1000 层)。 ), }, @@ -3026,8 +2944,7 @@ class Solution: <> 前 / 中 / 后序是同一条 DFS 路线 ,名字只说明节点自己什么时候被访问;层序是 BFS。四者时间都是 - O(n)。DFS 吃 O(h) 栈空间 —— 只有平衡时 h 才是 log n, - 退化成链时是 n;BFS 吃 O(w) 队列空间。 + O(n)。DFS 吃 O(h) 栈空间 —— 只有平衡时 h 才是 log n,退化成链时是 n;BFS 吃 O(w) 队列空间。 ), }, @@ -3045,8 +2962,7 @@ class Solution: zh: ( <> 两种做法:自顶向下用参数把祖先信息带下去(路径和、深度); - 自底向上用返回值把子树信息带上来(高度、直径)。 - 看答案依赖祖先还是子孙来选。另外记住返回值不一定是答案 —— + 自底向上用返回值把子树信息带上来(高度、直径)。看答案依赖祖先还是子孙来选。另外记住返回值不一定是答案 —— LC 543 返回的是高度,直径另用一个变量收集。 ), @@ -3063,8 +2979,7 @@ class Solution: zh: ( <> 让 BFS 能按层工作的那一步: - 在内层循环之前先记下队列长度,本轮只出队这么多个。 - 右视图、锯齿层序、最小深度全是它的变奏。 + 在内层循环之前先记下队列长度,本轮只出队这么多个。右视图、锯齿层序、最小深度全是它的变奏。 ), }, @@ -3086,8 +3001,7 @@ class Solution: 三个形状名词的中英对应不能想当然:真二叉树 full —— 每个节点要么 0 个孩子要么 2 个;满二叉树 perfect —— 每层都填满,所有叶子同一深度;完全二叉树 complete —— - 除最后一层外都填满,最后一层从左到右连续。 - 只有完全二叉树能不浪费地铺进数组(下标 i 的孩子在 2i+1、2i+2) + 除最后一层外都填满,最后一层从左到右连续。只有完全二叉树能不浪费地铺进数组(下标 i 的孩子在 2i+1、2i+2) —— 这就是第 9 章堆的地基。 ), diff --git a/app/binary-tree/viz.tsx b/app/binary-tree/viz.tsx index 36037cc..1307b31 100644 --- a/app/binary-tree/viz.tsx +++ b/app/binary-tree/viz.tsx @@ -178,8 +178,7 @@ export function TermTree() { <> 节点的深度 depth:从根走到它要经过几条边。根的深度是 0,所以 D 的深度是 2。节点的高度 height:从它走到自己最深的 - 叶子要经过几条边。叶子的高度是 0,所以 B 的高度是 1。 - 整棵树的高度 = 根的高度 = 这里的 2。 + 叶子要经过几条边。叶子的高度是 0,所以 B 的高度是 1。整棵树的高度 = 根的高度 = 这里的 2。 } /> @@ -261,9 +260,7 @@ export function ShapeGallery() { } zh={ <> - 每个节点要么有两个孩子,要么一个都没有。节点 2 是叶子, - 节点 3 两个孩子齐全,所以这棵树是真二叉树。它允许某一层中间留空, - 因此不是完全二叉树:下标 [3]、[4] 空着,[5]、[6] 却用上了。 + 每个节点要么有两个孩子,要么一个都没有。节点 2 是叶子,节点 3 两个孩子齐全,所以这棵树是真二叉树。它允许某一层中间留空,因此不是完全二叉树:下标 [3]、[4] 空着,[5]、[6] 却用上了。 } /> @@ -290,8 +287,7 @@ export function ShapeGallery() { zh={ <> 每一层都填满,所有叶子处在同一深度。高度为 h 的满二叉树共有 - 2h+1−1 个节点;这里 h = 2,正好 7 个。注意英文对应: - 满二叉树是 perfect,不是 full。 + 2h+1−1 个节点;这里 h = 2,正好 7 个。注意英文对应:满二叉树是 perfect,不是 full。 } /> @@ -318,9 +314,7 @@ export function ShapeGallery() { } zh={ <> - 除最后一层外每层都填满,最后一层从左到右连续排列。 - 于是用到的下标是一段没有空洞的连续区间 [0]…[5], - 整棵树铺进数组不浪费任何一格。第 9 章的堆,就靠这个性质活着。 + 除最后一层外每层都填满,最后一层从左到右连续排列。于是用到的下标是一段没有空洞的连续区间 [0]…[5],整棵树铺进数组不浪费任何一格。第 9 章的堆,就靠这个性质活着。 } /> @@ -385,8 +379,7 @@ const FAC_FRAMES: FacFrame[] = [ } zh={ <> - factorial(2) 同样卡在 factorial(1) 上,于是再压一帧。 - 每个栈帧独立记着自己的 n 和「算到哪一行了」,互不干扰。 + factorial(2) 同样卡在 factorial(1) 上,于是再压一帧。每个栈帧独立记着自己的 n 和「算到哪一行了」,互不干扰。 } /> @@ -413,8 +406,7 @@ const FAC_FRAMES: FacFrame[] = [ } zh={ <> - factorial(1) 命中终止条件:不再往下调,直接答 1, - 下潜到此为止。栈高 3 层,这就是递归的深度。 + factorial(1) 命中终止条件:不再往下调,直接答 1,下潜到此为止。栈高 3 层,这就是递归的深度。 } /> @@ -441,8 +433,7 @@ const FAC_FRAMES: FacFrame[] = [ } zh={ <> - f(1) 弹栈,把 1 交回 f(2)。f(2) 从冻结的那一行继续:2 × 1 = 2, - 算完了,轮到它弹栈。 + f(1) 弹栈,把 1 交回 f(2)。f(2) 从冻结的那一行继续:2 × 1 = 2,算完了,轮到它弹栈。 } /> @@ -569,9 +560,7 @@ const R_FRAMES: RFrame[] = [ zh={ <> 目标:数出这棵树有几个节点。函数的承诺: - count(node) 返回「以 node 为根的子树里有多少个节点」。 - 于是 count(node) = 1 + count(左) + count(右),count(null) = 0。 - 先调用 count(A)。 + count(node) 返回「以 node 为根的子树里有多少个节点」。于是 count(node) = 1 + count(左) + count(右),count(null) = 0。先调用 count(A)。 } /> @@ -592,8 +581,7 @@ const R_FRAMES: RFrame[] = [ } zh={ <> - count(A) 要算「1 + count(B) + count(C)」,先问 count(B)。 - A 的帧冻结在栈底,count(B) 压了进来。 + count(A) 要算「1 + count(B) + count(C)」,先问 count(B)。A 的帧冻结在栈底,count(B) 压了进来。 } /> @@ -613,8 +601,7 @@ const R_FRAMES: RFrame[] = [ } zh={ <> - count(B) 同样先要左边:压入 count(D)。栈越来越高, - 每一帧都记着自己停在哪里。 + count(B) 同样先要左边:压入 count(D)。栈越来越高,每一帧都记着自己停在哪里。 } /> @@ -635,8 +622,7 @@ const R_FRAMES: RFrame[] = [ } zh={ <> - D 的左右孩子都是 null,而 count(null) = 0 是终止条件。 - 于是 count(D) = 1 + 0 + 0 = 1,弹栈,把 1 交给 B。 + D 的左右孩子都是 null,而 count(null) = 0 是终止条件。于是 count(D) = 1 + 0 + 0 = 1,弹栈,把 1 交给 B。 } /> @@ -811,9 +797,7 @@ const R_FRAMES: RFrame[] = [ } zh={ <> - count(A) = 1 + 3 + 3 = 7。栈清空,答案是 7。复盘: - 每个节点恰好被访问一次,时间 O(n);栈最高时不超过树的高度, - 额外空间 O(h)。 + count(A) = 1 + 3 + 3 = 7。栈清空,答案是 7。复盘:每个节点恰好被访问一次,时间 O(n);栈最高时不超过树的高度,额外空间 O(h)。 } /> @@ -927,9 +911,7 @@ function buildDfsFrames(order: Exclude): TravFrame[] { } zh={ <> - {label.zh}:三种深度优先遍历走的路线完全一样, - 差别只在节点自己相对于两棵子树在什么时候被访问。 - 点「下一步」开走。 + {label.zh}:三种深度优先遍历走的路线完全一样,差别只在节点自己相对于两棵子树在什么时候被访问。点「下一步」开走。 } /> @@ -971,8 +953,7 @@ function buildDfsFrames(order: Exclude): TravFrame[] { } zh={ <> - 叶子 {node.n}:一进门就被访问。它的左右孩子都是空树, - 所以这次调用马上返回。 + 叶子 {node.n}:一进门就被访问。它的左右孩子都是空树,所以这次调用马上返回。 } /> @@ -986,8 +967,7 @@ function buildDfsFrames(order: Exclude): TravFrame[] { } zh={ <> - 进入 {node.n}:前序一进门就访问节点, - 然后才去左、右子树。 + 进入 {node.n}:前序一进门就访问节点,然后才去左、右子树。 } /> @@ -1012,8 +992,7 @@ function buildDfsFrames(order: Exclude): TravFrame[] { } zh={ <> - 叶子 {node.n}:左子树是空树(也算「走完了」), - 所以此刻访问它自己,右子树同样是空。 + 叶子 {node.n}:左子树是空树(也算「走完了」),所以此刻访问它自己,右子树同样是空。 } /> @@ -1027,8 +1006,7 @@ function buildDfsFrames(order: Exclude): TravFrame[] { } zh={ <> - {node.n} 的左子树全部走完 —— 中序此刻访问节点, - 位置在两棵子树之间,然后去右子树。 + {node.n} 的左子树全部走完 —— 中序此刻访问节点,位置在两棵子树之间,然后去右子树。 } /> @@ -1095,8 +1073,7 @@ function buildDfsFrames(order: Exclude): TravFrame[] { } zh={ <> - 完成。{label.zh}的序列是 [{out.join(", ")}]。 - 调用栈最深只到过 3 层 —— 恰好是树高加一。 + 完成。{label.zh}的序列是 [{out.join(", ")}]。调用栈最深只到过 3 层 —— 恰好是树高加一。 } /> @@ -1128,8 +1105,7 @@ function buildBfsFrames(): TravFrame[] { zh={ <> 层序(BFS):根 1 入队。规则只有一条: - 从队首取出一个、访问它、把它的孩子放到队尾。 - 先进先出保证一层处理完才轮到下一层。 + 从队首取出一个、访问它、把它的孩子放到队尾。先进先出保证一层处理完才轮到下一层。 } /> @@ -1203,8 +1179,7 @@ function buildBfsFrames(): TravFrame[] { } zh={ <> - 队列空,遍历结束:[{out.join(", ")}] —— 正好一层一层、从左到右。 - 队列最长时装下了一整层(4 个),所以额外空间是 O(w), + 队列空,遍历结束:[{out.join(", ")}] —— 正好一层一层、从左到右。队列最长时装下了一整层(4 个),所以额外空间是 O(w), w 是最宽那一层的宽度。 } @@ -1359,8 +1334,7 @@ const D_FRAMES: DFrame[] = [ zh={ <> 函数的承诺:maxDepth(node) 返回「从 node 往下到叶子的最长路径上有几个节点」 - ,并且 maxDepth(null) = 0。于是 maxDepth(node) = 1 + max(左边的答案, - 右边的答案)。这棵树是 [3, 9, 20, null, null, 15, 7]。 + ,并且 maxDepth(null) = 0。于是 maxDepth(node) = 1 + max(左边的答案,右边的答案)。这棵树是 [3, 9, 20, null, null, 15, 7]。 } /> @@ -1384,8 +1358,7 @@ const D_FRAMES: DFrame[] = [ } zh={ <> - 9 是叶子:左右都是空树,各报 0,于是 1 + max(0, 0) = 1, - 把 1 报给父节点。 + 9 是叶子:左右都是空树,各报 0,于是 1 + max(0, 0) = 1,把 1 报给父节点。 } /> @@ -1479,8 +1452,7 @@ const D_FRAMES: DFrame[] = [ } zh={ <> - 根也收齐了:1 + max(1, 2) = 3。答案是从叶子一层层「长」上来的, - 不是从根「数」下去的 —— 这就是自底向上。时间 O(n),栈空间 O(h)。 + 根也收齐了:1 + max(1, 2) = 3。答案是从叶子一层层「长」上来的,不是从根「数」下去的 —— 这就是自底向上。时间 O(n),栈空间 O(h)。 } /> @@ -1560,9 +1532,7 @@ const I_FRAMES: IFrame[] = [ zh={ <> 目标:把每个节点的左右孩子互换,整棵树镜像。函数的承诺: - invertTree(node) 返回「同一棵子树,但已镜像」。 - 做法:交换根的两个孩子,再让递归去镜像两棵子树。 - 交换写在两次递归调用之前还是之后,结果都一样。 + invertTree(node) 返回「同一棵子树,但已镜像」。做法:交换根的两个孩子,再让递归去镜像两棵子树。交换写在两次递归调用之前还是之后,结果都一样。 } /> @@ -1632,9 +1602,7 @@ const I_FRAMES: IFrame[] = [ } zh={ <> - 叶子没有孩子,invertTree(null) 直接返回 —— 完成。 - 新树的层序是 [4, 7, 2, 9, 6, 3, 1],处处是原树的镜像。 - 每个节点只交换一次:时间 O(n),栈空间 O(h)。 + 叶子没有孩子,invertTree(null) 直接返回 —— 完成。新树的层序是 [4, 7, 2, 9, 6, 3, 1],处处是原树的镜像。每个节点只交换一次:时间 O(n),栈空间 O(h)。 } /> @@ -1698,9 +1666,7 @@ const M_FRAMES: MFrame[] = [ } zh={ <> - 对称的意思是左子树和右子树互为镜像。 - 这是「两棵子树之间」的关系,单参数的 f(node) 表达不了, - 所以把递归升级成双参数 check(L, R),让两边沿镜像路线同步走。 + 对称的意思是左子树和右子树互为镜像。这是「两棵子树之间」的关系,单参数的 f(node) 表达不了,所以把递归升级成双参数 check(L, R),让两边沿镜像路线同步走。 } /> @@ -1783,9 +1749,7 @@ const M_FRAMES: MFrame[] = [ } zh={ <> - check(2, 2) 收到外侧、内侧两个 true,于是返回 true:这棵树对称。 - 任何一步出现「值不等」或「一边空一边不空」,false 都会一路传回顶层。 - 时间 O(n),栈空间 O(h)。 + check(2, 2) 收到外侧、内侧两个 true,于是返回 true:这棵树对称。任何一步出现「值不等」或「一边空一边不空」,false 都会一路传回顶层。时间 O(n),栈空间 O(h)。 } /> @@ -1884,8 +1848,7 @@ const L_FRAMES: LFrame[] = [ } zh={ <> - 第 1 层:size = 1。出队 3 并收进本层;孩子 9、20 入队。 - 本层 1 个处理完 → 第 1 层 = [3] 结束。 + 第 1 层:size = 1。出队 3 并收进本层;孩子 9、20 入队。本层 1 个处理完 → 第 1 层 = [3] 结束。 } /> @@ -1907,8 +1870,7 @@ const L_FRAMES: LFrame[] = [ } zh={ <> - 第 2 层:size = 2,先记下来。从现在起入队的孩子都不算这一层。 - 出队 9:它是叶子,没有孩子入队。 + 第 2 层:size = 2,先记下来。从现在起入队的孩子都不算这一层。出队 9:它是叶子,没有孩子入队。 } /> @@ -1930,8 +1892,7 @@ const L_FRAMES: LFrame[] = [ } zh={ <> - 出队 20,孩子 15、7 入队。本层 2 个处理完 → 第 2 层 = [9, 20]。 - 注意 15、7 虽然已经在队列里,但 size 早就定死为 2,它们只能等下一轮。 + 出队 20,孩子 15、7 入队。本层 2 个处理完 → 第 2 层 = [9, 20]。注意 15、7 虽然已经在队列里,但 size 早就定死为 2,它们只能等下一轮。 } /> @@ -1978,9 +1939,7 @@ const L_FRAMES: LFrame[] = [ } zh={ <> - 结果 [[3], [9, 20], [15, 7]]。没有「先记 size」这一步, - 队列只会给你一维序列,层与层的边界就丢了。 - 所有「按层处理」的题目都要用到这一步。 + 结果 [[3], [9, 20], [15, 7]]。没有「先记 size」这一步,队列只会给你一维序列,层与层的边界就丢了。所有「按层处理」的题目都要用到这一步。 } /> diff --git a/app/bst/page.tsx b/app/bst/page.tsx index 1628169..99e3000 100644 --- a/app/bst/page.tsx +++ b/app/bst/page.tsx @@ -88,8 +88,7 @@ const F98: TreeFrame[] = [ ), zh: ( <> - 正解:给每个节点发一张「合法区间」通行证。根没有任何祖先约束, - 区间是 (-∞, +∞),10 当然合法。 + 正解:给每个节点发一张「合法区间」通行证。根没有任何祖先约束,区间是 (-∞, +∞),10 当然合法。 ), }, @@ -107,8 +106,7 @@ const F98: TreeFrame[] = [ ), zh: ( <> - 往左走:左子树全体必须小于 10,所以上界收紧为 10。 - 5 ∈ (-∞, 10) ✓ + 往左走:左子树全体必须小于 10,所以上界收紧为 10。5 ∈ (-∞, 10) ✓ ), }, @@ -126,8 +124,7 @@ const F98: TreeFrame[] = [ ), zh: ( <> - 往右走:右子树全体必须大于 10,所以下界收紧为 10。 - 15 ∈ (10, +∞) ✓ + 往右走:右子树全体必须大于 10,所以下界收紧为 10。15 ∈ (10, +∞) ✓ ), }, @@ -146,8 +143,7 @@ const F98: TreeFrame[] = [ ), zh: ( <> - 15 的左孩子:区间收成 (10, 15) —— 既要小于 15(父节点), - 又要大于 10(祖父节点)。6 越过下界 10,验证失败。 + 15 的左孩子:区间收成 (10, 15) —— 既要小于 15(父节点),又要大于 10(祖父节点)。6 越过下界 10,验证失败。 ), }, @@ -169,8 +165,7 @@ const F98: TreeFrame[] = [ zh: ( <> 复盘:6 只和父节点 15 比是合格的,但它住在 10 的右子树里,必须大于 10。 - 「只查父子」会漏掉祖先的约束 —— 上下界法把祖先的要求一路传下来, - 谁也逃不掉。 + 「只查父子」会漏掉祖先的约束 —— 上下界法把祖先的要求一路传下来,谁也逃不掉。 ), }, @@ -390,8 +385,7 @@ const F108: ArrayFrame[] = [ ), zh: ( <> - 最后 [9] → 5 的右孩子。完成:5 个节点、树高 2 = ⌊log₂5⌋(按边数); - 每个元素恰好被用一次 → O(n) 建树。 + 最后 [9] → 5 的右孩子。完成:5 个节点、树高 2 = ⌊log₂5⌋(按边数);每个元素恰好被用一次 → O(n) 建树。 ), }, @@ -445,9 +439,7 @@ export default function BSTChapter() { ), zh: ( <> - 在二叉树上立下一条规矩:左 < 根 < 右, - 而且要对整棵子树成立,不只是对两个孩子。 - 从此每次比较都能整棵扔掉一边的子树 —— + 在二叉树上立下一条规矩:左 < 根 < 右,而且要对整棵子树成立,不只是对两个孩子。从此每次比较都能整棵扔掉一边的子树 —— 它把二分查找,长在了一棵随时可以插入删除的树上。 ), @@ -486,13 +478,8 @@ export default function BSTChapter() { } zh={

- 先回顾两种已学结构各自的长处。有序数组查找极快: - 二分每次排除一半,O(log n);但插入一个新值得先腾位置 —— - 右边所有元素集体后移,O(n)。链表正相反: - 只要已经站在位置上,接一个节点只改两根指针,O(1); - 可想找某个值,只能从头一路问过去,O(n)。 - 链表连二分都做不了 —— 它没有 O(1) 随机访问, - 「跳到中间」这一步本身就要 O(n)。 + 先回顾两种已学结构各自的长处。有序数组查找极快:二分每次排除一半,O(log n);但插入一个新值得先腾位置 —— + 右边所有元素集体后移,O(n)。链表正相反:只要已经站在位置上,接一个节点只改两根指针,O(1);可想找某个值,只能从头一路问过去,O(n)。链表连二分都做不了 —— 它没有 O(1) 随机访问,「跳到中间」这一步本身就要 O(n)。

} /> @@ -599,12 +586,7 @@ export default function BSTChapter() { } zh={

- BST 的主意:把「二分」的判断过程固化成树的形状。 - 想象一座图书馆:进门的导览牌写着「A–M 往左,N–Z 往右」;走进左区, - 又有一块牌子「A–F 往左,G–M 往右」…… 每读一块牌子, - 要找的范围就少掉一大块。BST 的每个节点就是一块这样的导览牌; - 而且因为节点之间用的是指针(第 3 章链表教的), - 插一块新牌子不需要移动任何已有的牌子。 + BST 的主意:把「二分」的判断过程固化成树的形状。想象一座图书馆:进门的导览牌写着「A–M 往左,N–Z 往右」;走进左区,又有一块牌子「A–F 往左,G–M 往右」……每读一块牌子,要找的范围就少掉一大块。BST 的每个节点就是一块这样的导览牌;而且因为节点之间用的是指针(第 3 章链表教的),插一块新牌子不需要移动任何已有的牌子。

} /> @@ -657,10 +639,8 @@ export default function BSTChapter() { } zh={

- 每到一个节点只问一次「大还是小」,另一边的子树整棵被扔掉。 - 比较次数 = 走过的路径上的节点数 ≤ h + 1 - (h 条边的路径串着 h + 1 个节点)。 - 树平衡时,每一步扔掉的大约就是剩余节点的一半。 + 每到一个节点只问一次「大还是小」,另一边的子树整棵被扔掉。比较次数 = 走过的路径上的节点数 ≤ h + 1 + (h 条边的路径串着 h + 1 个节点)。树平衡时,每一步扔掉的大约就是剩余节点的一半。

} /> @@ -681,8 +661,7 @@ export default function BSTChapter() { } zh={

- 插入:沿查找路线走到空位,挂上去,改一根指针。 - 删除:最多牵动一条路径。没有任何「集体后移」—— + 插入:沿查找路线走到空位,挂上去,改一根指针。删除:最多牵动一条路径。没有任何「集体后移」—— 这是从链表那里继承来的性质。

} @@ -711,10 +690,7 @@ export default function BSTChapter() { } zh={

- 印刷版字典有序但改不动:要加一个词,只能重排再版。 - 哈希表正相反:存取极快,但遍历得到的顺序没有意义。 - BST 是一部活页字典:随时插新页,而且任何时刻按顺序翻阅 - (中序遍历)都是排好序的。需求里同时出现 + 印刷版字典有序但改不动:要加一个词,只能重排再版。哈希表正相反:存取极快,但遍历得到的顺序没有意义。BST 是一部活页字典:随时插新页,而且任何时刻按顺序翻阅(中序遍历)都是排好序的。需求里同时出现 数据会变和要有顺序时,答案基本就是树结构。

} @@ -755,8 +731,7 @@ export default function BSTChapter() { 上一章学了四种遍历。对 BST 来说,其中一种格外重要: 中序遍历(inorder,左 → 根 → 右)输出的序列必然升序 。为什么?把树画出来就明白了 —— - 规矩保证左子树全体在根的左边、右子树全体在根的右边, - 所以每个节点的水平位置天然就是它的排序位次: + 规矩保证左子树全体在根的左边、右子树全体在根的右边,所以每个节点的水平位置天然就是它的排序位次:

} /> @@ -790,18 +765,11 @@ export default function BSTChapter() { zh={ <>

- 这条性质怎么用?正反两个方向都用得上。 - 想按顺序拿到 BST 里的数据,中序遍历即可, - 不需要额外排序;想验证一棵树是不是 BST, - 看它的中序序列是否严格递增;想找「第 k 小」,中序数到第 k 个。 - 本章一半的题目都建立在这一条性质上。 + 这条性质怎么用?正反两个方向都用得上。想按顺序拿到 BST 里的数据,中序遍历即可, + 不需要额外排序;想验证一棵树是不是 BST,看它的中序序列是否严格递增;想找「第 k 小」,中序数到第 k 个。本章一半的题目都建立在这一条性质上。

- 再看查找。在下面的实验室里输入一个数字点「查找」, - 你会看到它从根出发,每一步比较后只往一边走。 - 也试试插入:新值总是落在「查找失败的那个空位」上。最后, - 务必点一次「顺序插入 1→5」: - 亲眼看看规矩没变、速度却没了的样子。 + 再看查找。在下面的实验室里输入一个数字点「查找」,你会看到它从根出发,每一步比较后只往一边走。也试试插入:新值总是落在「查找失败的那个空位」上。最后,务必点一次「顺序插入 1→5」:亲眼看看规矩没变、速度却没了的样子。

} @@ -829,9 +797,7 @@ export default function BSTChapter() { } zh={

- 顺序插入时每个新值都往同一边拐,树斜成一条链: - 高度 h 从大约 log n 恶化到 n − 1,查找从「整棵扔掉子树」 - 退化成「逐个检查」—— 和链表一模一样。 + 顺序插入时每个新值都往同一边拐,树斜成一条链:高度 h 从大约 log n 恶化到 n − 1,查找从「整棵扔掉子树」退化成「逐个检查」—— 和链表一模一样。 规矩(左小右大)只保证正确性,不保证形状。 管形状的是 §05 的平衡树。

@@ -986,17 +952,13 @@ export default function BSTChapter() { zh={ <>

- 为什么全都写 O(h) 而不是 O(log n)? - 因为 h(树高)是个变量。和第 7 章一样, - 树高按边数计:只有根时 h = 0。完全平衡时 h = ⌊log₂n⌋ - —— 每层能装的节点数是上一层的两倍;顺序插入退化成链时 h = n − 1。 - 不加条件地说 O(log n) 是错的。完整答案是: + 为什么全都写 O(h) 而不是 O(log n)?因为 h(树高)是个变量。和第 7 章一样,树高按边数计:只有根时 h = 0。完全平衡时 h = ⌊log₂n⌋ + —— 每层能装的节点数是上一层的两倍;顺序插入退化成链时 h = n − 1。不加条件地说 O(log n) 是错的。完整答案是: O(h),平衡时 log n、最坏 n,工程用红黑树把 h 钉在 log n。

查找和插入你已经在实验室亲手做过了。真正的难点是 - 删除:挖掉一个节点会在树上留下一个洞, - 怎么补洞才能不破坏「左小右大」?按被删节点的孩子数量分三种情况: + 删除:挖掉一个节点会在树上留下一个洞,怎么补洞才能不破坏「左小右大」?按被删节点的孩子数量分三种情况:

} @@ -1100,8 +1062,7 @@ export default function BSTChapter() { zh={ <> 70 只有一个孩子 80:让父节点 50 直接接管 80 - (就像链表里跳过一个节点)。 - 80 那一支本来就全部大于 50,接上来规矩依旧成立。 + (就像链表里跳过一个节点)。80 那一支本来就全部大于 50,接上来规矩依旧成立。 } /> @@ -1165,8 +1126,7 @@ export default function BSTChapter() { zh={ <> 50 左右都有子树,哪个孩子都不能直接顶上。找 - 中序后继 60(右子树里最小的): - 把 60 的值抄给根,再去右子树删掉原来的 60。 + 中序后继 60(右子树里最小的):把 60 的值抄给根,再去右子树删掉原来的 60。 } /> @@ -1198,14 +1158,10 @@ export default function BSTChapter() {

情况 ③ 的两个「为什么」值得掰开。 为什么后继能当替身? - 中序后继是「恰好比被删值大的下一个数」,中间再没有别的键。 - 它顶上之后,左子树全体仍比它小(它比被删值还大), - 右子树剩余全体仍比它大(它本来就是右子树里最小的)—— + 中序后继是「恰好比被删值大的下一个数」,中间再没有别的键。它顶上之后,左子树全体仍比它小(它比被删值还大),右子树剩余全体仍比它大(它本来就是右子树里最小的)—— 两边的顺序都不破,换成别的键就做不到。 为什么删后继很容易? - 后继 = 从右孩子一路向左的尽头,它必然没有左孩子, - 删它必落入情况 ① 或 ②,递归不会没完没了。 - 对称地,用中序前驱(左子树最大值)也完全可行。 + 后继 = 从右孩子一路向左的尽头,它必然没有左孩子,删它必落入情况 ① 或 ②,递归不会没完没了。对称地,用中序前驱(左子树最大值)也完全可行。

} /> @@ -1232,9 +1188,7 @@ export default function BSTChapter() { zh={

叶子直接删;单孩子让孩子顶;双孩子值换后继、删除转到右子树 - —— 把「删中间的节点」降级成「删边缘的节点」。 - 总代价:定位 + 找后继 + 再删一次, - 全程走的还是一条向下的路径,O(h)。 + —— 把「删中间的节点」降级成「删边缘的节点」。总代价:定位 + 找后继 + 再删一次,全程走的还是一条向下的路径,O(h)。

} /> @@ -1272,8 +1226,7 @@ export default function BSTChapter() { 节点还是二叉树章的 TreeNode(值 + 左右孩子指针)。四个方法里, insert 和 delete 用递归写:注意它们都 返回「修补后的子树根」,由上一层接住 —— - 这个「返回自己让父节点重新牵手」的模式, - 是递归改树的标准做法,好处是不需要专门记录父节点。 + 这个「返回自己让父节点重新牵手」的模式,是递归改树的标准做法,好处是不需要专门记录父节点。

} /> @@ -1424,8 +1377,7 @@ class BST { zh: ( <> 细节:deleteAt 里「叶子」被并进了「只有右孩子」—— - 叶子的 right 是 null,返回它正好等于返回 null。 - 两行代码盖住三种情况。 + 叶子的 right 是 null,返回它正好等于返回 null。两行代码盖住三种情况。 ), }, @@ -1580,8 +1532,7 @@ class BST: <> 易错点:CPython 默认递归深度限制约 1000 —— 退化成链的 BST 上,递归查找可能超限。树可能很深时, - search / insert 写成迭代更稳;delete 因为要修补父子链, - 递归写法最顺手。 + search / insert 写成迭代更稳;delete 因为要修补父子链,递归写法最顺手。 ), }, @@ -1745,8 +1696,7 @@ class BST { zh: ( <> 提醒:比较用 ===;若存的是字符串, - < 会按字典序比较 —— 想按数值比记得先转换, - 或者把比较函数抽出来作为构造参数(工程写法)。 + < 会按字典序比较 —— 想按数值比记得先转换,或者把比较函数抽出来作为构造参数(工程写法)。 ), }, @@ -1786,12 +1736,8 @@ class BST { zh={

§02 的实验室已经演示过: - 有序输入会把 BST 养成一条链。 - 而现实数据偏偏经常有序 —— 按时间戳写入日志、按自增 id 插入记录、 - 按字母序导入词表…… 裸 BST 在生产环境几乎必然退化。 - 解法的思路很直接:插入删除后,如果某处一边太深,就 - 旋转把它扶正。不同的平衡树, - 区别只在「怎么定义太深」和「歪到什么程度才动手」。 + 有序输入会把 BST 养成一条链。而现实数据偏偏经常有序 —— 按时间戳写入日志、按自增 id 插入记录、按字母序导入词表……裸 BST 在生产环境几乎必然退化。解法的思路很直接:插入删除后,如果某处一边太深,就 + 旋转把它扶正。不同的平衡树,区别只在「怎么定义太深」和「歪到什么程度才动手」。

} /> @@ -1822,8 +1768,7 @@ class BST { zh={

AVL(1962,以发明者 Adelson-Velsky 和 Landis 命名)给每个节点定义 - 平衡因子(balance factor)= 左子树高 − 右子树高, - 并要求任何节点的平衡因子 ∈ {"{-1, 0, 1}"}。一旦插入让某个节点的 + 平衡因子(balance factor)= 左子树高 − 右子树高,并要求任何节点的平衡因子 ∈ {"{-1, 0, 1}"}。一旦插入让某个节点的 |BF| 达到 2,立刻旋转修复。看最小的例子 —— 依次插入 3、2、1:

} @@ -1866,8 +1811,7 @@ class BST { zh={ <> 3 的左子树高 1(按边数),右子树为空、记作 −1: - BF = 1 − (−1) = +2,超标。 - 失衡形状是「左左」—— 解法:右旋。 + BF = 1 − (−1) = +2,超标。失衡形状是「左左」—— 解法:右旋。 } /> @@ -1912,9 +1856,7 @@ class BST { } zh={ <> - 右旋 = 让左孩子 2 当新根,3 降级成它的右孩子。 - 转完中序还是 1, 2, 3 —— 旋转改形状,不改顺序, - 这是它合法的根本原因。 + 右旋 = 让左孩子 2 当新根,3 降级成它的右孩子。转完中序还是 1, 2, 3 —— 旋转改形状,不改顺序,这是它合法的根本原因。 } /> @@ -1937,10 +1879,7 @@ class BST { } zh={

- 真实的 AVL 还有「左右 / 右左」等组合形状,需要两次旋转, - 思路相同:把三个值里居中的那个转上来当根。 - AVL 是严格的那一派 —— 高度始终贴近 log n,查找最快; - 代价落在写入上。 + 真实的 AVL 还有「左右 / 右左」等组合形状,需要两次旋转,思路相同:把三个值里居中的那个转上来当根。AVL 是严格的那一派 —— 高度始终贴近 log n,查找最快;代价落在写入上。

} /> @@ -2013,16 +1952,11 @@ class BST {

- 这五条合起来推出一个漂亮的结论:最长路径最多「黑红相间」, - 最短路径可以「全黑」,而两者黑节点数相同(规矩 ⑤)—— - 所以最长路径 ≤ 最短路径 × 2, - 高度被锁死在 O(log n) 量级。它允许树有点歪, - 换来的是每次更新只需常数次旋转:插入最多 2 次,删除最多 3 次。 - AVL 的插入最多需要一次单旋或一次双旋(即最多 2 次单旋),但 AVL 的删除 + 这五条合起来推出一个漂亮的结论:最长路径最多「黑红相间」,最短路径可以「全黑」,而两者黑节点数相同(规矩 ⑤)—— + 所以最长路径 ≤ 最短路径 × 2,高度被锁死在 O(log n) 量级。它允许树有点歪,换来的是每次更新只需常数次旋转:插入最多 2 次,删除最多 3 次。AVL 的插入最多需要一次单旋或一次双旋(即最多 2 次单旋),但 AVL 的删除 可能一路回溯到根、每层都要调整。 不追求完美平衡,只追求足够平衡 —— - 这是典型的工程取舍,也是它进入各家标准库的原因。 - 读多写少选 AVL,读写混合选红黑树。 + 这是典型的工程取舍,也是它进入各家标准库的原因。读多写少选 AVL,读写混合选红黑树。

} @@ -2048,11 +1982,7 @@ class BST { } zh={

- 1978 年 Guibas 和 Sedgewick 在施乐帕克研究中心发表了这套结构。 - 据 Sedgewick 本人回忆,颜色来自实验室的打印机: - 它能印红、黑两色,论文里用红色标注特殊节点最醒目, - 名字就这么定了。一台打印机的墨, - 决定了此后五十年教科书的配色。 + 1978 年 Guibas 和 Sedgewick 在施乐帕克研究中心发表了这套结构。据 Sedgewick 本人回忆,颜色来自实验室的打印机:它能印红、黑两色,论文里用红色标注特殊节点最醒目,名字就这么定了。一台打印机的墨,决定了此后五十年教科书的配色。

} /> @@ -2085,9 +2015,7 @@ class BST {

要不要用树,只由一个问题决定:需不需要顺序? 只做单点查找(这个 key 在不在、对应值是什么),哈希表更快 —— - 平均 O(1) 对树的 O(log n)。 - 只有当需求里出现范围查询、找某个值上下最近的 key、 - 按 key 顺序遍历时,才该选平衡 BST —— + 平均 O(1) 对树的 O(log n)。只有当需求里出现范围查询、找某个值上下最近的 key、按 key 顺序遍历时,才该选平衡 BST —— 这几件事哈希表都做不到,除非把全部数据取出来重新排序。

} @@ -2199,8 +2127,7 @@ class BST { } zh={ <> - Map 只保留插入顺序; - 做题时用「数组 + 二分」顶替,或者自己手写一棵树 + Map 只保留插入顺序;做题时用「数组 + 二分」顶替,或者自己手写一棵树 } /> @@ -2333,9 +2260,7 @@ bisect.insort(arr, 25) # 插入 O(n) —— list 底层还是数组`, <> 这一点要说准:bisect.insort{" "} 查得快,但插入仍是 O(n) —— list 是动态数组(第 1 章的老账)。 - SortedList 写入快得多,是因为它把值分散在许多小块里, - 插入只搬动其中一小块;但它不是平衡树, - 插入在理论上也不是 O(log n),只是在做题和一般业务负载下够快、够省事。 + SortedList 写入快得多,是因为它把值分散在许多小块里,插入只搬动其中一小块;但它不是平衡树,插入在理论上也不是 O(log n),只是在做题和一般业务负载下够快、够省事。 ), }, @@ -2397,8 +2322,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) ), zh: ( <> - 易错点:普通对象的键遍历顺序有一套自己的规则 - (整数型键升序、字符串键按插入顺序),不要拿它当有序容器 —— + 易错点:普通对象的键遍历顺序有一套自己的规则(整数型键升序、字符串键按插入顺序),不要拿它当有序容器 —— 需要有序就显式排序,或者用二分维护。 ), @@ -2438,15 +2362,10 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) } zh={

- MySQL(InnoDB)的索引是 B+ 树 —— 同样是有序树, - 为什么不用内存里更快的红黑树?因为场景变了:数据在磁盘上, - 而磁盘按「页」(通常 16KB)整块读取,读 1 字节和读 16KB 代价几乎一样。 - 红黑树一个节点存一个 key,树高约 log₂n - (百万数据一次查询要走约 20 个节点),意味着最多 20 次磁盘读取。 - B+ 树则让一个节点装满 + MySQL(InnoDB)的索引是 B+ 树 —— 同样是有序树,为什么不用内存里更快的红黑树?因为场景变了:数据在磁盘上,而磁盘按「页」(通常 16KB)整块读取,读 1 字节和读 16KB 代价几乎一样。红黑树一个节点存一个 key,树高约 log₂n + (百万数据一次查询要走约 20 个节点),意味着最多 20 次磁盘读取。B+ 树则让一个节点装满 一整页的几百个 key,分叉数几百,百万数据只需 3~4 层 —— - 矮胖的树 = 极少的读取次数。此外 B+ 树把数据全放叶子层、 - 叶子之间用链表串起来:范围扫描(WHERE id BETWEEN …) + 矮胖的树 = 极少的读取次数。此外 B+ 树把数据全放叶子层、叶子之间用链表串起来:范围扫描(WHERE id BETWEEN …) 沿链表顺序读就行,不用在树上跳来跳去。一句话: 红黑树为内存的随机访问而生,B+ 树为磁盘的按页读取而生 —— 结构没有优劣,只有适不适合当前的介质。 @@ -2494,8 +2413,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) 利用中序 = 升序(第 k 小、最小差、验证、恢复);②{" "} 利用比较扔掉子树 (搜索、插入、删除、最近公共祖先、范围和的剪枝);③{" "} - 反向构造(把有序数据变成平衡 BST)。 - 三道精讲每个套路各占一道。 + 反向构造(把有序数据变成平衡 BST)。三道精讲每个套路各占一道。

} /> @@ -2533,9 +2451,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) zh={

题意:判断一棵二叉树是否为合法 BST。 - 常见错误:几乎每个人的第一版都是「检查每个节点比左孩子大、 - 比右孩子小」——这是错的。 - 规矩管的是整棵子树,不是父子两个人。看这个专门击穿它的反例: + 常见错误:几乎每个人的第一版都是「检查每个节点比左孩子大、比右孩子小」——这是错的。规矩管的是整棵子树,不是父子两个人。看这个专门击穿它的反例:

} /> @@ -2594,8 +2510,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) zh: ( <> 细节:界用 long,因为节点值可能取到{" "} - Integer.MIN_VALUE / MAX_VALUE, - 用 int 当边界会把合法的树判错 —— 面试时写出这一步,回答会更扎实。 + Integer.MIN_VALUE / MAX_VALUE,用 int 当边界会把合法的树判错 —— 面试时写出这一步,回答会更扎实。 ), }, @@ -2678,8 +2593,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) ), zh: ( <> - 顺手:JS 的 ±Infinity 跟任何数比较都符合预期, - 边界处理最省心。 + 顺手:JS 的 ±Infinity 跟任何数比较都符合预期,边界处理最省心。 ), }, @@ -2708,10 +2622,8 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) } zh={

- 每个节点检查一次:时间 O(n),空间 O(h) 递归栈。追问一: - 「另一种解法?」—— 中序遍历,检查序列是否严格递增 - (维护 prev,一旦 cur ≤ prev 即失败),原理就是 §02 的性质, - 两种都要会。追问二:「为什么区间是开区间?」—— + 每个节点检查一次:时间 O(n),空间 O(h) 递归栈。追问一:「另一种解法?」—— 中序遍历,检查序列是否严格递增 + (维护 prev,一旦 cur ≤ prev 即失败),原理就是 §02 的性质,两种都要会。追问二:「为什么区间是开区间?」—— 题目要求严格小于 / 大于,等号也算违规,重复值不合法。

} @@ -2753,8 +2665,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) 题意:返回 BST 中第 k 小的元素。暴力: 任意遍历收集所有值、排序取第 k 个 —— O(n log n),完全没用上 BST。 为什么用中序:排序在建树时就已经完成了 —— - 中序遍历就是按升序逐个吐数, - 我们只需要一边遍历一边数数,数到 k 立刻停: + 中序遍历就是按升序逐个吐数,我们只需要一边遍历一边数数,数到 k 立刻停:

} /> @@ -2861,9 +2772,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) ), zh: ( <> - 为什么用显式栈:弹出第 k 个节点时循环立即返回, - 而且不受递归深度限制,这一点在 Python 里尤其重要(默认上限 1000)。 - 同一段栈模板也是 LC 173(BST 迭代器)的答案。 + 为什么用显式栈:弹出第 k 个节点时循环立即返回,而且不受递归深度限制,这一点在 Python 里尤其重要(默认上限 1000)。同一段栈模板也是 LC 173(BST 迭代器)的答案。 ), }, @@ -2929,12 +2838,10 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) } zh={

- 时间 O(h + k):先沉到最左 O(h),再吐出 k 个;空间 O(h)。 - 经典追问:「如果频繁插入删除,还要频繁查第 k 小呢?」—— + 时间 O(h + k):先沉到最左 O(h),再吐出 k 个;空间 O(h)。经典追问:「如果频繁插入删除,还要频繁查第 k 小呢?」—— 在每个节点上缓存左子树的节点数:查询时若 k ≤ leftSize 往左; k = leftSize + 1 就是自己;否则带着 k − leftSize − 1 往右 —— - 每次 O(h),插入删除时顺路维护计数即可。 - 这就是把二分查找直接做在树上。 + 每次 O(h),插入删除时顺路维护计数即可。这就是把二分查找直接做在树上。

} /> @@ -2975,8 +2882,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n)

题意:把升序数组变成一棵高度平衡的 BST。反面教材: 把元素逐个 insert —— 输入有序,§02 实验室演过,直接退化成链。 - 正解:平衡的本质是「左右节点数均等」, - 而有序数组里谁站中间一目了然: + 正解:平衡的本质是「左右节点数均等」,而有序数组里谁站中间一目了然: 取中点当根,左右两半递归建子树。

} @@ -3046,10 +2952,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) } zh={

- 取中点后,左右两半的长度最多差 1;递归的每一层都维持这个性质, - 于是任何节点的左右子树节点数最多差 1,高度差自然不超过 1。 - 这其实是把「二分查找的决策树」显式地盖了出来:mid 是根, - 两半是子树,二分可能走的每条路都成了树上的一条边。 + 取中点后,左右两半的长度最多差 1;递归的每一层都维持这个性质,于是任何节点的左右子树节点数最多差 1,高度差自然不超过 1。这其实是把「二分查找的决策树」显式地盖了出来:mid 是根,两半是子树,二分可能走的每条路都成了树上的一条边。

} /> @@ -3166,12 +3069,9 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) } zh={

- 每个元素恰好当一次根:时间 O(n),空间 O(log n) 递归栈。 - 追问:「输入换成有序链表呢?」(LC 109)—— - 链表找中点要 O(n),于是有两个思路:每次用快慢指针找中点 - (总 O(n log n));或者反过来用「中序位置法」—— - 先数出长度,再按中序顺序边递归边消费链表节点,依然 O(n)。 - 能把这一层讲清楚,这组题就都能解决了。 + 每个元素恰好当一次根:时间 O(n),空间 O(log n) 递归栈。追问:「输入换成有序链表呢?」(LC 109)—— + 链表找中点要 O(n),于是有两个思路:每次用快慢指针找中点(总 O(n log n));或者反过来用「中序位置法」—— + 先数出长度,再按中序顺序边递归边消费链表节点,依然 O(n)。能把这一层讲清楚,这组题就都能解决了。

} /> @@ -3242,8 +3142,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) ), zh: ( <> - 中序遍历 = 升序:第 k 小、最小差、验证、恢复…… - BST 一大半的题,钥匙都是这一条。 + 中序遍历 = 升序:第 k 小、最小差、验证、恢复……BST 一大半的题,钥匙都是这一条。 ), }, @@ -3259,8 +3158,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) ), zh: ( <> - 查找 / 插入 / 删除都是 O(h)(树高按边数计): - 完全平衡时 h = ⌊log₂n⌋,一般的平衡树 h = O(log n),有序插入退化时 h = n − 1 —— + 查找 / 插入 / 删除都是 O(h)(树高按边数计):完全平衡时 h = ⌊log₂n⌋,一般的平衡树 h = O(log n),有序插入退化时 h = n − 1 —— 说复杂度带上 h,或者把条件说清楚。 ), @@ -3297,9 +3195,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) zh: ( <> 工程中不会直接使用无自平衡机制的 BST:Java 有{" "} - TreeMap / TreeSet(红黑树, - 足够平衡就好)、Python 用第三方 sortedcontainers、 - JS 无内置;磁盘上的数据库索引则换 B+ 树 —— + TreeMap / TreeSet(红黑树,足够平衡就好)、Python 用第三方 sortedcontainers、JS 无内置;磁盘上的数据库索引则换 B+ 树 —— 矮胖省读取次数,叶子链表利于范围扫描。 ), @@ -3316,8 +3212,7 @@ arr.splice(lowerBound(arr, 25), 0, 25); // 有序插入,搬移 O(n) zh: ( <> 哈希表还是 BST,只看一个问题:需不需要顺序? - 单点查找选哈希表;范围查询、找最近的 key、按顺序遍历, - 才轮到有序结构。 + 单点查找选哈希表;范围查询、找最近的 key、按顺序遍历,才轮到有序结构。 ), }, diff --git a/app/bst/viz.tsx b/app/bst/viz.tsx index 413b3d2..175a73b 100644 --- a/app/bst/viz.tsx +++ b/app/bst/viz.tsx @@ -198,8 +198,7 @@ export function BSTLab() { } zh={ <> - {v} 已经在树里 —— 本实现直接忽略重复值, - 工程上更常见的做法是在节点上挂一个计数器。 + {v} 已经在树里 —— 本实现直接忽略重复值,工程上更常见的做法是在节点上挂一个计数器。 } />, @@ -387,9 +386,7 @@ export function BSTLab() { } zh={ <> - 5 个节点,树高 4 —— 树斜成了一条链,查 5 要比较 5 次。 - O(h) 变成了 O(n),和链表一样慢。有序输入是裸 BST 的最坏情况, - 这正是 §05 平衡树要解决的问题。 + 5 个节点,树高 4 —— 树斜成了一条链,查 5 要比较 5 次。O(h) 变成了 O(n),和链表一样慢。有序输入是裸 BST 的最坏情况,这正是 §05 平衡树要解决的问题。 } />, @@ -603,8 +600,7 @@ export function InorderFig() { <> 「左 < 根 < 右」对整棵子树成立 ⇒ 左子树全体 画在根左边、右子树全体画在根右边 ⇒ - 节点的水平位置就是它的排序位次。中序遍历(左 → 根 → 右) - 恰好从左到右逐个读过去,所以输出必然升序 —— + 节点的水平位置就是它的排序位次。中序遍历(左 → 根 → 右)恰好从左到右逐个读过去,所以输出必然升序 —— 这不是巧合,而是规矩的直接推论。 } diff --git a/app/graph/page.tsx b/app/graph/page.tsx index a35eac7..3b72623 100644 --- a/app/graph/page.tsx +++ b/app/graph/page.tsx @@ -82,9 +82,7 @@ export default function GraphChapter() { zh: ( <> 图是一组顶点加一组记录它们之间关系的 - 边。地铁站与线路、人与好友、网页与链接、 - 课程与先修 —— 只要有「东西」和「东西之间的联系」,画出来就是一张图。 - 它也是全书最一般的结构:前面学的链表、树、网格,都是它的特例。 + 边。地铁站与线路、人与好友、网页与链接、课程与先修 —— 只要有「东西」和「东西之间的联系」,画出来就是一张图。它也是全书最一般的结构:前面学的链表、树、网格,都是它的特例。 ), }} @@ -126,8 +124,7 @@ export default function GraphChapter() { <>

先回忆一路走来的结构:数组是一排,链表是 - 一条链,树只向下分叉、从不回头。 - 它们都有同一个限制:现实里的关系常常是 + 一条链,树只向下分叉、从不回头。它们都有同一个限制:现实里的关系常常是 多对多、还能绕回来的。

下面四件每天都在发生的事,用前面的结构都装不下:

@@ -155,9 +152,7 @@ export default function GraphChapter() { } zh={ <> - 每个站是一个点,每段轨道是一条边。 - 换乘站连着好几条线,还能坐一圈绕回原地 —— 有分叉、有环, - 树画不出来。 + 每个站是一个点,每段轨道是一条边。换乘站连着好几条线,还能坐一圈绕回原地 —— 有分叉、有环,树画不出来。 } /> @@ -182,9 +177,7 @@ export default function GraphChapter() { } zh={ <> - 每个人是点,「是好友」是无向边,「关注」是有向边。 - A 的朋友的朋友可能又是 A —— 关系交织成网, - 不是层层向下的树。 + 每个人是点,「是好友」是无向边,「关注」是有向边。A 的朋友的朋友可能又是 A —— 关系交织成网,不是层层向下的树。 } /> @@ -209,8 +202,7 @@ export default function GraphChapter() { } zh={ <> - 每门课是点,「先修」是有向边。数据结构要先学数组, - 操作系统要先学 C 语言 —— + 每门课是点,「先修」是有向边。数据结构要先学数组,操作系统要先学 C 语言 —— 这些「谁必须在谁之前」构成一张有向图。 } @@ -237,8 +229,7 @@ export default function GraphChapter() { zh={ <> 每个网页是点,每个超链接是有向边。Google - 当年就是把整个互联网建成一张巨图, - 靠网页之间的链接关系排出搜索结果(PageRank)。 + 当年就是把整个互联网建成一张巨图,靠网页之间的链接关系排出搜索结果(PageRank)。 } /> @@ -466,10 +457,8 @@ export default function GraphChapter() { } zh={

- 这是本章最该带走的一句话。单链表是「每个点只有一条出边、 - 串成一条直线」的图;树是「连通 + 无环 + 指定了一个根」的图; - 网格是「每个格子是点、上下左右相邻是边」的图。 - 所以你早就在和图打交道了 —— 现在,我们把最一般的那种拿出来单独讲。 + 这是本章最该带走的一句话。单链表是「每个点只有一条出边、串成一条直线」的图;树是「连通 + 无环 + 指定了一个根」的图; + 网格是「每个格子是点、上下左右相邻是边」的图。所以你早就在和图打交道了 —— 现在,我们把最一般的那种拿出来单独讲。

} /> @@ -497,12 +486,7 @@ export default function GraphChapter() { } zh={

- 1736 年,数学家欧拉(Euler)研究「柯尼斯堡七桥问题」: - 能不能一次走遍七座桥、每座只过一次?他把陆地抽象成点、 - 桥抽象成边,证明了这不可能 —— 图论就此诞生。 - 两百多年后,同样的「点 + 边」抽象撑起了导航、社交、编译器、 - 芯片布线和整个互联网。把复杂现实抽象成点和边, - 是计算机科学最有用的思维工具之一。 + 1736 年,数学家欧拉(Euler)研究「柯尼斯堡七桥问题」:能不能一次走遍七座桥、每座只过一次?他把陆地抽象成点、桥抽象成边,证明了这不可能 —— 图论就此诞生。两百多年后,同样的「点 + 边」抽象撑起了导航、社交、编译器、芯片布线和整个互联网。把复杂现实抽象成点和边,是计算机科学最有用的思维工具之一。

} /> @@ -536,10 +520,7 @@ export default function GraphChapter() { } zh={

- 数组有「连续内存 + 下标公式」,树有「节点 + 左右引用」。 - 图两样都没有,因为它的形状千变万化。工程上最常用两种表示法, - 它们的取舍就是一场典型的「时间 vs 空间」权衡。 - 点下面的顶点,对照着看同一张图的两种长相: + 数组有「连续内存 + 下标公式」,树有「节点 + 左右引用」。图两样都没有,因为它的形状千变万化。工程上最常用两种表示法,它们的取舍就是一场典型的「时间 vs 空间」权衡。点下面的顶点,对照着看同一张图的两种长相:

} /> @@ -605,11 +586,8 @@ export default function GraphChapter() { } zh={ <> - 每个点挂一串「它的邻居」(数组套数组 / 哈希表套数组)。 - 只存真实存在的边,空间{" "} - ; - 取一个点的所有邻居也很直接。代价:查「i、j 之间有没有边」 - 要扫 i 的邻居串,最坏 O(deg i)。 + 每个点挂一串「它的邻居」(数组套数组 / 哈希表套数组)。只存真实存在的边,空间{" "} + ;取一个点的所有邻居也很直接。代价:查「i、j 之间有没有边」要扫 i 的邻居串,最坏 O(deg i)。 绝大多数做题和工程场景都用它。 } @@ -748,11 +726,8 @@ export default function GraphChapter() { } zh={

- 最朴素的存法:一个数组,每个元素是 [u, v, w] 一条边。 - 它适合「一次性读入全部边再排序」的算法,比如最小生成树的 - Kruskal、并查集判环。但想取某点的邻居得扫全部边,做遍历太慢。 - 所以它常常只是输入格式 —— 题目给你 edge list, - 你第一步往往是把它转成邻接表。 + 最朴素的存法:一个数组,每个元素是 [u, v, w] 一条边。它适合「一次性读入全部边再排序」的算法,比如最小生成树的 + Kruskal、并查集判环。但想取某点的邻居得扫全部边,做遍历太慢。所以它常常只是输入格式 —— 题目给你 edge list,你第一步往往是把它转成邻接表。

} /> @@ -788,8 +763,7 @@ export default function GraphChapter() { } zh={

- 图的绝大多数算法,骨架都是「把每个点访问一遍」。 - 访问图有两种标准走法,它们分别复用了你已经学过的一种结构: + 图的绝大多数算法,骨架都是「把每个点访问一遍」。访问图有两种标准走法,它们分别复用了你已经学过的一种结构:

} /> @@ -819,10 +793,8 @@ export default function GraphChapter() { } zh={ <> - 搜索一层一层向外扩:先访问起点,再访问它所有邻居, - 再访问「邻居里没访问过的邻居」…… 用 - 队列(先进先出)驱动。点是按「离起点几条边」分层出来的, - 所以 BFS 能求无权图里边数最少的路径。 + 搜索一层一层向外扩:先访问起点,再访问它所有邻居,再访问「邻居里没访问过的邻居」……用 + 队列(先进先出)驱动。点是按「离起点几条边」分层出来的,所以 BFS 能求无权图里边数最少的路径。 } /> @@ -851,9 +823,7 @@ export default function GraphChapter() { } zh={ <> - 搜索沿一条路走到走不通,再退回上一个岔口换一条。 - 用栈驱动(或者写成递归,系统调用栈就是那个栈)。 - 适合「探索所有路径 / 连通块 / 找环」这类问题。 + 搜索沿一条路走到走不通,再退回上一个岔口换一条。用栈驱动(或者写成递归,系统调用栈就是那个栈)。适合「探索所有路径 / 连通块 / 找环」这类问题。 } /> @@ -874,8 +844,7 @@ export default function GraphChapter() { } zh={

- 光看文字不如亲眼看。下面这张 8 个点的图,切换 BFS / DFS, - 一步步播放 —— 注意看下方队列 / 栈的内容怎么变、 + 光看文字不如亲眼看。下面这张 8 个点的图,切换 BFS / DFS,一步步播放 —— 注意看下方队列 / 栈的内容怎么变、 visited 集合怎么长,以及节点点亮的顺序 (每个点下面的 #编号就是访问序)。

@@ -909,12 +878,8 @@ export default function GraphChapter() { } zh={

- 这是图与树最本质的区别。树没有环:从根往下走, - 永远不会绕回已经走过的祖先,所以树的遍历(第 7 章)从不需要 - visited。图可能有环:A→B→C→A…… - 没有记录「谁来过」,遍历就会在环里无限打转,程序永远停不下来。 - 所以规则是:进入一个点前先查 visited,进入后立刻标记。 - BFS 里更要「一入队就标记」,而不是出队才标记 —— + 这是图与树最本质的区别。树没有环:从根往下走,永远不会绕回已经走过的祖先,所以树的遍历(第 7 章)从不需要 + visited。图可能有环:A→B→C→A……没有记录「谁来过」,遍历就会在环里无限打转,程序永远停不下来。所以规则是:进入一个点前先查 visited,进入后立刻标记。BFS 里更要「一入队就标记」,而不是出队才标记 —— 否则每一条指向它的边都会把它再塞进队列一次。

} @@ -1059,12 +1024,7 @@ export default function GraphChapter() { } zh={

- 用邻接表时,BFS 和 DFS 的复杂度都是 O(V + E): - 每个顶点被处理一次(贡献 V),每条边被检查一次 - (有向图一次、无向图两端各一次,贡献 E)。 - 这是图论最基础的一条复杂度,后面几乎所有算法都从它长出来。 - 换成邻接矩阵,同样的遍历会变成 O(V²), - 因为取一个点的邻居要扫整整一行。 + 用邻接表时,BFS 和 DFS 的复杂度都是 O(V + E):每个顶点被处理一次(贡献 V),每条边被检查一次(有向图一次、无向图两端各一次,贡献 E)。这是图论最基础的一条复杂度,后面几乎所有算法都从它长出来。换成邻接矩阵,同样的遍历会变成 O(V²),因为取一个点的邻居要扫整整一行。

} /> @@ -1101,8 +1061,7 @@ export default function GraphChapter() {

题目通常给你的是边列表(比如{" "} edges = [[0,1],[0,2],...]),第一步几乎总是把它转成 - 邻接表,然后 BFS / DFS 直接套模板。 - 先看「建图 + BFS」。高亮的两行是关键:顶点是 + 邻接表,然后 BFS / DFS 直接套模板。先看「建图 + BFS」。高亮的两行是关键:顶点是 在入队的那一刻被标记的。

} @@ -1254,8 +1213,7 @@ def bfs(g, start, n): ), zh: ( <> - 易错点:队列一定用 collections.deque, - 它的 popleft() 是 O(1);不要用{" "} + 易错点:队列一定用 collections.deque,它的 popleft() 是 O(1);不要用{" "} list.pop(0)(O(n),会把整个 BFS 拖成 O(V · E))。 ), @@ -1331,8 +1289,7 @@ function bfs(g, start, n) { zh: ( <> 易错点:JS 数组的 shift() 是 O(n) - 搬家。数据量大时用「读指针 head 只增不减」的写法, - 出队 O(1)。 + 搬家。数据量大时用「读指针 head 只增不减」的写法,出队 O(1)。 ), }, @@ -1351,8 +1308,7 @@ function bfs(g, start, n) { } zh={

- DFS 有两种写法:递归(短、直观, - 但图很深时可能导致调用栈溢出)和迭代 + DFS 有两种写法:递归(短、直观,但图很深时可能导致调用栈溢出)和迭代 (用显式栈,安全)。两个都要会:

} @@ -1423,9 +1379,7 @@ void dfsIter(List> g, int start) { ), zh: ( <> - 两版的访问顺序可能不同,因为栈先弹出最后压入的邻居; - 但都是合法的深度优先遍历。递归深度可能达到 V,V 很大时 - (如 10⁵ 个点连成一条链)要用迭代版防止栈溢出。 + 两版的访问顺序可能不同,因为栈先弹出最后压入的邻居;但都是合法的深度优先遍历。递归深度可能达到 V,V 很大时(如 10⁵ 个点连成一条链)要用迭代版防止栈溢出。 ), }, @@ -1560,8 +1514,7 @@ function dfsIter(g, start, n) { zh: ( <> JS 引擎的调用栈也就一万多层,深递归同样会报{" "} - Maximum call stack size exceeded。 - 竞赛或大数据量优先迭代版。 + Maximum call stack size exceeded。竞赛或大数据量优先迭代版。 ), }, @@ -1583,11 +1536,7 @@ function dfsIter(g, start, n) { } zh={

- 最后一块拼图:网格型图。矩阵(第 1 章) - 本身就是一张图 —— 每个格子 (r, c) 是顶点, - 它和上下左右四个格子之间各有一条边。 - 这就是为什么「洪水填充」和「迷宫最短路」属于图论题。 - 遍历时不用真的建邻接表,用一个方向数组 + 最后一块拼图:网格型图。矩阵(第 1 章)本身就是一张图 —— 每个格子 (r, c) 是顶点,它和上下左右四个格子之间各有一条边。这就是为什么「洪水填充」和「迷宫最短路」属于图论题。遍历时不用真的建邻接表,用一个方向数组 就能在一个循环里走完四个方向,这是网格题的标准模板:

} @@ -1698,11 +1647,7 @@ function gridDfs(grid, r, c) { } zh={

- ① 八方向(含对角线):dirs 写 8 个偏移即可。 - ② 直接改原网格的值当 visited(如把 1 改成 2 或 0), - 省掉一个 visited 矩阵 —— 但会破坏输入, - 面试时记得先问一句「可以修改原数组吗」。网格 BFS 同理, - 把栈换成队列即可。 + ① 八方向(含对角线):dirs 写 8 个偏移即可。② 直接改原网格的值当 visited(如把 1 改成 2 或 0),省掉一个 visited 矩阵 —— 但会破坏输入,面试时记得先问一句「可以修改原数组吗」。网格 BFS 同理,把栈换成队列即可。

} /> @@ -1738,9 +1683,7 @@ function gridDfs(grid, r, c) { zh={

和数组、哈希表不同,三种语言都 - 没有开箱即用的图类型。 - 但「用邻接表表示图」的写法高度统一,只是各语言的容器不同。 - 记住每种语言的建表惯用法和 + 没有开箱即用的图类型。但「用邻接表表示图」的写法高度统一,只是各语言的容器不同。记住每种语言的建表惯用法和 visited 用什么,上手任何图题都有章可循:

} @@ -2022,10 +1965,7 @@ const seen = new Set();`, } zh={

- 这是用 JS 刷图论最大的短板:没有优先队列 / 堆。 - 做 Dijkstra 时,要么自己手写一个二叉堆(第 9 章教过), - 要么用「每轮线性扫最小」的 O(V²) 版本 —— 小图上完全够用。 - 面试用 JS 时,提前把手写堆准备好。 + 这是用 JS 刷图论最大的短板:没有优先队列 / 堆。做 Dijkstra 时,要么自己手写一个二叉堆(第 9 章教过),要么用「每轮线性扫最小」的 O(V²) 版本 —— 小图上完全够用。面试用 JS 时,提前把手写堆准备好。

} /> @@ -2079,9 +2019,7 @@ const seen = new Set();`, } zh={

- 一大批 LeetCode 中等题,本质都是「在网格上做 DFS / BFS」: - 岛屿数量、岛屿面积、被围绕的区域、腐烂的橘子…… - 它们共用同一个映射: + 一大批 LeetCode 中等题,本质都是「在网格上做 DFS / BFS」:岛屿数量、岛屿面积、被围绕的区域、腐烂的橘子……它们共用同一个映射: 每个格子是一个顶点,上下左右相邻的格子之间有一条边 ,然后遍历。核心技巧叫「淹没 / 染色」 —— 访问过的格子直接改值,既当 visited 又防重复计数。 @@ -2122,13 +2060,10 @@ const seen = new Set();`, zh={

题意:给一个由 '1'(陆地)和{" "} - '0'(水)组成的网格,数出有几座岛 - (上下左右相连的陆地算一座)。 - 思路:逐格扫描,一旦遇到没被淹过的{" "} - '1',岛屿数 +1,然后从这里 DFS, - 把整座岛的 '1' 全「淹成{" "} - '0'」,同一座岛就不会被重复数。 - 看动画,注意绿色 = 已淹没(已计入某座岛)。 + '0'(水)组成的网格,数出有几座岛(上下左右相连的陆地算一座)。 + 思路:逐格扫描,一旦遇到没被淹过的{" "} + '1',岛屿数 +1,然后从这里 DFS,把整座岛的 '1' 全「淹成{" "} + '0'」,同一座岛就不会被重复数。看动画,注意绿色 = 已淹没(已计入某座岛)。

} /> @@ -2289,12 +2224,7 @@ const seen = new Set();`, } zh={

- 时间 O(行 × 列):每个格子最多被进入一次(淹过就变 0)。 - 空间是递归栈,最坏 O(行 × 列)(整张图全是陆地时)。面试常见追问: - 「不能改原网格怎么办?」(另开 visited 矩阵)、 - 「栈溢出怎么办?」(改 BFS 或迭代 DFS)、 - 「要数最大岛面积?」(LC695,让 DFS 返回淹没的格子数)。 - 淹没法是所有网格连通块题的模板。 + 时间 O(行 × 列):每个格子最多被进入一次(淹过就变 0)。空间是递归栈,最坏 O(行 × 列)(整张图全是陆地时)。面试常见追问:「不能改原网格怎么办?」(另开 visited 矩阵)、「栈溢出怎么办?」(改 BFS 或迭代 DFS)、「要数最大岛面积?」(LC695,让 DFS 返回淹没的格子数)。淹没法是所有网格连通块题的模板。

} /> @@ -2339,17 +2269,14 @@ const seen = new Set();`, zh={ <>

- 排课表、编译依赖、任务调度…… 这类问题都在问同一件事: + 排课表、编译依赖、任务调度……这类问题都在问同一件事: 一堆任务互相有「谁必须在谁之前」的约束,能不能排出一个合法顺序? - 这个顺序就是拓扑排序(topological sort)。 - 它只对有向无环图(DAG)成立 —— 一旦有环 - (A 依赖 B、B 又依赖 A),谁都没法先做,排不出来。 + 这个顺序就是拓扑排序(topological sort)。它只对有向无环图(DAG)成立 —— 一旦有环(A 依赖 B、B 又依赖 A),谁都没法先做,排不出来。

- 最直观的算法是 Kahn 入度法, - 像现实里选课一样自然: + 最直观的算法是 Kahn 入度法,像现实里选课一样自然:

} @@ -2410,8 +2337,7 @@ const seen = new Set();`, } zh={ <> - 出队一门课(修完),它的后继课入度各减 1;减到 0 的又能入队。 - 循环到队空。 + 出队一门课(修完),它的后继课入度各减 1;减到 0 的又能入队。循环到队空。 } /> @@ -2449,11 +2375,9 @@ const seen = new Set();`, zh={

题意:共 numCourses 门课, - prerequisites[i] = [a, b] 表示「修 a 前必须先修 b」。 - 判断能否修完所有课。 - 思路:这就是在问「这张有向图有没有环」—— - 能跑完整个拓扑排序就无环。看 Kahn 逐帧: - 注意每个点下方的入度怎么随出队一路减到 0。 + prerequisites[i] = [a, b] 表示「修 a 前必须先修 b」。判断能否修完所有课。 + 思路:这就是在问「这张有向图有没有环」—— + 能跑完整个拓扑排序就无环。看 Kahn 逐帧:注意每个点下方的入度怎么随出队一路减到 0。

} /> @@ -2628,10 +2552,7 @@ class Solution: 有向图判环有两种正解:①{" "} 拓扑排序(本题),出队数少于总点数即有环;②{" "} DFS 三状态标记(未访问 / 正在当前递归栈中 / 已完成)—— - 碰到「已完成」的点没问题,那条路已经探过了; - 碰到「仍在当前栈中」的点才是环。无向图不能直接套这两种: - 要用并查集,或者 DFS 时忽略「刚走过来的那条边」, - 否则会把父节点当成环。追问延伸:LC210 要输出 + 碰到「已完成」的点没问题,那条路已经探过了;碰到「仍在当前栈中」的点才是环。无向图不能直接套这两种:要用并查集,或者 DFS 时忽略「刚走过来的那条边」,否则会把父节点当成环。追问延伸:LC210 要输出 具体的拓扑序(把出队顺序记下来就是)。复杂度{" "} 。

@@ -2661,8 +2582,7 @@ class Solution: } zh={

- 挑算法前先分清一件事:边带不带权。 - 这决定了用哪把武器: + 挑算法前先分清一件事:边带不带权。这决定了用哪把武器:

} /> @@ -2692,9 +2612,7 @@ class Solution: zh={ <> 每条边代价都相同时,BFS 按层扩散, - 第一次到达某点的层数,就是到它的最少步数。 - 不用任何高级算法,一个队列足矣。 - 「最少几步 / 最少操作次数」类题的首选。 + 第一次到达某点的层数,就是到它的最少步数。不用任何高级算法,一个队列足矣。「最少几步 / 最少操作次数」类题的首选。 } /> @@ -2725,11 +2643,7 @@ class Solution: } zh={ <> - 边有不同权重(距离 / 耗时)时,BFS 失效: - 走的边少不代表权之和小。改用 Dijkstra: - 小根堆每次挑出「当前离起点最近、还没定案」的点, - 定案后松弛它的邻居。前提是所有边权非负, - 实现上呼应第 9 章的堆。 + 边有不同权重(距离 / 耗时)时,BFS 失效:走的边少不代表权之和小。改用 Dijkstra:小根堆每次挑出「当前离起点最近、还没定案」的点,定案后松弛它的邻居。前提是所有边权非负,实现上呼应第 9 章的堆。 } /> @@ -2757,13 +2671,11 @@ class Solution:

重点讲 Dijkstra。它的规则是: - 每次从「未定案的点」里挑 dist 最小的那个, - 它的最短距离此刻就能确定 + 每次从「未定案的点」里挑 dist 最小的那个,它的最短距离此刻就能确定 —— 因为边权非负,任何绕远路只会更贵,不可能反超。定案后,用它去 松弛(relax)邻居: - if dist[u] + w < dist[v]: 更新 dist[v]。 - 看 5 个点的完整演算,注意 dist 是怎么被一次次改小的。 + if dist[u] + w < dist[v]: 更新 dist[v]。看 5 个点的完整演算,注意 dist 是怎么被一次次改小的。

} /> @@ -2801,12 +2713,10 @@ class Solution: zh={

题意:从节点 k 发信号,times[i] = [u, v, w]{" "} - 表示信号从 u 到 v 要 w 时间。求信号传遍所有 n 个节点最少需要多久 - (传不到返回 -1)。 - 思路:标准单源最短路 —— Dijkstra 求出 k + 表示信号从 u 到 v 要 w 时间。求信号传遍所有 n 个节点最少需要多久(传不到返回 -1)。 + 思路:标准单源最短路 —— Dijkstra 求出 k 到每个点的最短时间,答案就是这些最短时间里的最大值 - (最后一个收到信号的点决定总耗时);若有点仍是 ∞ 则不可达, - 返回 -1。 + (最后一个收到信号的点决定总耗时);若有点仍是 ∞ 则不可达,返回 -1。

} /> @@ -2894,9 +2804,7 @@ class Solution: ), zh: ( <> - if (d > dist[u]) continue; 这句很关键: - 堆里可能残留同一个点的旧(更大)距离, - 弹出时发现比当前 dist 还大,就是过期记录,直接跳过。 + if (d > dist[u]) continue; 这句很关键:堆里可能残留同一个点的旧(更大)距离,弹出时发现比当前 dist 还大,就是过期记录,直接跳过。 ), }, @@ -2960,8 +2868,7 @@ class Solution: ), zh: ( <> - Python 的 heapq 是小根堆, - 把元组第一维放距离就会按距离出堆。最后的{" "} + Python 的 heapq 是小根堆,把元组第一维放距离就会按距离出堆。最后的{" "} max(dist[1:]) 跳过下标 0(节点从 1 开始编号)。 ), @@ -3034,8 +2941,7 @@ var networkDelayTime = function (times, n, k) { zh: ( <> 想要正统{" "} - 的 JS 版, - 得自己手写二叉堆(第 9 章)。这里的 O(V²) 版在 LC743 + 的 JS 版,得自己手写二叉堆(第 9 章)。这里的 O(V²) 版在 LC743 的数据规模下足够。 ), @@ -3072,14 +2978,9 @@ var networkDelayTime = function (times, n, k) {

① 为什么用小根堆?为了每次 O(log V) 地取出「当前最近的未定案点」,不用线性扫。②{" "} - 为什么怕负权?Dijkstra 在一个点弹出堆的那一刻就把它的距离 - 定死、永不回头,而这只在边权非负时成立 - (绕路只会更贵)。有负边时,后来才发现的路径可能更便宜, - 某个点会被过早定案,答案就错了。这时改用 Bellman-Ford, - 复杂度 ,它还能判负环。③{" "} + 为什么怕负权?Dijkstra 在一个点弹出堆的那一刻就把它的距离定死、永不回头,而这只在边权非负时成立(绕路只会更贵)。有负边时,后来才发现的路径可能更便宜,某个点会被过早定案,答案就错了。这时改用 Bellman-Ford,复杂度 ,它还能判负环。③{" "} 复杂度?用二叉堆是{" "} - ; - 图连通、E ≥ V - 1 时常简写作 O(E log V)。 + ;图连通、E ≥ V - 1 时常简写作 O(E log V)。

} /> @@ -3107,9 +3008,7 @@ var networkDelayTime = function (times, n, k) { zh={

无权图(或所有边权相同)求最短路,不要用 Dijkstra —— - 直接 BFS 更简单更快。Dijkstra 是「边权不同且非负」时才需要的更通用的算法。 - 看到「最少步数 / 最少操作次数」优先想 BFS; - 看到「最短距离 / 最小花费 + 边权不一」才想 Dijkstra。 + 直接 BFS 更简单更快。Dijkstra 是「边权不同且非负」时才需要的更通用的算法。看到「最少步数 / 最少操作次数」优先想 BFS;看到「最短距离 / 最小花费 + 边权不一」才想 Dijkstra。

} /> @@ -3170,8 +3069,7 @@ var networkDelayTime = function (times, n, k) { zh: ( <> 图 = 顶点 + 边。链表、树、网格都是它的特例 —— - 单链表是「每点一条出边的直线图」,树是「连通且无环的图」, - 网格是「每个格子和上下左右相邻的图」。 + 单链表是「每点一条出边的直线图」,树是「连通且无环的图」,网格是「每个格子和上下左右相邻的图」。 ), }, @@ -3187,8 +3085,8 @@ var networkDelayTime = function (times, n, k) { ), zh: ( <> - 两种表示法:邻接矩阵 占 O(V²) 空间、查边 O(1); - 邻接表 占 O(V + E) 空间、遍历邻居快。 + 两种表示法:邻接矩阵占 O(V²) 空间、查边 O(1); + 邻接表占 O(V + E) 空间、遍历邻居快。 稀疏图默认邻接表,这也是做题时最常用的表示法。 ), @@ -3224,8 +3122,7 @@ var networkDelayTime = function (times, n, k) { ), zh: ( <> - 网格题 = 网格上的 DFS/BFS + 方向数组 dirs; - 「淹没 / 染色」把访问过的格子改值,兼任 visited + 网格题 = 网格上的 DFS/BFS + 方向数组 dirs;「淹没 / 染色」把访问过的格子改值,兼任 visited (LC200 岛屿是模板)。 ), @@ -3243,10 +3140,7 @@ var networkDelayTime = function (times, n, k) { ), zh: ( <> - 拓扑排序只对 有向无环图(DAG) 成立:Kahn 入度法 - (入度 0 入队 → 出队时把后继入度减 1),出不完 = 有环。 - 这是有向图判环的两种标准做法之一(另一种是 DFS 三状态); - 无向图判环要用别的方法。 + 拓扑排序只对有向无环图(DAG)成立:Kahn 入度法(入度 0 入队 → 出队时把后继入度减 1),出不完 = 有环。这是有向图判环的两种标准做法之一(另一种是 DFS 三状态);无向图判环要用别的方法。 ), }, @@ -3266,8 +3160,7 @@ var networkDelayTime = function (times, n, k) { <> 最短路看边权:无权用 BFS(层数就是最少边数); 非负权用 Dijkstra(贪心 + 小根堆,O((V + E) log V)); - 有负权时 Dijkstra 失效(定案后不再回头), - 改用 Bellman-Ford,复杂度 O(V · E)。 + 有负权时 Dijkstra 失效(定案后不再回头),改用 Bellman-Ford,复杂度 O(V · E)。 ), }, diff --git a/app/graph/viz.tsx b/app/graph/viz.tsx index bb9cfc6..9613e45 100644 --- a/app/graph/viz.tsx +++ b/app/graph/viz.tsx @@ -311,11 +311,7 @@ export function TermGraph() { } zh={ <> - 顶点装数据,边记录两点之间的关系; - 一个点连了几条边就是它的度 degree; - 能沿边从一个点走到另一个点就说它们连通 connected; - 起点等于终点的闭合路径叫环 cycle。 - 本章的一切,都由这几个词拼出来。 + 顶点装数据,边记录两点之间的关系;一个点连了几条边就是它的度 degree;能沿边从一个点走到另一个点就说它们连通 connected;起点等于终点的闭合路径叫环 cycle。本章的一切,都由这几个词拼出来。 } /> @@ -368,8 +364,7 @@ export function MiniConcepts() { } zh={ <> - 边没有方向,关系是对称的:A 和 B 互为朋友、地铁双向通车。 - 树就是这一类:无向、连通、且没有环。 + 边没有方向,关系是对称的:A 和 B 互为朋友、地铁双向通车。树就是这一类:无向、连通、且没有环。 } /> @@ -393,8 +388,7 @@ export function MiniConcepts() { } zh={ <> - 边有箭头,关系是单向的:A 关注 B 不等于 B 关注 A、 - 网页 A 链到 B。此时度分成入度(指进来的)和 + 边有箭头,关系是单向的:A 关注 B 不等于 B 关注 A、网页 A 链到 B。此时度分成入度(指进来的)和 出度(指出去的)。单链表就是「每个点只有一条出边」的有向图。 } @@ -420,9 +414,7 @@ export function MiniConcepts() { } zh={ <> - 边上带数字(权 weight):距离、时间、费用。 - 此时「最短路」问的是权之和最小的那条路,而不是边数最少。 - 有没有方向和有没有权是两个独立的选择 —— + 边上带数字(权 weight):距离、时间、费用。此时「最短路」问的是权之和最小的那条路,而不是边数最少。有没有方向和有没有权是两个独立的选择 —— 这里画的恰好既有向又带权,但带权的无向图同样常见。 } @@ -550,8 +542,7 @@ export function ReprLab() { } zh={ <> - V × V 的表格:查「i、j 之间有没有边」是 O(1), - 但不管图多稀疏,都硬占 O(V²) 空间。 + V × V 的表格:查「i、j 之间有没有边」是 O(1),但不管图多稀疏,都硬占 O(V²) 空间。 } /> @@ -618,10 +609,8 @@ export function ReprLab() { } zh={ <> - 顶点 {sel} 的邻居是 [{REPR_ADJ[sel].join(", ")}]: - 矩阵里是第 {sel} 行中所有为 1 的列;邻接表里就是第 {sel}{" "} - 行挂着的那串。两种表示装的是同一张图, - 区别只在于它们让什么变便宜:查边快,还是省空间加遍历邻居快。 + 顶点 {sel} 的邻居是 [{REPR_ADJ[sel].join(", ")}]:矩阵里是第 {sel} 行中所有为 1 的列;邻接表里就是第 {sel}{" "} + 行挂着的那串。两种表示装的是同一张图,区别只在于它们让什么变便宜:查边快,还是省空间加遍历邻居快。 } /> @@ -703,8 +692,7 @@ function buildBfs(): TravFrame[] { } zh={ <> - 起点 0 入队。BFS 用队列(先进先出): - 先被发现的点先被处理,搜索就一层一层往外扩(呼应第 5 章队列)。 + 起点 0 入队。BFS 用队列(先进先出):先被发现的点先被处理,搜索就一层一层往外扩(呼应第 5 章队列)。 一入队就标记 visited,而不是出队才标记 —— 这样同一个点不会被排两次队。 @@ -740,8 +728,7 @@ function buildBfs(): TravFrame[] { zh={ <> 出队 {u}(第 {order[u] + 1} 个访问),把它没见过的邻居{" "} - {newly.join("、")} 塞到队尾。 - 队列里装的正是「下一批要处理的点」。 + {newly.join("、")} 塞到队尾。队列里装的正是「下一批要处理的点」。 } /> @@ -755,8 +742,7 @@ function buildBfs(): TravFrame[] { } zh={ <> - 出队 {u}(第 {order[u] + 1} 个访问), - 邻居全在 visited 里了 —— 无人入队。 + 出队 {u}(第 {order[u] + 1} 个访问),邻居全在 visited 里了 —— 无人入队。 } /> @@ -786,8 +772,7 @@ function buildBfs(): TravFrame[] { <> 队列空,遍历结束。访问序 0 1 2 3 4 5 6 7,严格按层: {"{0} → {1,2} → {3,4,5} → {6,7}"}。第 k 层装的正好是「距起点 k - 条边」的点 —— 这就是 BFS 能求无权图最少边数路径的原因(§06)。 - 一旦边权各不相同,这个结论就不成立,得换 Dijkstra。 + 条边」的点 —— 这就是 BFS 能求无权图最少边数路径的原因(§06)。一旦边权各不相同,这个结论就不成立,得换 Dijkstra。 } /> @@ -823,8 +808,7 @@ function buildDfs(): TravFrame[] { zh={ <> DFS 用栈(写成递归时,系统调用栈就是这个栈)—— - 沿一条路一直走到走不通,再退回上一个岔口换一条。 - 下方栈里显示的是当前节点之下的那段栈,也就是回到起点的路径。 + 沿一条路一直走到走不通,再退回上一个岔口换一条。下方栈里显示的是当前节点之下的那段栈,也就是回到起点的路径。 } /> @@ -874,8 +858,7 @@ function buildDfs(): TravFrame[] { {parent}–{u} {" "} - 往深处走,访问 {u}(第 {order[u] + 1} 个),压栈。 - 只要当前点还有没走过的邻居,DFS 就不回头。 + 往深处走,访问 {u}(第 {order[u] + 1} 个),压栈。只要当前点还有没走过的邻居,DFS 就不回头。 } /> @@ -947,9 +930,7 @@ function buildDfs(): TravFrame[] { zh={ <> 访问序 0 1 3 6 4 2 5 7 —— 和 BFS 完全不同:DFS - 先一头扎到最深(0→1→3→6→…)才回头。visited 绝不能省: - 这张图有环,少了它就会在环里无限打转。树没有环, - 所以树的遍历才不需要 visited。 + 先一头扎到最深(0→1→3→6→…)才回头。visited 绝不能省:这张图有环,少了它就会在环里无限打转。树没有环,所以树的遍历才不需要 visited。 } /> @@ -1149,8 +1130,7 @@ function buildGridFrames(): GridFrame[] { zh={ <> 网格本身就是一张图:每个格子是一个顶点, - 上下左右相邻的两个格子之间有一条边。规则:逐格扫描, - 遇到还没淹过的陆地 1 就把岛屿数 +1,再 DFS + 上下左右相邻的两个格子之间有一条边。规则:逐格扫描,遇到还没淹过的陆地 1 就把岛屿数 +1,再 DFS 把这座岛所有相连的 1 全部「淹成 0」,同一座岛就不会被重复计数。 } @@ -1184,8 +1164,7 @@ function buildGridFrames(): GridFrame[] { {r},{c} - ):把当前陆地标记为已访问(染成水),再朝上下左右四个方向递归。 - 改值本身就充当了 visited,不用另开一个矩阵。 + ):把当前陆地标记为已访问(染成水),再朝上下左右四个方向递归。改值本身就充当了 visited,不用另开一个矩阵。 } />, @@ -1228,8 +1207,7 @@ function buildGridFrames(): GridFrame[] { {r},{c} - ):它不属于任何已淹的岛,于是第 {count} 座岛诞生, - 启动 DFS 淹没整片相连陆地。 + ):它不属于任何已淹的岛,于是第 {count} 座岛诞生,启动 DFS 淹没整片相连陆地。 } />, @@ -1377,9 +1355,7 @@ function buildTopoFrames(): TopoFrame[] { } zh={ <> - 拓扑序只对有向无环图存在。第一步是数每个点的入度: - 有几根箭头指向它,也就是它还有几门没修完的前置课。 - 课程 3 被 1、2 指向,入度 2;课程 0 没人指向,入度 0。 + 拓扑序只对有向无环图存在。第一步是数每个点的入度:有几根箭头指向它,也就是它还有几门没修完的前置课。课程 3 被 1、2 指向,入度 2;课程 0 没人指向,入度 0。 } />, @@ -1469,8 +1445,7 @@ function buildTopoFrames(): TopoFrame[] { zh={ <> 拓扑序:{out.join(" → ")}。全部 {n} 门课都出了队 ⇒{" "} - 图无环,课程表可行。若中途队列空了却还有课没出, - 说明剩下的课互相依赖成环,谁都开不了头 —— 这正是 LC207 + 图无环,课程表可行。若中途队列空了却还有课没出,说明剩下的课互相依赖成环,谁都开不了头 —— 这正是 LC207 的判定,也是有向图判环的两种标准做法之一。 } @@ -1667,11 +1642,8 @@ function buildDijkstra(): DjFrame[] { } zh={ <> - Dijkstra 求单源最短路(权之和最小),前提是所有边权非负。 - 先令 dist[起点 0] = 0,其余为 ∞。 - 小根堆每次弹出「当前 dist 最小、还没定案」的点。 - 因为没有一条边会让总和变小,所以一个点第一次被弹出时, - 它的距离就已经是最终答案。 + Dijkstra 求单源最短路(权之和最小),前提是所有边权非负。先令 dist[起点 0] = 0,其余为 ∞。 + 小根堆每次弹出「当前 dist 最小、还没定案」的点。因为没有一条边会让总和变小,所以一个点第一次被弹出时,它的距离就已经是最终答案。 } />, @@ -1722,8 +1694,7 @@ function buildDijkstra(): DjFrame[] { <> {" "} 据此松弛它的出边: - {updated.map((x) => `dist[${x}]=${dist[x]}`).join("、")}。 - 这些点还没定案,所以可以把它们的临时距离改小。 + {updated.map((x) => `dist[${x}]=${dist[x]}`).join("、")}。这些点还没定案,所以可以把它们的临时距离改小。 ) : ( <> 它没有能让别人变更短的出边。 @@ -1752,12 +1723,9 @@ function buildDijkstra(): DjFrame[] { } zh={ <> - 全部定案。0 到各点的最短距离:[{dist.join(", ")}]。 - 注意 dist[1] 经 2→1 从 4 降到 3、dist[3] 经 1→3 从 6 降到 4 —— - 这两次变化都发生在它们还是临时距离的时候;一旦定案就不会再改。 - 若这是 LC743,网络延迟 = 这些值里的 - 最大值 {Math.max(...dist)}(最后收到信号的点决定总耗时); - 若有点仍是 ∞ 则不可达,返回 -1。 + 全部定案。0 到各点的最短距离:[{dist.join(", ")}]。注意 dist[1] 经 2→1 从 4 降到 3、dist[3] 经 1→3 从 6 降到 4 —— + 这两次变化都发生在它们还是临时距离的时候;一旦定案就不会再改。若这是 LC743,网络延迟 = 这些值里的 + 最大值 {Math.max(...dist)}(最后收到信号的点决定总耗时);若有点仍是 ∞ 则不可达,返回 -1。 } />, diff --git a/app/hash/page.tsx b/app/hash/page.tsx index 63d9664..1f364a3 100644 --- a/app/hash/page.tsx +++ b/app/hash/page.tsx @@ -127,8 +127,7 @@ const F1: ArrayFrame[] = [ zh={ <> i = 3,v = 7:需要 9 − 7 = 2。查表:有,2 的下标是 1 → - 答案 [1, 3]。每个数只被处理一次:一次查 + 一次存,平均都是 O(1), - 整趟 O(n)。 + 答案 [1, 3]。每个数只被处理一次:一次查 + 一次存,平均都是 O(1),整趟 O(n)。 } /> @@ -156,9 +155,7 @@ const F49: ArrayFrame[] = [ } zh={ <> - 异位词的特征:字母相同、顺序不同。给每个词一个签名: - 把字母排序 —— eat / tea / ate 排序后都是 "aet"。 - 签名做 key,词加入该 key 下的那一组。 + 异位词的特征:字母相同、顺序不同。给每个词一个签名:把字母排序 —— eat / tea / ate 排序后都是 "aet"。签名做 key,词加入该 key 下的那一组。 } /> @@ -176,8 +173,7 @@ const F49: ArrayFrame[] = [ } zh={ <> - "eat" → 签名 "aet":表里还没有这个组,新建。 - map = {"{aet: [eat]}"} + "eat" → 签名 "aet":表里还没有这个组,新建。map = {"{aet: [eat]}"} } /> @@ -195,8 +191,7 @@ const F49: ArrayFrame[] = [ } zh={ <> - "tea" → 签名 "aet":组已存在,直接加入。 - map = {"{aet: [eat, tea]}"} + "tea" → 签名 "aet":组已存在,直接加入。map = {"{aet: [eat, tea]}"} } /> @@ -234,8 +229,7 @@ const F49: ArrayFrame[] = [ } zh={ <> - "ate" → 签名 "aet":加入 eat 那组。 - 三个异位词从未两两比较过,却自动聚在了一起。 + "ate" → 签名 "aet":加入 eat 那组。三个异位词从未两两比较过,却自动聚在了一起。 } /> @@ -305,8 +299,7 @@ const F128: ArrayFrame[] = [ } zh={ <> - 第一步:全部丢进 Set = {"{100, 4, 200, 1, 3, 2}"}。从此「x 在不在」 - 平均只要 O(1)。目标是最长的数值连续序列,元素在数组里的位置无所谓。 + 第一步:全部丢进 Set = {"{100, 4, 200, 1, 3, 2}"}。从此「x 在不在」平均只要 O(1)。目标是最长的数值连续序列,元素在数组里的位置无所谓。 } /> @@ -325,8 +318,7 @@ const F128: ArrayFrame[] = [ } zh={ <> - 检查 100:99 不在 Set 里 → 100 是某条序列的起点。 - 向右数:101 也不在 → 这条序列长度为 1。 + 检查 100:99 不在 Set 里 → 100 是某条序列的起点。向右数:101 也不在 → 这条序列长度为 1。 } /> @@ -345,8 +337,7 @@ const F128: ArrayFrame[] = [ } zh={ <> - 检查 4:3 在 Set 里 → 4 不是起点,直接跳过。 - 它属于别人的序列,等那条序列的起点来数它 —— 这一步正是总工作量保持线性的关键。 + 检查 4:3 在 Set 里 → 4 不是起点,直接跳过。它属于别人的序列,等那条序列的起点来数它 —— 这一步正是总工作量保持线性的关键。 } /> @@ -437,8 +428,7 @@ const F128: ArrayFrame[] = [ } zh={ <> - 为什么是 O(n)?每个数最多被摸两次:一次是它自己的起点检查, - 一次是被某条序列「向右数到」。总工作量 ≤ 2n。内层 while + 为什么是 O(n)?每个数最多被摸两次:一次是它自己的起点检查,一次是被某条序列「向右数到」。总工作量 ≤ 2n。内层 while 不是重复劳动,它只是把账记在了起点头上。 } @@ -490,8 +480,7 @@ export default function HashChapter() { zh: ( <> 哈希函数把 key 算成一个数组下标,表直接跳过去 —— - 查找因此不需要逐个扫描已存的数据。代价是: - 两个不同的 key 可能算出同一个下标,而本章余下的篇幅,大半都在讲怎么处理它。 + 查找因此不需要逐个扫描已存的数据。代价是:两个不同的 key 可能算出同一个下标,而本章余下的篇幅,大半都在讲怎么处理它。 ), }} @@ -550,19 +539,14 @@ export default function HashChapter() { zh={ <>

- 在纸质字典里找一个字,有两种查法。第一种:从第一页开始逐页翻, - 翻到为止 —— 这是线性查找,O(n),字典越厚越慢。 - 第二种:用前面的索引,按读音直接翻到那一页,字典多厚几乎无所谓。 - 第二种查法之所以成立,是因为 + 在纸质字典里找一个字,有两种查法。第一种:从第一页开始逐页翻,翻到为止 —— 这是线性查找,O(n),字典越厚越慢。第二种:用前面的索引,按读音直接翻到那一页,字典多厚几乎无所谓。第二种查法之所以成立,是因为 这个字本身,经过一套固定规则,变成了一个位置。

数组早就有这种能力:给下标,O(1) 拿到元素 —— - 因为地址是算出来的,不是找出来的。但下标必须是较小的非负整数。 - 哈希表把这份能力推广到任意 key: + 因为地址是算出来的,不是找出来的。但下标必须是较小的非负整数。哈希表把这份能力推广到任意 key: - 哈希函数把 key(字符串、对象、一对坐标……)算成一个整数, - 这个整数就当数组下标用 + 哈希函数把 key(字符串、对象、一对坐标……)算成一个整数,这个整数就当数组下标用 ,全程不扫描。这就是全部思想。哈希表不是新的存储方式,它是 一个数组 + 一条算下标的规则 + 一套「两个 key 算出同一个下标怎么办」的方案。 @@ -664,13 +648,10 @@ export default function HashChapter() { } zh={

- Python 解析一个变量名,查的是命名空间,而命名空间就是 dict; - 浏览器缓存按 URL 找文件;数据库按相等的键连接两张表时,会临时建一张哈希表(hash join); - Redis 几乎就是一张带网络接口的哈希表。凡是「用名字直达内容」的地方, - 背后多半站着一张哈希表。有一个相关但不同的例子:Git + Python 解析一个变量名,查的是命名空间,而命名空间就是 dict;浏览器缓存按 URL 找文件;数据库按相等的键连接两张表时,会临时建一张哈希表(hash join); + Redis 几乎就是一张带网络接口的哈希表。凡是「用名字直达内容」的地方,背后多半站着一张哈希表。有一个相关但不同的例子:Git 用内容的密码学哈希给每次提交命名 —— - 那是另一类哈希函数,目标是「几乎不可能构造出同名的两份内容」, - 而不是「查得快」。 + 那是另一类哈希函数,目标是「几乎不可能构造出同名的两份内容」,而不是「查得快」。

} /> @@ -702,8 +683,7 @@ export default function HashChapter() { } zh={

- 哈希函数(hash function)接受一个 key, - 返回一个整数。怎么算几乎都行,但有三条要求决定了这张表能不能用 —— + 哈希函数(hash function)接受一个 key,返回一个整数。怎么算几乎都行,但有三条要求决定了这张表能不能用 —— 每一条背后都是一个「不满足会怎样」。

} @@ -797,8 +777,7 @@ export default function HashChapter() { } zh={

- 字符串怎么变成数?最经典的做法是多项式哈希: - 把每个字符的编码乘上 31 的一个幂次,再相加。以{" "} + 字符串怎么变成数?最经典的做法是多项式哈希:把每个字符的编码乘上 31 的一个幂次,再相加。以{" "} "cat" 为例(c = 99、a = 97、t = 116):

} @@ -835,8 +814,7 @@ export default function HashChapter() { 会得到相同的值:字母一样,只是顺序不同。乘上 31 的幂次, 让位置也参与运算 —— 越靠左的字符被乘 31 的次数越多。写成循环就是一行: - h = h × 31 + code(c)。最后一步,把这个大数对桶数取模, - 压进合法的数组下标范围。亲手转一转这台机器: + h = h × 31 + code(c)。最后一步,把这个大数对桶数取模,压进合法的数组下标范围。亲手转一转这台机器:

} /> @@ -867,12 +845,9 @@ export default function HashChapter() { } zh={

- 31 是奇素数。奇数乘子能保住结果的低位信息 —— 这很重要, - 因为桶数通常是 2 的幂,下标就取自低位。它还便宜: - 31 × i 等价于 (i << 5) − i, - 一次移位加一次减法。你刚才在实验室里造出的 Aa 与 BB{" "} - 冲突不是 bug —— 它们在 Java 里的 hashCode 都是 2112。 - 字符串有无限多个,int 只有 2³² 个,按抽屉原理 + 31 是奇素数。奇数乘子能保住结果的低位信息 —— 这很重要,因为桶数通常是 2 的幂,下标就取自低位。它还便宜: + 31 × i 等价于 (i << 5) − i,一次移位加一次减法。你刚才在实验室里造出的 Aa 与 BB{" "} + 冲突不是 bug —— 它们在 Java 里的 hashCode 都是 2112。字符串有无限多个,int 只有 2³² 个,按抽屉原理 必然存在同哈希的 key。冲突不可能被设计掉,只能被处理。

} @@ -921,17 +896,12 @@ export default function HashChapter() { zh={ <>

- 方案一:链地址法(separate chaining)。 - 每个桶挂的不是一个元素,而是一条链表,撞了就接到链上。 - 查找时先哈希定位桶,再沿链逐个比对 key。Java 的 HashMap + 方案一:链地址法(separate chaining)。每个桶挂的不是一个元素,而是一条链表,撞了就接到链上。查找时先哈希定位桶,再沿链逐个比对 key。Java 的 HashMap 和 §04 手写的版本都走这条路。

- 方案二:开放寻址(open addressing)。 - 每个桶最多放一个元素,撞了就按固定规则去找另一个空桶, - 最简单的规则是「往右试下一个」,叫 - 线性探测(linear probing)。CPython 的 dict、 - Rust 标准库的 HashMap 都用开放寻址,它对 CPU 缓存更友好 —— + 方案二:开放寻址(open addressing)。每个桶最多放一个元素,撞了就按固定规则去找另一个空桶,最简单的规则是「往右试下一个」,叫 + 线性探测(linear probing)。CPython 的 dict、Rust 标准库的 HashMap 都用开放寻址,它对 CPU 缓存更友好 —— 下一个被探测的桶通常就在同一条缓存行里。同一批 key,两种策略:

@@ -965,13 +935,7 @@ export default function HashChapter() { } zh={

- 哈希太差,或者输入是攻击者精心构造的,某条链就可能变得很长。 - Java 8 起,当一个桶里大约存到 8 个元素、 - 且总桶数不少于 64 时,这个桶会从链表转成红黑树, - 桶内查找从 O(n) 降到 O(log n)。为什么是 8? - 哈希分布良好时,单桶元素个数近似服从泊松分布, - 达到 8 的概率约为一亿分之六。树化不是为正常数据准备的, - 它是给恶意构造的输入(HashDoS 攻击)留的保险丝。 + 哈希太差,或者输入是攻击者精心构造的,某条链就可能变得很长。Java 8 起,当一个桶里大约存到 8 个元素、且总桶数不少于 64 时,这个桶会从链表转成红黑树,桶内查找从 O(n) 降到 O(log n)。为什么是 8?哈希分布良好时,单桶元素个数近似服从泊松分布,达到 8 的概率约为一亿分之六。树化不是为正常数据准备的,它是给恶意构造的输入(HashDoS 攻击)留的保险丝。

} /> @@ -998,11 +962,7 @@ export default function HashChapter() { } zh={

- 探测表里不能直接把格子改回空。查找会在第一个空格子处停下, - 所以那些被探测挤到后面的元素会突然变得不可达。 - 通用做法是写一块墓碑(tombstone), - 意思是「这里曾经有人」:查找继续往后走,插入可以复用它。 - 所以开放寻址的删除并不真正释放格子,墓碑多了还得重建整张表。 + 探测表里不能直接把格子改回空。查找会在第一个空格子处停下,所以那些被探测挤到后面的元素会突然变得不可达。通用做法是写一块墓碑(tombstone),意思是「这里曾经有人」:查找继续往后走,插入可以复用它。所以开放寻址的删除并不真正释放格子,墓碑多了还得重建整张表。

} /> @@ -1048,23 +1008,13 @@ export default function HashChapter() { <>

桶越满,冲突越频繁。衡量「满」的指标叫 - 负载因子(load factor)= 已存元素数 ÷ 桶数。 - Java HashMap 默认在负载因子超过 0.75 时扩容。 - 扩容 = 申请一个更大的桶数组(容量翻倍),然后把已有的每个 key - 重新安放一次 —— 后半步叫 rehash,而且没得省。 - 因为下标来自 hash % 桶数,桶数一变,key - 该待的地方就变了。举例:98262 % 8 = 6、98262 % 16 = 6, - 这个 key 恰好原地不动;但 98270 % 8 = 6 而 98270 % 16 = 14, - 它就得搬。容量是 2 的幂时,原本在 i 号桶的元素要么留在 i, - 要么搬到 i + 旧容量, + 负载因子(load factor)= 已存元素数 ÷ 桶数。Java HashMap 默认在负载因子超过 0.75 时扩容。扩容 = 申请一个更大的桶数组(容量翻倍),然后把已有的每个 key + 重新安放一次 —— 后半步叫 rehash,而且没得省。因为下标来自 hash % 桶数,桶数一变,key + 该待的地方就变了。举例:98262 % 8 = 6、98262 % 16 = 6,这个 key 恰好原地不动;但 98270 % 8 = 6 而 98270 % 16 = 14,它就得搬。容量是 2 的幂时,原本在 i 号桶的元素要么留在 i,要么搬到 i + 旧容量, 但每个元素都得被访问一次才知道是哪种。

- rehash 意味着某一次插入可能要花 O(n)。由于容量是翻倍的, - 这份代价会摊到之后的插入上,所以插入是均摊 O(1), - 而不是每次都 O(1)。为什么是 0.75?再高,每个桶平均挂的元素更多, - 每次查找要比较的次数变多 —— 只要负载因子有固定上限,平均仍是 O(1), - 只是常数变大、更慢;再低,大片桶空着浪费内存。 + rehash 意味着某一次插入可能要花 O(n)。由于容量是翻倍的,这份代价会摊到之后的插入上,所以插入是均摊 O(1),而不是每次都 O(1)。为什么是 0.75?再高,每个桶平均挂的元素更多,每次查找要比较的次数变多 —— 只要负载因子有固定上限,平均仍是 O(1),只是常数变大、更慢;再低,大片桶空着浪费内存。

} @@ -1189,10 +1139,8 @@ export default function HashChapter() { } zh={

- 哈希表的插入、查找、删除是平均 O(1),依赖两个前提: - 哈希函数分布均匀、负载因子受控(靠扩容维持)。 - 最坏是 O(n),发生在大量 key 落进同一个桶时。 - 只说「哈希表是 O(1)」,平均和前提两样都漏了 —— + 哈希表的插入、查找、删除是平均 O(1),依赖两个前提:哈希函数分布均匀、负载因子受控(靠扩容维持)。 + 最坏是 O(n),发生在大量 key 落进同一个桶时。只说「哈希表是 O(1)」,平均和前提两样都漏了 —— 这是面试作答里最常见的一处失分。

} @@ -1399,9 +1347,7 @@ public class MyHashMap { <> 两个细节:Java 不能直接 new 泛型数组,所以有那行强转; & 0x7fffffff 用来清掉符号位 —— hashCode - 可能为负,而 Java 里负数取模仍是负数,会得到非法下标。 - 真正的 HashMap 更进一步:容量恒为 2 的幂,于是用位与代替取模; - 取低位之前还会用{" "} + 可能为负,而 Java 里负数取模仍是负数,会得到非法下标。真正的 HashMap 更进一步:容量恒为 2 的幂,于是用位与代替取模;取低位之前还会用{" "} h ^ (h >>> 16){" "} 把高位混进低位,避免只在高位不同的 key 全挤进同一个桶。 @@ -1510,10 +1456,8 @@ public class MyHashMap { ), zh: ( <> - 这是教学版。CPython 真正的 dict 用开放寻址而非链地址, - 并且把条目按插入顺序存在另一个紧凑数组里。另外, - str 的 hash() 默认按进程加随机盐 - (防 HashDoS),所以 hash("abc"){" "} + 这是教学版。CPython 真正的 dict 用开放寻址而非链地址,并且把条目按插入顺序存在另一个紧凑数组里。另外, + str 的 hash() 默认按进程加随机盐(防 HashDoS),所以 hash("abc"){" "} 的具体数值每次运行都不同,绝不能依赖它。 ), @@ -1630,12 +1574,8 @@ public class MyHashMap { ), zh: ( <> - 这个简化版放弃了什么:它对 String(key) 计算哈希, - 而任何对象转成字符串都是 "[object Object]", - 于是所有对象 key 都落进同一个桶,在它们之间查找会退化成 O(n)。 - (比较 key 时仍用 ===,所以两个不同的对象依然是两个 key。) - 真正的 Map{" "}按身份对对象做哈希,任何值都能当 key, - 遍历还保持插入顺序。 + 这个简化版放弃了什么:它对 String(key) 计算哈希,而任何对象转成字符串都是 "[object Object]",于是所有对象 key 都落进同一个桶,在它们之间查找会退化成 O(n)。(比较 key 时仍用 ===,所以两个不同的对象依然是两个 key。) + 真正的 Map{" "}按身份对对象做哈希,任何值都能当 key,遍历还保持插入顺序。 ), }, @@ -1661,9 +1601,7 @@ public class MyHashMap { zh={

「put 的流程是什么?」「扩容时发生了什么?」「为什么 get - 平均 O(1)?」—— 每个答案都是上面的某一行,你可以指着它说。 - 没写进来的部分(树化、线程安全、ConcurrentHashMap) - 都是在这套骨架上加东西。 + 平均 O(1)?」—— 每个答案都是上面的某一行,你可以指着它说。没写进来的部分(树化、线程安全、ConcurrentHashMap)都是在这套骨架上加东西。

} /> @@ -1699,8 +1637,7 @@ public class MyHashMap {

每种语言都内置了工业级的哈希表,而且都是两副面孔: Map(字典)存键值对,Set(集合) - 只存 key —— 它就是不带 value 的同一张哈希表, - 所以「在不在」查得和查字典一样快。API 大同小异,陷阱各有不同: + 只存 key —— 它就是不带 value 的同一张哈希表,所以「在不在」查得和查字典一样快。API 大同小异,陷阱各有不同:

} /> @@ -1773,11 +1710,9 @@ Map big = new HashMap<>(10000);`, <> 契约:用自定义类当 key 时, 重写了 equals 就必须重写 hashCode。HashMap 先用 hashCode - 找桶,再在桶内用 equals 比对;两个「相等」的对象若哈希不同, - 会落进不同的桶,equals 根本没机会执行。由此还有第二条: + 找桶,再在桶内用 equals 比对;两个「相等」的对象若哈希不同,会落进不同的桶,equals 根本没机会执行。由此还有第二条: 放进表之后不要再修改 key —— - 条目还待在旧哈希选中的桶里,再也找不到了。HashMap 不保序: - 要插入序用 LinkedHashMap,要排序用 TreeMap。 + 条目还待在旧哈希选中的桶里,再也找不到了。HashMap 不保序:要插入序用 LinkedHashMap,要排序用 TreeMap。 ), }, @@ -1854,10 +1789,8 @@ ok = {(1, 2): "a tuple can be a key"} <> 易错点:可变对象(list / dict /{" "} set)没有 __hash__,不能当 key —— - 内容一变哈希就变,条目会失联。tuple 不可变所以可以, - 前提是它里面装的也全部可哈希。另外,d[k] 与{" "} - d.get(k) 的区别(抛 KeyError 还是返回 None) - 几乎每个新手都会踩一次。 + 内容一变哈希就变,条目会失联。tuple 不可变所以可以,前提是它里面装的也全部可哈希。另外,d[k] 与{" "} + d.get(k) 的区别(抛 KeyError 还是返回 None)几乎每个新手都会踩一次。 ), }, @@ -1925,10 +1858,7 @@ obj["1"]; // "a" —— key 被转成字符串,1 和 "1" 是同一个 ), zh: ( <> - 易错点:Object 的 key 只能是 string 或 symbol, - 数字和对象都会先被转成字符串;它还会继承原型上的 key, - 而用户输入的 __proto__ 当 key 是真实存在的安全问题。 - 遍历顺序也有意外:「长得像数组下标」的 key + 易错点:Object 的 key 只能是 string 或 symbol,数字和对象都会先被转成字符串;它还会继承原型上的 key,而用户输入的 __proto__ 当 key 是真实存在的安全问题。遍历顺序也有意外:「长得像数组下标」的 key 会排在最前面,并按数值升序。要字典就用 Map /{" "} Set;确实需要一个纯净对象时,用{" "} Object.create(null)。 @@ -2146,8 +2076,7 @@ obj["1"]; // "a" —— key 被转成字符串,1 和 "1" 是同一个 的注解干脆叫 @EqualsAndHashCode,Java 的 record 两个都自动生成。整个生态都在执行同一条规则: equals 相等的对象,hashCode 必须相等。HashMap - 的查找分两步:先用 hashCode 找桶,再用 equals 在桶内确认。 - 规则一破,第一步就走进了错误的桶。 + 的查找分两步:先用 hashCode 找桶,再用 equals 在桶内确认。规则一破,第一步就走进了错误的桶。

} /> @@ -2214,8 +2143,7 @@ obj["1"]; // "a" —— key 被转成字符串,1 和 "1" 是同一个 } zh={

- 判重、判环、求交集 —— 只关心某个值在不在, - 不关心它带着什么信息。→ LC 217、202、349、128。 + 判重、判环、求交集 —— 只关心某个值在不在,不关心它带着什么信息。→ LC 217、202、349、128。

} /> @@ -2265,8 +2193,7 @@ obj["1"]; // "a" —— key 被转成字符串,1 和 "1" 是同一个 } zh={

- 把「本质相同」的东西归到同一个 key 下:设计一个签名函数, - 让同类必定得到同一个 key。→ LC 49、383、299。 + 把「本质相同」的东西归到同一个 key 下:设计一个签名函数,让同类必定得到同一个 key。→ LC 49、383、299。

} /> @@ -2308,8 +2235,7 @@ obj["1"]; // "a" —— key 被转成字符串,1 和 "1" 是同一个 在数组中找两个数,和等于 target,返回它们的下标。暴力: 双层循环枚举所有数对,O(n²)。改进的来源: 看看内层循环在干什么 —— 对每个 i,它在 i - 前面的部分里找 target − nums[i],这是一次线性查找。 - 把「已经走过的数」存进哈希表,这次查找就变成一次 O(1) 的查表: + 前面的部分里找 target − nums[i],这是一次线性查找。把「已经走过的数」存进哈希表,这次查找就变成一次 O(1) 的查表:

} /> @@ -2423,10 +2349,8 @@ obj["1"]; // "a" —— key 被转成字符串,1 和 "1" 是同一个 } zh={

- 时间 O(n)、空间 O(n) —— 典型的用空间换时间。 - 追问一:为什么先查再存?为了防止自己和自己配对 —— - target = 8、nums[i] = 4 时,先存后查会让 4 匹配到自己那条记录。 - 追问二:数组有序呢?那就用对撞双指针,O(n) 时间、O(1) 空间(LC + 时间 O(n)、空间 O(n) —— 典型的用空间换时间。追问一:为什么先查再存?为了防止自己和自己配对 —— + target = 8、nums[i] = 4 时,先存后查会让 4 匹配到自己那条记录。追问二:数组有序呢?那就用对撞双指针,O(n) 时间、O(1) 空间(LC 167,数组章讲过)。有序想双指针,无序想哈希表。

} @@ -2465,8 +2389,7 @@ obj["1"]; // "a" —— key 被转成字符串,1 和 "1" 是同一个 题意:把字母相同、顺序不同的词分到同一组。暴力: 两两比较是否互为异位词,O(n² · k)。改进的来源: 与其让词互相比较,不如给每个词一个签名 —— - 一个「异位词相同、其他一律不同」的值。 - 然后一张 Map<签名, 列表> 就会自己把组分好: + 一个「异位词相同、其他一律不同」的值。然后一张 Map<签名, 列表> 就会自己把组分好:

} /> @@ -2586,8 +2509,7 @@ class Solution:

排序签名:每个词 O(k log k),写起来最短。 计数签名:数出 26 个字母各出现几次,拼成 - "a1e1t1" 这样的字符串,每个词 O(k), - 词很长时更划算。两者遵循同一条规则: + "a1e1t1" 这样的字符串,每个词 O(k),词很长时更划算。两者遵循同一条规则: 签名必须恰好刻画「同组」的那个本质。同样的思路会在 LC 249(移位字符串分组)和 LC 205(同构字符串)里再次出现。

@@ -2635,11 +2557,7 @@ class Solution: 题意:在无序数组中,求最长的数值连续 序列的长度,元素位置无所谓,而且要求 O(n)。第一反应: 排序后扫一遍 —— 但排序是 O(n log n),题目不允许。 - 改进的来源:把所有值丢进 Set,「x + 1 在不在」就变成 O(1), - 于是可以从某个值往右走,数出一条序列的长度。 - 但对每个值都这么做仍然是 O(n²):序列 1..100 里, - 从 1 数一遍、从 2 数一遍、从 3 再数一遍。 - 加一条规则就解决了:只从序列的起点开始数 —— + 改进的来源:把所有值丢进 Set,「x + 1 在不在」就变成 O(1),于是可以从某个值往右走,数出一条序列的长度。但对每个值都这么做仍然是 O(n²):序列 1..100 里,从 1 数一遍、从 2 数一遍、从 3 再数一遍。加一条规则就解决了:只从序列的起点开始数 —— 起点就是「x − 1 不在 Set 里」的那个 x:

} @@ -2764,13 +2682,9 @@ class Solution: } zh={

- 这里确实有嵌套的 while,但它只从序列的起点启动, - 而每条序列只有一个起点。把所有 while + 这里确实有嵌套的 while,但它只从序列的起点启动,而每条序列只有一个起点。把所有 while 的迭代加起来,每个值只被「数过」一次。外层 n - 次起点检查,加上内层总共至多 n 步,合起来 O(n)。 - 这和数组章滑动窗口的 2n 论证是同一套均摊推理。 - 追问:能不能遍历 nums 而不是 set?可以, - 但重复元素会白做几次起点检查 —— 遍历 set 更干净。 + 次起点检查,加上内层总共至多 n 步,合起来 O(n)。这和数组章滑动窗口的 2n 论证是同一套均摊推理。追问:能不能遍历 nums 而不是 set?可以,但重复元素会白做几次起点检查 —— 遍历 set 更干净。

} /> @@ -2829,8 +2743,7 @@ class Solution: ), zh: ( <> - 哈希表 = 数组 + 哈希函数 + 冲突处理方案。 - 哈希函数把 key 算成下标,于是数组只给整数下标的 O(1) + 哈希表 = 数组 + 哈希函数 + 冲突处理方案。哈希函数把 key 算成下标,于是数组只给整数下标的 O(1) 直达,任何 key 都能用上。 ), @@ -2848,10 +2761,7 @@ class Solution: ), zh: ( <> - 哈希函数必须确定、均匀、快。可能的 key 比桶多, - 冲突必然发生。链地址法给每个桶挂一条链(Java); - 开放寻址则去探测别的空位(Python), - 它在高负载因子下代价更大,删除还得用墓碑。 + 哈希函数必须确定、均匀、快。可能的 key 比桶多,冲突必然发生。链地址法给每个桶挂一条链(Java);开放寻址则去探测别的空位(Python),它在高负载因子下代价更大,删除还得用墓碑。 ), }, @@ -2870,10 +2780,7 @@ class Solution: zh: ( <> 负载因子越线(Java 默认 0.75)后,表会申请更大的数组并 - 把每个 key 重新安放一次 —— 因为下标依赖桶数。 - 所以某一次插入可能花 O(n),插入的严谨说法是均摊 O(1)。 - 完整表述:哈希均匀且负载因子受控时平均 O(1), - 大量 key 挤进同一个桶时最坏 O(n)。 + 把每个 key 重新安放一次 —— 因为下标依赖桶数。所以某一次插入可能花 O(n),插入的严谨说法是均摊 O(1)。完整表述:哈希均匀且负载因子受控时平均 O(1),大量 key 挤进同一个桶时最坏 O(n)。 ), }, @@ -2891,10 +2798,8 @@ class Solution: ), zh: ( <> - 每种语言各有一个陷阱。Java:重写 equals 就要重写 hashCode, - 而且 key 放进表后不要再改。Python:可变对象不能当 key(list - 不行,元素全可哈希的 tuple 可以),3.7 起 dict 保持插入序。 - JavaScript:用 Map,别用普通 Object —— Object 的 key + 每种语言各有一个陷阱。Java:重写 equals 就要重写 hashCode,而且 key 放进表后不要再改。Python:可变对象不能当 key(list + 不行,元素全可哈希的 tuple 可以),3.7 起 dict 保持插入序。JavaScript:用 Map,别用普通 Object —— Object 的 key 会被转成字符串,原型还会额外贡献 key。 ), @@ -2912,9 +2817,7 @@ class Solution: zh: ( <> 三个解题信号:「见过吗」→ Set;「配对」→ Map - 存「值 → 下标 / 次数」;「分组计数」→ Map<签名, 列表>。 - Set 就是只存 key 的哈希表。前缀和 + 哈希(LC 560) - 就是把「两数之和」用在前缀和上。 + 存「值 → 下标 / 次数」;「分组计数」→ Map<签名, 列表>。Set 就是只存 key 的哈希表。前缀和 + 哈希(LC 560)就是把「两数之和」用在前缀和上。 ), }, diff --git a/app/hash/viz.tsx b/app/hash/viz.tsx index 8d9a9ea..f19be85 100644 --- a/app/hash/viz.tsx +++ b/app/hash/viz.tsx @@ -109,8 +109,7 @@ export function HashLab() { } zh={ <> - 读入字符 '{s.ch}'(编码 {s.code}):旧 h 乘 31,再加上它。 - 每个字符都会改变结果,位置也会 —— 越靠前的字符被乘 31 的次数越多。 + 读入字符 '{s.ch}'(编码 {s.code}):旧 h 乘 31,再加上它。每个字符都会改变结果,位置也会 —— 越靠前的字符被乘 31 的次数越多。 } />, @@ -168,8 +167,7 @@ export function HashLab() { zh={ <> 冲突(collision)。「{w}」和「{occupants.join("、")} - 」被分进了同一个 {t} 号桶 —— 不同的 key、相同的下标。 - 接下来怎么办,就是 §03 的主题。 + 」被分进了同一个 {t} 号桶 —— 不同的 key、相同的下标。接下来怎么办,就是 §03 的主题。 } /> @@ -185,8 +183,7 @@ export function HashLab() { } zh={ <> - 「{w}」落进 {t} 号桶。以后查它:算出同样的哈希、同样的取模, - 一步跳到 {t} 号桶,不需要逐个扫描 —— 这就是查得快的全部原因。 + 「{w}」落进 {t} 号桶。以后查它:算出同样的哈希、同样的取模,一步跳到 {t} 号桶,不需要逐个扫描 —— 这就是查得快的全部原因。 } /> @@ -349,8 +346,7 @@ function buildChainFrames(): ChainFrame[] { } zh={ <> - 6 个单词依次插入 8 个桶。链地址法:每个桶不是只放一个元素, - 而是挂一条链表 —— 撞了就接到链上。 + 6 个单词依次插入 8 个桶。链地址法:每个桶不是只放一个元素,而是挂一条链表 —— 撞了就接到链上。 } /> @@ -374,9 +370,7 @@ function buildChainFrames(): ChainFrame[] { } zh={ <> - 「{w}」也被哈希到 {b} 号桶 —— 冲突发生。处理方式: - 接到该桶链表的尾部。代价:以后查这个桶里的 key, - 要沿链逐个比对。 + 「{w}」也被哈希到 {b} 号桶 —— 冲突发生。处理方式:接到该桶链表的尾部。代价:以后查这个桶里的 key,要沿链逐个比对。 } /> @@ -414,10 +408,8 @@ function buildChainFrames(): ChainFrame[] { } zh={ <> - 插入完毕:最长的链只有 2 个节点,查任何 key 最多比对 2 次。 - 只要哈希分布均匀、负载因子受控,链长的平均值就是常数 —— - 这正是「平均 O(1)」的依据,也说明了它为什么只是平均值: - 把这 6 个词全塞进同一个桶,同样一次查找就要比对 6 次。 + 插入完毕:最长的链只有 2 个节点,查任何 key 最多比对 2 次。只要哈希分布均匀、负载因子受控,链长的平均值就是常数 —— + 这正是「平均 O(1)」的依据,也说明了它为什么只是平均值:把这 6 个词全塞进同一个桶,同样一次查找就要比对 6 次。 } /> @@ -452,8 +444,7 @@ function buildProbeFrames(): ProbeFrame[] { } zh={ <> - 同一批单词,这次用开放寻址 · 线性探测:每个格子只放一个元素, - 撞了就往右找下一个空位,到头绕回 0。 + 同一批单词,这次用开放寻址 · 线性探测:每个格子只放一个元素,撞了就往右找下一个空位,到头绕回 0。 } /> @@ -528,10 +519,8 @@ function buildProbeFrames(): ProbeFrame[] { } zh={ <> - 4~7 号已经连成一片,而且绕过末尾一直接到 0、1 号。 - 一次冲突把元素挤到旁边,让下一次冲突更容易发生,连片就越来越长 —— - 这叫聚集(clustering)。所以开放寻址比链地址法更怕负载因子, - 经典线性探测通常压到 0.5~0.7 就要扩容,而不是 0.75(SwissTable 等现代实现分组探测,可到 0.875,Rust 的 HashMap 就是一例)。 + 4~7 号已经连成一片,而且绕过末尾一直接到 0、1 号。一次冲突把元素挤到旁边,让下一次冲突更容易发生,连片就越来越长 —— + 这叫聚集(clustering)。所以开放寻址比链地址法更怕负载因子,经典线性探测通常压到 0.5~0.7 就要扩容,而不是 0.75(SwissTable 等现代实现分组探测,可到 0.875,Rust 的 HashMap 就是一例)。 } /> diff --git a/app/heap/page.tsx b/app/heap/page.tsx index d60beb1..9809171 100644 --- a/app/heap/page.tsx +++ b/app/heap/page.tsx @@ -54,8 +54,7 @@ const F215: ArrayFrame[] = [ ), zh: ( <> - 维护一个最多装 2 个元素的小根堆,让它始终装着「迄今最大的 2 个」。 - 第一个数是 3:堆没满,直接进。此刻门槛(堆顶,也就是堆里最小的)是 3。 + 维护一个最多装 2 个元素的小根堆,让它始终装着「迄今最大的 2 个」。第一个数是 3:堆没满,直接进。此刻门槛(堆顶,也就是堆里最小的)是 3。 ), }, @@ -93,8 +92,7 @@ const F215: ArrayFrame[] = [ ), zh: ( <> - 下一个数 1(右边这个标记格是待检验的新数,不在堆里)。 - 和门槛比较:1 < 2,连堆里最弱的都比不过,直接丢弃,堆不动。 + 下一个数 1(右边这个标记格是待检验的新数,不在堆里)。和门槛比较:1 < 2,连堆里最弱的都比不过,直接丢弃,堆不动。 ), }, @@ -132,8 +130,7 @@ const F215: ArrayFrame[] = [ ), zh: ( <> - 淘汰 2、修复堆序之后,堆里是 {"{3, 5}"},门槛升到 3。 - 门槛只会越来越高 —— 这正是我们想要的:每替换一次,幸存者就更强一点。 + 淘汰 2、修复堆序之后,堆里是 {"{3, 5}"},门槛升到 3。门槛只会越来越高 —— 这正是我们想要的:每替换一次,幸存者就更强一点。 ), }, @@ -150,8 +147,7 @@ const F215: ArrayFrame[] = [ ), zh: ( <> - 下一个数 6:6 > 3,进,挤掉 3。堆里是 {"{5, 6}"}, - 门槛升到 5。 + 下一个数 6:6 > 3,进,挤掉 3。堆里是 {"{5, 6}"},门槛升到 5。 ), }, @@ -186,9 +182,7 @@ const F215: ArrayFrame[] = [ ), zh: ( <> - 扫完了。堆里是 {"{5, 6}"},正是最大的 2 个,堆顶 5 就是第 2 大的元素。 - 全程 O(n log k) 时间、O(k) 空间。n 很大而 k 很小时, - 这比全排序的 O(n log n) 少做很多工作。 + 扫完了。堆里是 {"{5, 6}"},正是最大的 2 个,堆顶 5 就是第 2 大的元素。全程 O(n log k) 时间、O(k) 空间。n 很大而 k 很小时,这比全排序的 O(n log n) 少做很多工作。 ), }, @@ -215,8 +209,7 @@ const F347: ArrayFrame[] = [ zh: ( <> 第一步 哈希计数:数字 1 出现 3 次,2 出现 2 次, - 3 出现 1 次。第二步把这些频次喂给一个最多装 2 个的小根堆。 - 先放数字 1 的频次 3。 + 3 出现 1 次。第二步把这些频次喂给一个最多装 2 个的小根堆。先放数字 1 的频次 3。 ), }, @@ -235,9 +228,7 @@ const F347: ArrayFrame[] = [ ), zh: ( <> - 数字 2 的频次是 2,入堆并上浮到顶。堆满了, - 门槛就是仍在堆里的最低频次 2。 - 注意格子里画的是频次,不是数字本身。 + 数字 2 的频次是 2,入堆并上浮到顶。堆满了,门槛就是仍在堆里的最低频次 2。注意格子里画的是频次,不是数字本身。 ), }, @@ -277,8 +268,7 @@ const F347: ArrayFrame[] = [ zh: ( <> 堆里剩下频次 {"{2, 3}"},分别属于数字 2 和 1 —— - 就是前 2 高频的元素。计数 O(n),维护堆 O(n log k),合计 O(n log k)。 - 这是你的第一道「两种结构组合」的题:哈希表 + 堆。 + 就是前 2 高频的元素。计数 O(n),维护堆 O(n log k),合计 O(n log k)。这是你的第一道「两种结构组合」的题:哈希表 + 堆。 ), }, @@ -302,8 +292,7 @@ const F23: ArrayFrame[] = [ ), zh: ( <> - 三条升序链表:1→4→5、1→3→4、2→6。把三个头结点放进小根堆, - 得到 {"{1, 1, 2}"}。堆顶是三条链里最小的值,也就是合并结果的下一个数。 + 三条升序链表:1→4→5、1→3→4、2→6。把三个头结点放进小根堆,得到 {"{1, 1, 2}"}。堆顶是三条链里最小的值,也就是合并结果的下一个数。 ), }, @@ -345,8 +334,7 @@ const F23: ArrayFrame[] = [ ), zh: ( <> - 弹出 1(来自链 2),补进它的下一个结点 3。 - 堆里是 {"{2, 3, 4}"}。 + 弹出 1(来自链 2),补进它的下一个结点 3。堆里是 {"{2, 3, 4}"}。
输出:1 1 @@ -411,8 +399,7 @@ const F23: ArrayFrame[] = [ ), zh: ( <> - 接连弹出两个 4。链 1 的 4 后面还有 5,补进堆; - 链 2 的 4 是那条链的最后一个结点,没有东西可补,于是堆缩到 {"{5, 6}"}。 + 接连弹出两个 4。链 1 的 4 后面还有 5,补进堆;链 2 的 4 是那条链的最后一个结点,没有东西可补,于是堆缩到 {"{5, 6}"}。
输出:1 1 2 3 4 4 @@ -441,8 +428,7 @@ const F23: ArrayFrame[] = [
输出:1 1 2 3 4 4 5 6
- 总共 N 个结点,每个结点进堆、出堆各一次,每次堆操作 O(log k), - 所以是 O(N log k) 时间、O(k) 空间 —— 堆里最多只有 k 个结点。 + 总共 N 个结点,每个结点进堆、出堆各一次,每次堆操作 O(log k),所以是 O(N log k) 时间、O(k) 空间 —— 堆里最多只有 k 个结点。 ), }, @@ -496,10 +482,7 @@ export default function HeapChapter() { ), zh: ( <> - 一个永远先把最要紧的元素交给你的容器。它从不做全排序, - 只承诺一件事:堆顶是当前的最小值(或最大值); - 取走它、塞进新值,都只要 O(log n)。 - 承诺得少,所以跑得快。 + 一个永远先把最要紧的元素交给你的容器。它从不做全排序,只承诺一件事:堆顶是当前的最小值(或最大值);取走它、塞进新值,都只要 O(log n)。承诺得少,所以跑得快。 ), }} @@ -573,37 +556,27 @@ export default function HeapChapter() { zh={ <>

- 食堂窗口按到达顺序服务,那是上一章的队列。 - 急诊室不能这么干:五分钟前才到的心梗病人,要排在已经等了一小时的 - 崴脚病人前面。这套流程叫分诊(triage): - 每空出一间诊室,就叫当前最危重的病人进去。 - 没有人去算谁排第二、谁排第三 —— 反正下一次还得重新挑一遍。 + 食堂窗口按到达顺序服务,那是上一章的队列。急诊室不能这么干:五分钟前才到的心梗病人,要排在已经等了一小时的崴脚病人前面。这套流程叫分诊(triage):每空出一间诊室,就叫当前最危重的病人进去。没有人去算谁排第二、谁排第三 —— 反正下一次还得重新挑一遍。

这就是堆(heap)的全部工作:在一堆不断变化的数据里, O(1) 报出最小值(或最大值), - O(log n) 取走它或插入新值。 - 「不断变化」这四个字是关键:数据不是一次给全的,就像病人一直在来。 + O(log n) 取走它或插入新值。「不断变化」这四个字是关键:数据不是一次给全的,就像病人一直在来。

- 那为什么不干脆排个序,让最危重的站第一个? - 可以,但排序做的事远超题目所需:O(n log n) 把 + 那为什么不干脆排个序,让最危重的站第一个?可以,但排序做的事远超题目所需:O(n log n) 把 全部 n 个元素的先后都定死,而你只要 - 其中一个。更麻烦的是更新: - 往有序数组里插一个新病人,要搬移元素,O(n) + 其中一个。更麻烦的是更新:往有序数组里插一个新病人,要搬移元素,O(n) —— 这是第 1 章算过的账。堆的取舍正好相反: - 只维护「谁是最值」这一件事, - 所以插入和删除都是 O(log n)。 + 只维护「谁是最值」这一件事,所以插入和删除都是 O(log n)。

有两个词经常被混用,这里先分清。 优先队列(priority queue)是一个 接口:一个能不断放入、又能随时取出优先级最高者的容器; 二叉堆(binary heap)是这个接口最常见的 - 实现。二者的关系就像「排序」和「快速排序」。 - 几乎所有语言的 PriorityQueue / heapq{" "} - 底层都是二叉堆,本章造的正是这台引擎。 - 它们不是同义词,所以本章说「堆」指结构,说「优先队列」指接口。 + 实现。二者的关系就像「排序」和「快速排序」。几乎所有语言的 PriorityQueue / heapq{" "} + 底层都是二叉堆,本章造的正是这台引擎。它们不是同义词,所以本章说「堆」指结构,说「优先队列」指接口。

} @@ -628,8 +601,7 @@ export default function HeapChapter() { } zh={

- 堆只保证一件事:堆顶是全堆最小(或最大)的元素。 - 其余元素之间的顺序,包括同一层的两个结点, + 堆只保证一件事:堆顶是全堆最小(或最大)的元素。其余元素之间的顺序,包括同一层的两个结点, 没有任何规定。承诺越少,维护越省。

} @@ -654,8 +626,7 @@ export default function HeapChapter() { zh={

插入一个值、取走当前最值,都只走 - 一条与树高等长的路径:O(log n)。 - 只看堆顶不取走则是 O(1)。正因如此,堆能扛住源源不断的数据流。 + 一条与树高等长的路径:O(log n)。只看堆顶不取走则是 O(1)。正因如此,堆能扛住源源不断的数据流。

} /> @@ -680,8 +651,7 @@ export default function HeapChapter() { } zh={

- 任务调度、Dijkstra 最短路、Huffman 编码、Top-K、合并 K 路有序序列…… - 一切「反复取当前最值」的问题,底下几乎都是堆在转。 + 任务调度、Dijkstra 最短路、Huffman 编码、Top-K、合并 K 路有序序列……一切「反复取当前最值」的问题,底下几乎都是堆在转。

} /> @@ -705,8 +675,7 @@ export default function HeapChapter() { zh={

一个常见的混淆:本章的「堆」和堆内存(heap memory) - 毫无关系,只是重名。堆内存是程序运行时动态分配对象的那片区域, - 与调用栈相对。本章的堆是一种数据结构 —— + 毫无关系,只是重名。堆内存是程序运行时动态分配对象的那片区域,与调用栈相对。本章的堆是一种数据结构 —— 一棵有特定形状的树。看到这个词,先分清指的是哪一个。

} @@ -738,8 +707,7 @@ export default function HeapChapter() { } zh={

- 堆是一棵二叉树,但只守两条规矩: - 一条管形状,一条管顺序。 + 堆是一棵二叉树,但只守两条规矩:一条管形状,一条管顺序。

} /> @@ -766,9 +734,7 @@ export default function HeapChapter() { } zh={

- 完全二叉树(complete binary tree):除最后一层外, - 每层都填满;最后一层的结点全部靠左连续排列,中间不留空位 - (第 7 章见过)。这条规矩让树又矮又宽: + 完全二叉树(complete binary tree):除最后一层外,每层都填满;最后一层的结点全部靠左连续排列,中间不留空位(第 7 章见过)。这条规矩让树又矮又宽: n 个结点的高度恰好是 ⌊log₂n⌋。它同时保证没有位置被跳过 —— 这正是下面「塞进数组」的前提。

@@ -796,10 +762,7 @@ export default function HeapChapter() { } zh={

- 每个父结点 ≤ 它的每个孩子。沿着每条路径层层递推, - 根就成了全树最小值 —— 这就是小根堆(min-heap)。 - 这条规矩只约束父子这一对,兄弟之间没有任何关系: - 左孩子完全可以比右孩子大。父 ≥ 子则是 + 每个父结点 ≤ 它的每个孩子。沿着每条路径层层递推,根就成了全树最小值 —— 这就是小根堆(min-heap)。这条规矩只约束父子这一对,兄弟之间没有任何关系:左孩子完全可以比右孩子大。父 ≥ 子则是 大根堆(max-heap),堆顶是最大值,两者完全对称。

} @@ -833,14 +796,9 @@ export default function HeapChapter() { } zh={

- 很多人以为堆就是「从小到大排好的树」。不是。 - 堆只保证每一对父 → 子是有序的, - 同一层的两个结点(兄弟或堂兄弟)之间没有任何规定。 - 所以把底层数组打印出来,常常是{" "} - [1, 3, 2, 7, 4, 5] 这样:看着不像升序, - 但它是合法的堆 —— 1≤3、1≤2、3≤7、3≤4、2≤5,每一对父子都成立。 - 正因为堆一次只理一条链而不是整批数据, - 单次更新才是 O(log n),而不是全排序的 O(n log n)。 + 很多人以为堆就是「从小到大排好的树」。不是。堆只保证每一对父 → 子是有序的, + 同一层的两个结点(兄弟或堂兄弟)之间没有任何规定。所以把底层数组打印出来,常常是{" "} + [1, 3, 2, 7, 4, 5] 这样:看着不像升序,但它是合法的堆 —— 1≤3、1≤2、3≤7、3≤4、2≤5,每一对父子都成立。正因为堆一次只理一条链而不是整批数据,单次更新才是 O(log n),而不是全排序的 O(n log n)。

} /> @@ -863,12 +821,8 @@ export default function HeapChapter() { } zh={

- 现在两条规矩接上了。规矩 ① 说完全二叉树没有空洞, - 于是可以把结点按层、从左到右编号 - (根是 0,下一层是 1、2,再下一层是 3、4、5、6……), - 然后直接铺进一个数组,编号就是下标。 - 因为没有空洞,数组不会浪费任何一格; - 也不需要指针 —— 每一条父子连线都由三条公式 + 现在两条规矩接上了。规矩 ① 说完全二叉树没有空洞,于是可以把结点按层、从左到右编号 + (根是 0,下一层是 1、2,再下一层是 3、4、5、6……),然后直接铺进一个数组,编号就是下标。因为没有空洞,数组不会浪费任何一格;也不需要指针 —— 每一条父子连线都由三条公式 算出来:

} @@ -960,11 +914,8 @@ export default function HeapChapter() {

这个思路你见过。数组那一章里,元素地址 ={" "} 首地址 + 下标 × 元素大小,同样是 - 算出来的,不是存下来的。 - 堆把这套下标算术从「数组元素」搬到了「树的父子关系」上。 - 省掉指针换来两个实在的好处:不占额外内存 - (链式二叉树每个结点要存两根指针), - 以及元素在内存里连续排列、对 CPU 缓存更友好 + 算出来的,不是存下来的。堆把这套下标算术从「数组元素」搬到了「树的父子关系」上。省掉指针换来两个实在的好处:不占额外内存 + (链式二叉树每个结点要存两根指针),以及元素在内存里连续排列、对 CPU 缓存更友好 (还是第 1 章的那份红利)。

} @@ -994,10 +945,8 @@ export default function HeapChapter() {

有些教科书让堆从下标 1 开始,公式会短一点:父 ={" "} i / 2、左孩子 = 2i、右孩子 ={" "} - 2i + 1。代价是下标 0 空着不用。 - 实际实现(Java 的 PriorityQueue、Python 的{" "} - heapq)都从 0 开始,不浪费空间, - 所以本章统一用 0 起步的公式。两套约定都对,别在同一份代码里混用。 + 2i + 1。代价是下标 0 空着不用。实际实现(Java 的 PriorityQueue、Python 的{" "} + heapq)都从 0 开始,不浪费空间,所以本章统一用 0 起步的公式。两套约定都对,别在同一份代码里混用。

} /> @@ -1045,9 +994,7 @@ export default function HeapChapter() {

堆只有两个动作,而且互为镜像:插入时新元素从底往上找位置,叫 上浮(sift up);删除时元素从顶往下找位置,叫 - 下沉(sift down)。 - 在下面的实验室里 push / pop 几次, - 盯着树视图和数组视图一起变化 —— + 下沉(sift down)。在下面的实验室里 push / pop 几次,盯着树视图和数组视图一起变化 —— 它们画的是同一份数据。你会发现所谓堆操作,不过是 比较一对父子、不合规就交换,一路重复到不用再换为止。

@@ -1119,13 +1066,10 @@ export default function HeapChapter() {

  1. - ① 写到数组尾部,也就是完全二叉树的下一个空位。 - 这一步保证形状规矩不被破坏。 + ① 写到数组尾部,也就是完全二叉树的下一个空位。这一步保证形状规矩不被破坏。
  2. - ② 上浮:新值和父结点比较,比父结点小就交换, - 换上去再和新的父结点比,直到「不比父结点小」或「已经到根」为止。 - 最长的路径是从最底层走到根,所以交换次数不超过树高: + ② 上浮:新值和父结点比较,比父结点小就交换,换上去再和新的父结点比,直到「不比父结点小」或「已经到根」为止。最长的路径是从最底层走到根,所以交换次数不超过树高: O(log n)。
@@ -1137,21 +1081,15 @@ export default function HeapChapter() { ① 读出堆顶。它就是答案 —— 小根堆里的最小值。
  • - ② 把最后一个元素搬到堆顶。为什么是最后一个? - 因为删掉末尾不破坏完全二叉树的形状,删掉别的位置会留下一个空洞。 + ② 把最后一个元素搬到堆顶。为什么是最后一个?因为删掉末尾不破坏完全二叉树的形状,删掉别的位置会留下一个空洞。
  • - ③ 下沉。刚补到顶上的这个值多半偏大: - 让它和两个孩子里较小的那个比较,比孩子大就交换、跟着下去, - 直到「比两个孩子都小」或「没有孩子」为止。 - 同样不超过树高:O(log n)。 + ③ 下沉。刚补到顶上的这个值多半偏大:让它和两个孩子里较小的那个比较,比孩子大就交换、跟着下去,直到「比两个孩子都小」或「没有孩子」为止。同样不超过树高:O(log n)。

    • 下沉时为什么必须挑较小的孩子? - 假设你换了较大的那个孩子:它升上去当了父结点, - 而更小的兄弟还在它下面,「父 ≤ 子」当场被破坏。 - 只有把较小的孩子提上来,才能同时压住两个孩子。 + 假设你换了较大的那个孩子:它升上去当了父结点,而更小的兄弟还在它下面,「父 ≤ 子」当场被破坏。只有把较小的孩子提上来,才能同时压住两个孩子。

    } @@ -1291,10 +1229,7 @@ export default function HeapChapter() { zh={

    表里最反直觉的一行是{" "} - heapify:把乱序数组原地整理成堆,只要 O(n)。 - 直觉会说「n 个元素,每个可能下沉 log n 层,应该是 O(n log n)」。 - 点一下实验室里的「随机数组建堆」, - 数数它到底交换了几次 —— 通常远少于预期。原因如下: + heapify:把乱序数组原地整理成堆,只要 O(n)。直觉会说「n 个元素,每个可能下沉 log n 层,应该是 O(n log n)」。点一下实验室里的「随机数组建堆」,数数它到底交换了几次 —— 通常远少于预期。原因如下:

    } /> @@ -1335,17 +1270,10 @@ export default function HeapChapter() { zh={

    做法是 - 从最后一个父结点(下标 n/2 − 1)倒着走到下标 0,逐个下沉, - 这叫 Floyd 建堆。关键在于「谁能沉得远」:在完全二叉树里, - 大约一半的结点是叶子,位于最底层,下沉 0 步; - 上一层约 1/4 的结点最多沉 1 步;再上一层约 1/8 最多沉{" "} - 2 步…… 越能沉得深的结点,数量越稀少。 - 把总步数加起来是 Σ d · n / 2d+1,而 Σ d / 2 - d+1 = 1,所以总交换次数不超过 n,建堆是 O(n)。 - 逐个 push 恰好相反:它让每个新元素往根的方向爬, - 而爬得最远的正是数量最多的底层结点 —— 差的就是这一个 log。 - 记住这条:数据已经全在手上就用 heapify(O(n)); - 数据逐个到达就只能逐个 push。 + 从最后一个父结点(下标 n/2 − 1)倒着走到下标 0,逐个下沉,这叫 Floyd 建堆。关键在于「谁能沉得远」:在完全二叉树里, + 大约一半的结点是叶子,位于最底层,下沉 0 步;上一层约 1/4 的结点最多沉 1 步;再上一层约 1/8 最多沉{" "} + 2 步…… 越能沉得深的结点,数量越稀少。把总步数加起来是 Σ d · n / 2d+1,而 Σ d / 2 + d+1 = 1,所以总交换次数不超过 n,建堆是 O(n)。逐个 push 恰好相反:它让每个新元素往根的方向爬,而爬得最远的正是数量最多的底层结点 —— 差的就是这一个 log。记住这条:数据已经全在手上就用 heapify(O(n));数据逐个到达就只能逐个 push。

    } /> @@ -1377,16 +1305,8 @@ export default function HeapChapter() { } zh={

    - 堆擅长「反复取最值」,但有三件事它不擅长: - 第一,查找某个特定值要 O(n); - 第二,按顺序输出全部元素需要 pop n 次,合计 O(n log n) —— - 这个过程正是堆排序(heap sort), - 它在最好、平均、最坏情况下都是 O(n log n),额外空间 O(1), - 而且不稳定:相等的元素出堆顺序可能和入堆顺序不同; - 第三,堆只把堆顶交给你,所以要拿第 k 小的值, - 通常得先 pop 掉 k − 1 个。 - 如果你需要随时按序访问或做范围查询,请回到第 8 章的 BST / TreeMap。 - 选错结构是面试和工程里最贵的错误。 + 堆擅长「反复取最值」,但有三件事它不擅长:第一,查找某个特定值要 O(n);第二,按顺序输出全部元素需要 pop n 次,合计 O(n log n) —— + 这个过程正是堆排序(heap sort),它在最好、平均、最坏情况下都是 O(n log n),额外空间 O(1),而且不稳定:相等的元素出堆顺序可能和入堆顺序不同;第三,堆只把堆顶交给你,所以要拿第 k 小的值,通常得先 pop 掉 k − 1 个。如果你需要随时按序访问或做范围查询,请回到第 8 章的 BST / TreeMap。选错结构是面试和工程里最贵的错误。

    } /> @@ -1424,12 +1344,8 @@ export default function HeapChapter() { zh={

    把 §03 的动作写成代码。真正干活的只有三个方法: - siftUp(上浮)、siftDown(下沉), - 以及 O(n) 建堆的静态方法 heapify。 - push / pop 只是把「改数组」和 - 「修复堆序」拼在一起。底层用一个普通的可变数组存, - 父子关系全靠 §02 的三条公式算。 - 建议先盖住代码,自己默写一遍 siftDown —— + siftUp(上浮)、siftDown(下沉),以及 O(n) 建堆的静态方法 heapify。 + push / pop 只是把「改数组」和「修复堆序」拼在一起。底层用一个普通的可变数组存,父子关系全靠 §02 的三条公式算。建议先盖住代码,自己默写一遍 siftDown —— 「挑较小的孩子」那一步,是最多人写错的地方。

    } @@ -1569,9 +1485,7 @@ export default function HeapChapter() { ), zh: ( <> - 易错点:比较写的是 a[i] >= a[p], - 相等时不交换,可以避免相等元素之间无意义的来回交换。 - 想要大根堆,把两处比较的方向反过来即可,其余一行都不用改。 + 易错点:比较写的是 a[i] >= a[p],相等时不交换,可以避免相等元素之间无意义的来回交换。想要大根堆,把两处比较的方向反过来即可,其余一行都不用改。 ), }, @@ -1694,8 +1608,7 @@ export default function HeapChapter() { <> 实际项目里别手写:标准库的 heapq{" "} 就是同一套算法的 C 实现(heappush、 - heappop、heapify)。 - 这里手写只为看清内部;§05 教你怎么直接用 heapq。 + heappop、heapify)。这里手写只为看清内部;§05 教你怎么直接用 heapq。 ), }, @@ -1834,11 +1747,7 @@ export default function HeapChapter() { zh: ( <> 为什么这段值得背下来:JavaScript 没有 - 内置的堆或优先队列(§05 详述)。 - 面试和笔试里经常要当场手写一个, - 把这个类练到不用想就能写出来,Top-K 和 Dijkstra 才有把握。 - 可选参数 less 让同一个类也能比较对象, - 例如按频次或按结点值排序;§06 的精讲就用到了它。 + 内置的堆或优先队列(§05 详述)。面试和笔试里经常要当场手写一个,把这个类练到不用想就能写出来,Top-K 和 Dijkstra 才有把握。可选参数 less 让同一个类也能比较对象,例如按频次或按结点值排序;§06 的精讲就用到了它。 ), }, @@ -1911,16 +1820,12 @@ export default function HeapChapter() { } zh={

    - §04 是为了让你理解机制,真正做题时用语言自带的实现。 - 三种语言在这里差别很大:Java 有开箱即用的{" "} + §04 是为了让你理解机制,真正做题时用语言自带的实现。三种语言在这里差别很大:Java 有开箱即用的{" "} PriorityQueue;Python 有 heapq —— 一组直接操作普通 list 的函数; - JavaScript 没有内置的堆, - 这也是上一节要你把手写堆记熟的原因。 - 有两个共同的陷阱要记住: + JavaScript 没有内置的堆,这也是上一节要你把手写堆记熟的原因。有两个共同的陷阱要记住: Java 和 Python 默认都是小根堆,想要大根堆得动手; - 遍历堆不会得到有序结果, - 想按顺序读只能一个个取出来。 + 遍历堆不会得到有序结果,想按顺序读只能一个个取出来。

    } /> @@ -1987,9 +1892,7 @@ PriorityQueue h = new PriorityQueue<>(List.of(5, 1, 3));`, <> 两个陷阱。① 遍历(for (int x : pq) 或{" "} toString())走的是底层数组, - 顺序没有意义;想按升序读只能反复 poll()。 - ② 比较器别写成 x[0] - y[0]: - 两个 int 相减在一大一负时可能溢出,符号就反了 —— + 顺序没有意义;想按升序读只能反复 poll()。② 比较器别写成 x[0] - y[0]:两个 int 相减在一大一负时可能溢出,符号就反了 —— 应当使用 Integer.compare。 ), @@ -2066,10 +1969,8 @@ heapq.heappop(pq) # (3, 'apple')`, <> 易错点:元组比较如果比到某一项是 不可比较的类型(例如两个 freq 相等,接着要比自定义对象), - Python 会抛 TypeError。 - 惯用解法是在中间塞一个自增序号当决胜项,如{" "} - (freq, idx, obj) —— 序号永不重复, - 所以永远比不到对象本身。 + Python 会抛 TypeError。惯用解法是在中间塞一个自增序号当决胜项,如{" "} + (freq, idx, obj) —— 序号永不重复,所以永远比不到对象本身。 ), }, @@ -2137,14 +2038,10 @@ const q = new MinPriorityQueue((x) => x.dist); // dist 最小的先出`, ), zh: ( <> - 两个提醒。① 不要用 arr.sort() 代替堆: - 每次插入后重排是单次 O(n log n),而不是 O(log n), - 数据一大就会超时。② @datastructures-js/priority-queue{" "} + 两个提醒。① 不要用 arr.sort() 代替堆:每次插入后重排是单次 O(n log n),而不是 O(log n),数据一大就会超时。② @datastructures-js/priority-queue{" "} 的 API 在大版本之间变过:旧版本收{" "} {"{ priority: fn }"}、返回{" "} - {"{ element, priority }"} 包装对象, - 新版本直接收函数、直接返回元素本身。 - 既然无法确定评测机装的是哪个版本,自己手写堆更保险, + {"{ element, priority }"} 包装对象,新版本直接收函数、直接返回元素本身。既然无法确定评测机装的是哪个版本,自己手写堆更保险, §06 的精讲也都这样做。 ), @@ -2365,8 +2262,7 @@ const q = new MinPriorityQueue((x) => x.dist); // dist 最小的先出`, ② 反复取最值,取完还要塞回新值 (每一步贪心地用当前最值,再插入更新后的值 —— 任务调度、重构字符串、粉碎石头都是这一类); - ③ 合并 K 路有序序列(K 条链表或 K 行矩阵)。 - 下面三道精讲各挑一个套路。先讲 Top-K 里最出人意料的那一点。 + ③ 合并 K 路有序序列(K 条链表或 K 行矩阵)。下面三道精讲各挑一个套路。先讲 Top-K 里最出人意料的那一点。

    } /> @@ -2406,19 +2302,10 @@ const q = new MinPriorityQueue((x) => x.dist); // dist 最小的先出`, } zh={

    - 第一反应通常是「求第 K 大,当然用大根堆」。其实正好相反: - 标准解法是一个最多装 k 个元素的小根堆。 - 想通这一点,大部分 Top-K 题就变成同一道题了。 - 道理是这样的:你要留住「迄今最大的 k 个」, - 每当有更强的新值进来,就必须淘汰已有 k 个里最弱的那个。 - 这 k 个里最弱的就是它们的最小值, - 而随时 O(1) 读出最小值正是小根堆的本事。 - 于是堆顶成了入围门槛:新值只有比堆顶大才进得来, - 同时把旧堆顶挤出去。扫完 n 个值,堆里就是最大的 k 个, + 第一反应通常是「求第 K 大,当然用大根堆」。其实正好相反:标准解法是一个最多装 k 个元素的小根堆。想通这一点,大部分 Top-K 题就变成同一道题了。道理是这样的:你要留住「迄今最大的 k 个」,每当有更强的新值进来,就必须淘汰已有 k 个里最弱的那个。这 k 个里最弱的就是它们的最小值,而随时 O(1) 读出最小值正是小根堆的本事。于是堆顶成了入围门槛:新值只有比堆顶大才进得来,同时把旧堆顶挤出去。扫完 n 个值,堆里就是最大的 k 个, 堆顶正是第 K 大。镜像情况:求第 K 小就用容量 k 的 大根堆,堆顶是这 k 个候选里最大的。总规律是: - 选那种能把「最该被踢的元素」放在堆顶的堆。 - 代价是 O(n log k) —— 只要 k 远小于 n,就比 O(n log n) 的排序划算。 + 选那种能把「最该被踢的元素」放在堆顶的堆。代价是 O(n log k) —— 只要 k 远小于 n,就比 O(n log n) 的排序划算。

    } /> @@ -2457,10 +2344,8 @@ const q = new MinPriorityQueue((x) => x.dist); // dist 最小的先出`, } zh={

    - 题意:返回数组里第 k 大的元素。重复元素照常计数, - 所以不是第 k 个不同的值。 - 暴力:整个数组排序 O(n log n),取倒数第 k 个。 - 能过,但为了回答关于一个元素的问题,把所有元素的顺序都算了出来。 + 题意:返回数组里第 k 大的元素。重复元素照常计数,所以不是第 k 个不同的值。 + 暴力:整个数组排序 O(n log n),取倒数第 k 个。能过,但为了回答关于一个元素的问题,把所有元素的顺序都算了出来。 正解:套用上面的规律 —— 容量 k 的小根堆,堆顶就是门槛。下面是 k = 2 的过程。

    @@ -2589,15 +2474,8 @@ var findKthLargest = function (nums, k) { } zh={

    - 时间 O(n log k):n 个值,每个至多进出一次容量 k 的堆; - 空间 O(k)。经典追问是「能做到 O(n) 吗?」 - 能,用快速选择(quickselect): - 复用快排的 partition,每轮只递归一边, - 平均 O(n),最坏 O(n²)(随机选基准可以让最坏情况极难出现)。 - 那堆解法为什么还常用?两个原因: - 第一,数据流场景里值源源不断,根本没有完整数组给你 partition; - 第二,数据放不进内存时,容量 k 的堆只要 O(k) 空间。 - 完整的回答要讲清两种解法各自的适用场景。 + 时间 O(n log k):n 个值,每个至多进出一次容量 k 的堆;空间 O(k)。经典追问是「能做到 O(n) 吗?」 + 能,用快速选择(quickselect):复用快排的 partition,每轮只递归一边,平均 O(n),最坏 O(n²)(随机选基准可以让最坏情况极难出现)。那堆解法为什么还常用?两个原因:第一,数据流场景里值源源不断,根本没有完整数组给你 partition;第二,数据放不进内存时,容量 k 的堆只要 O(k) 空间。完整的回答要讲清两种解法各自的适用场景。

    } /> @@ -2638,12 +2516,9 @@ var findKthLargest = function (nums, k) {

    题意:返回数组里出现频率前 k 高的元素。 暴力:统计频率后按频率排序,取前 k 个,O(n log n)。 - 正解:这是你的第一道组合两种结构的题: - 一种结构不够,就串两种 —— - 先用哈希表 O(n) 数出每个值的频次(第 6 章的内容), - 再把这些频次喂给容量 k 的小根堆做 Top-K - (本章的内容)。注意堆是按频次排序的, - 所以门槛是仍在堆里的最低频次。 + 正解:这是你的第一道组合两种结构的题:一种结构不够,就串两种 —— + 先用哈希表 O(n) 数出每个值的频次(第 6 章的内容),再把这些频次喂给容量 k 的小根堆做 Top-K + (本章的内容)。注意堆是按频次排序的,所以门槛是仍在堆里的最低频次。

    } /> @@ -2802,8 +2677,7 @@ class Solution: [...cnt].sort((a,b)=>b[1]-a[1]).slice(0,k).map(p=>p[0]) {" "} - 也能通过,但那是 O(n log n),不是堆的 O(n log k)。 - 桶排序能做到 O(n),是回答追问的好方案。 + 也能通过,但那是 O(n log n),不是堆的 O(n log k)。桶排序能做到 O(n),是回答追问的好方案。 ), }, @@ -2829,12 +2703,8 @@ class Solution: } zh={

    - 计数 O(n),维护堆 O(n log k),合计 O(n log k), - 空间 O(n)(哈希表)。追问是「能做到 O(n) 吗?」 - 能,用桶排序:任何频次都不会超过 n, - 所以开 n + 1 个桶,bucket[f] 装所有出现 f 次的值, - 再从频次最高的桶往下收集,凑够 k 个即可 —— 不用排序也不用堆。 - 「哈希 + 堆」是最好记的通用解,「哈希 + 桶」是它的 O(n) 特化版。 + 计数 O(n),维护堆 O(n log k),合计 O(n log k),空间 O(n)(哈希表)。追问是「能做到 O(n) 吗?」 + 能,用桶排序:任何频次都不会超过 n,所以开 n + 1 个桶,bucket[f] 装所有出现 f 次的值,再从频次最高的桶往下收集,凑够 k 个即可 —— 不用排序也不用堆。「哈希 + 堆」是最好记的通用解,「哈希 + 桶」是它的 O(n) 特化版。

    } /> @@ -2875,13 +2745,8 @@ class Solution:

    题意:把 k 条各自升序的链表合并成一条升序链表。 暴力:把所有结点值倒进数组、排序、再重建链表, - O(N log N)(N 是结点总数)。能过, - 但它浪费了「每条链已经有序」这个条件。 - 正解:合并有序序列时,答案的下一个值一定是 - 当前各条链头结点里最小的那个。 - 谁能报出一个不断变化的集合里的最小值?小根堆。 - 所以堆里只装 k 个头结点: - 取走最小的,再把它的后继补进来。 + O(N log N)(N 是结点总数)。能过,但它浪费了「每条链已经有序」这个条件。 + 正解:合并有序序列时,答案的下一个值一定是当前各条链头结点里最小的那个。谁能报出一个不断变化的集合里的最小值?小根堆。所以堆里只装 k 个头结点:取走最小的,再把它的后继补进来。

    } /> @@ -3003,11 +2868,7 @@ class Solution: zh: ( <> 陷阱:两个元组的 val 相等时, - Python 会接着比下一项。如果那一项就是 node, - 而 ListNode 没有定义 <, - 就会抛 TypeError。 - 在中间放一个唯一且递增的序号 i, - 比较就永远到不了结点本身 —— 这是用 heapq{" "} + Python 会接着比下一项。如果那一项就是 node,而 ListNode 没有定义 <,就会抛 TypeError。在中间放一个唯一且递增的序号 i,比较就永远到不了结点本身 —— 这是用 heapq{" "} 存对象的标准做法。 ), @@ -3078,17 +2939,7 @@ class Solution: } zh={

    - 设结点总数为 N。每个结点恰好进堆、出堆各一次, - 每次堆操作 O(log k) —— 堆里最多只有 k 个结点。 - 所以时间是 O(N log k),额外空间 O(k)。 - 注意这里和链表章的呼应:堆里存的是结点, - 靠 next 就能拿到每条链的剩余部分,不必复制任何值。 - 经典追问是「不用堆行不行?」行,用分治归并: - 每轮把链表两两配对,用「合并两个有序链表」(LC 21)合并每一对, - 链表数随之减半。k 条链 log k 轮合完, - 每轮总共扫 O(N) 个结点,同样是 O(N log k), - 而且不需要堆的 O(k) 空间。(如果把各条链依次并入同一个结果, - 则要 O(Nk),链表章提到的正是这种做法。) + 设结点总数为 N。每个结点恰好进堆、出堆各一次,每次堆操作 O(log k) —— 堆里最多只有 k 个结点。所以时间是 O(N log k),额外空间 O(k)。注意这里和链表章的呼应:堆里存的是结点,靠 next 就能拿到每条链的剩余部分,不必复制任何值。经典追问是「不用堆行不行?」行,用分治归并:每轮把链表两两配对,用「合并两个有序链表」(LC 21)合并每一对,链表数随之减半。k 条链 log k 轮合完,每轮总共扫 O(N) 个结点,同样是 O(N log k),而且不需要堆的 O(k) 空间。(如果把各条链依次并入同一个结果,则要 O(Nk),链表章提到的正是这种做法。)

    } /> @@ -3145,10 +2996,7 @@ class Solution: ), zh: ( <> - 堆只承诺一件事:堆顶是最值。 - 兄弟乱序、底层数组乱序都完全合法。 - 承诺越少,维护越便宜:单次更新 O(log n),而不是全排序的 O(n log n)。 - 这笔取舍就是它的全部设计。 + 堆只承诺一件事:堆顶是最值。兄弟乱序、底层数组乱序都完全合法。承诺越少,维护越便宜:单次更新 O(log n),而不是全排序的 O(n log n)。这笔取舍就是它的全部设计。 ), }, @@ -3165,8 +3013,7 @@ class Solution: zh: ( <> 两条规矩:完全二叉树(又矮又宽,高度 ⌊log₂n⌋,没有空洞) - 和小根堆的 父 ≤ 子。正因为没有空洞, - 整棵树才能塞进数组,每条连线都是算出来的: + 和小根堆的 父 ≤ 子。正因为没有空洞,整棵树才能塞进数组,每条连线都是算出来的: parent = (i−1)/2、children = 2i+1, 2i+2, 不需要指针。 @@ -3205,8 +3052,7 @@ class Solution: <> Top-K 那条反直觉的规律:求第 K 大用容量 k 的 小根堆(堆顶是门槛,比门槛大才进);求第 K 小用 - 大根堆。选那种能把「最该被踢的元素」放在堆顶的堆。 - 代价是 O(n log k)。 + 大根堆。选那种能把「最该被踢的元素」放在堆顶的堆。代价是 O(n log k)。 ), }, @@ -3227,12 +3073,8 @@ class Solution: zh: ( <> 优先队列是接口,二叉堆是常见实现。工程上: - Java 的 PriorityQueue 默认小根堆, - 传 Comparator(如 reverseOrder())可以反向, - 而且遍历无序;Python 的 heapq 到 3.13 为止只有小根堆, - 大根堆靠存负数(3.14 新增了 heappush_max{" "} - 等函数);JavaScript 没有内置实现, - 只能手写或用第三方包。 + Java 的 PriorityQueue 默认小根堆,传 Comparator(如 reverseOrder())可以反向,而且遍历无序;Python 的 heapq 到 3.13 为止只有小根堆,大根堆靠存负数(3.14 新增了 heappush_max{" "} + 等函数);JavaScript 没有内置实现,只能手写或用第三方包。 ), }, diff --git a/app/heap/viz.tsx b/app/heap/viz.tsx index d4b906c..2d78215 100644 --- a/app/heap/viz.tsx +++ b/app/heap/viz.tsx @@ -177,8 +177,7 @@ export function HeapLab() { } zh={ <> - 落位。{v} 上浮了 {swaps} 次,不超过树高({h})。 - push 是 O(log n) —— 它最长只走一条「叶到根」的路。 + 落位。{v} 上浮了 {swaps} 次,不超过树高({h})。push 是 O(log n) —— 它最长只走一条「叶到根」的路。 } />, @@ -213,8 +212,7 @@ export function HeapLab() { } zh={ <> - pop():堆顶 {top} 是堆里最小的值(小根堆唯一的承诺), - 要出队的就是它。 + pop():堆顶 {top} 是堆里最小的值(小根堆唯一的承诺),要出队的就是它。 } />, @@ -249,9 +247,7 @@ export function HeapLab() { } zh={ <> - 第一步:把最后一个元素 {moved} 搬到堆顶。 - 删掉末尾不会破坏完全二叉树的形状,但顶部的堆序多半坏了, - 所以这个值要「下沉」回它该待的位置。 + 第一步:把最后一个元素 {moved} 搬到堆顶。删掉末尾不会破坏完全二叉树的形状,但顶部的堆序多半坏了,所以这个值要「下沉」回它该待的位置。 } />, @@ -300,8 +296,7 @@ export function HeapLab() { } zh={ <> - 第二步 下沉:a[{ci}]={cur} 和较小的孩子 a[{cm}]={child} 交换。 - 换较大的那个,另一边马上会违反「父 ≤ 子」。 + 第二步 下沉:a[{ci}]={cur} 和较小的孩子 a[{cm}]={child} 交换。换较大的那个,另一边马上会违反「父 ≤ 子」。 } />, @@ -327,8 +322,7 @@ export function HeapLab() { } zh={ <> - pop() 完成:弹出 {top},补位元素下沉 {swaps} 次, - 新堆顶是 {newTop}。pop 同样是 O(log n) —— 一条「根到叶」的路。 + pop() 完成:弹出 {top},补位元素下沉 {swaps} 次,新堆顶是 {newTop}。pop 同样是 O(log n) —— 一条「根到叶」的路。 } />, @@ -417,10 +411,7 @@ export function HeapLab() { } zh={ <> - 建堆完成。7 个元素只交换了 {swaps} 次。 - 大约一半的结点是叶子,移动 0 层;约 1/4 最多移 1 层;约 1/8 最多移 2 层…… - 能沉得深的结点恰恰最稀少,所以总步数不超过 n,建堆是 O(n), - 比逐个 push 的 O(n log n) 便宜。 + 建堆完成。7 个元素只交换了 {swaps} 次。大约一半的结点是叶子,移动 0 层;约 1/4 最多移 1 层;约 1/8 最多移 2 层……能沉得深的结点恰恰最稀少,所以总步数不超过 n,建堆是 O(n),比逐个 push 的 O(n log n) 便宜。 } />, @@ -644,10 +635,7 @@ export function HeapMapFig() { zh={ <> 看高亮的这一家三口:结点 [1] 的值是 20,它的孩子在 2 × 1 + 1 ={" "} - [3] 和 2 × 1 + 2 = [4];反过来,[4] 的父结点在 - (4 − 1) / 2 = [1](整数除法)。 - 完全二叉树按层编号没有一个空洞,所以整棵树塞进数组不浪费任何位置, - 而且不需要存父指针或孩子指针 —— 每一条连线都是用下标算出来的。 + [3] 和 2 × 1 + 2 = [4];反过来,[4] 的父结点在(4 − 1) / 2 = [1](整数除法)。完全二叉树按层编号没有一个空洞,所以整棵树塞进数组不浪费任何位置,而且不需要存父指针或孩子指针 —— 每一条连线都是用下标算出来的。 } /> diff --git a/app/home-viz.tsx b/app/home-viz.tsx index dd10396..b3d5e23 100644 --- a/app/home-viz.tsx +++ b/app/home-viz.tsx @@ -232,8 +232,7 @@ const MSG_SHARE = ( } zh={ <> - 执行 b = a:复制的不是盒子,而是纸条上的地址 —— 现在两张标签 - 指向同一个盒子。b 原来的盒子没人指了,等着被回收。 + 执行 b = a:复制的不是盒子,而是纸条上的地址 —— 现在两张标签指向同一个盒子。b 原来的盒子没人指了,等着被回收。 } /> diff --git a/app/linked-list/page.tsx b/app/linked-list/page.tsx index 96dbe22..d9d9278 100644 --- a/app/linked-list/page.tsx +++ b/app/linked-list/page.tsx @@ -79,8 +79,7 @@ export default function LinkedListChapter() { ), zh: ( <> - 每个节点只存一个值和下一个节点的地址。 - 链表交出了连续内存与下标访问,换回来的是: + 每个节点只存一个值和下一个节点的地址。链表交出了连续内存与下标访问,换回来的是: 只要位置前面那个节点已经在手上,插入只需改两根引用,删除只需改一根,不必搬动任何元素 @@ -144,24 +143,18 @@ export default function LinkedListChapter() { <>

    先回放第 1 章最贵的一幕:往数组中间插一个元素,插入点右边的 - 所有元素集体右移一格;删一个,右边全体左移补位。 - 数据量十万条、操作又频繁落在中间时,这份 O(n) + 所有元素集体右移一格;删一个,右边全体左移补位。数据量十万条、操作又频繁落在中间时,这份 O(n) 的搬家成本就是实打实的账单。根源只有一个:数组把 逻辑上的相邻绑定在物理上的相邻 上 —— 两个邻居在内存里就是邻居,中间挤不进人。

    - 链表(linked list)把这道焊缝拆了: - 元素不必住在邻居隔壁,只要每人身上带一张纸条,写着「下一个人住在哪」。 - 你拿到第一个地址(head),照纸条找到第二个,再找第三个…… - 纸条上写着「没有了」(null),这条链就到头了。 + 链表(linked list)把这道焊缝拆了:元素不必住在邻居隔壁,只要每人身上带一张纸条,写着「下一个人住在哪」。你拿到第一个地址(head),照纸条找到第二个,再找第三个……纸条上写着「没有了」(null),这条链就到头了。

    在这样的世界里,「在 A 和 B 之间插入 C」变得极便宜: C 的纸条写上「下一个是 B」,再把 A 的纸条改成「下一个是 C」—— - 只改两张纸条,其他元素一个都不动。 - 代价是门牌号没了:想找第 100 个元素,只能从头一张张纸条追过去。 - 由此有三条家规: + 只改两张纸条,其他元素一个都不动。代价是门牌号没了:想找第 100 个元素,只能从头一张张纸条追过去。由此有三条家规:

    } @@ -185,9 +178,7 @@ export default function LinkedListChapter() { } zh={

    - 节点(node)在内存里想住哪住哪,彼此可以离得很远。 - 好处:不需要一大块连续内存,也永远不会为了扩容整体搬家; - 代价:CPU 猜不到下一个节点在哪,没法提前把它读进缓存。 + 节点(node)在内存里想住哪住哪,彼此可以离得很远。好处:不需要一大块连续内存,也永远不会为了扩容整体搬家;代价:CPU 猜不到下一个节点在哪,没法提前把它读进缓存。

    } /> @@ -208,8 +199,7 @@ export default function LinkedListChapter() { } zh={

    - 每个节点 = 一个值 + 一根 next 引用。 - 链表的顺序只存在于这些引用里,和地址毫无关系 —— + 每个节点 = 一个值 + 一根 next 引用。链表的顺序只存在于这些引用里,和地址毫无关系 —— 所谓「链」,指的就是这一串手拉手的引用。

    } @@ -231,8 +221,7 @@ export default function LinkedListChapter() { } zh={

    - 这里没有「地址 = 首地址 + i × 元素大小」这条公式。 - 想到第 i 个,只能从 head 出发跟 i 次引用 —— + 这里没有「地址 = 首地址 + i × 元素大小」这条公式。想到第 i 个,只能从 head 出发跟 i 次引用 —— 访问是 O(n),这就是它为便宜的插删付出的对价。

    } @@ -262,8 +251,7 @@ export default function LinkedListChapter() { } zh={

    - 内存分配器把空闲块串成一条空闲链表(free list), - 归还一块内存只是改两根引用,不必搬动任何数据;FAT + 内存分配器把空闲块串成一条空闲链表(free list),归还一块内存只是改两根引用,不必搬动任何数据;FAT 文件系统用一张分配表记录每个块的下一个块号,文件就是表里的一条链 —— 所以一个文件可以散落在整块磁盘上。而面试里最出名的组合 —— LRU 缓存(LC 146)= 哈希表 + 双向链表 —— @@ -306,10 +294,7 @@ export default function LinkedListChapter() {

    序章 §03 说过: 引用(reference)本质上就是一个内存地址 —— - 一张写着「去 2096 号找它」的纸条。链表的节点无非是把「值」 - 和「纸条」打包放在一起。下图是同一批值 [7, 2, 9] 的两种住法, - 注意链表三个节点的物理顺序(2096 → 3120 → 1432)和逻辑顺序 - (7 → 2 → 9)毫无关系: + 一张写着「去 2096 号找它」的纸条。链表的节点无非是把「值」和「纸条」打包放在一起。下图是同一批值 [7, 2, 9] 的两种住法,注意链表三个节点的物理顺序(2096 → 3120 → 1432)和逻辑顺序(7 → 2 → 9)毫无关系:

    } /> @@ -337,10 +322,8 @@ export default function LinkedListChapter() { } zh={

    - 数组的 O(1) 来自那条地址公式,而公式成立靠「连续 + 同型」。 - 链表节点散落各处,第 i 个节点的地址 - 只记录在第 i−1 个节点肚子里 —— 想知道它在哪, - 必须先找到前一个。信息的存放方式决定了访问方式:O(n) + 数组的 O(1) 来自那条地址公式,而公式成立靠「连续 + 同型」。链表节点散落各处,第 i 个节点的地址 + 只记录在第 i−1 个节点肚子里 —— 想知道它在哪,必须先找到前一个。信息的存放方式决定了访问方式:O(n) 不是实现不够好,是结构使然。

    } @@ -364,10 +347,7 @@ export default function LinkedListChapter() { } zh={

    - {"{ val: 7, next: 1432 }"} —— 一格值 + 一格地址。 - 在 Java / Python / JS 里,next 就是一个指向下一个节点对象的引用; - 没有下一个时记作 null / None / null, - 它是每条链的终点,也是空指针异常最常见的发生位置。 + {"{ val: 7, next: 1432 }"} —— 一格值 + 一格地址。在 Java / Python / JS 里,next 就是一个指向下一个节点对象的引用;没有下一个时记作 null / None / null,它是每条链的终点,也是空指针异常最常见的发生位置。

    } /> @@ -405,12 +385,8 @@ export default function LinkedListChapter() { zh={

    第 1 章讲过 CPU 缓存行:读 arr[0] 时, - arr[1..15] 因为紧挨着它,顺便一起进了缓存。 - 链表享受不到这个红利 —— 下一个节点在哪,要读完当前节点才知道, - CPU 无法提前加载,几乎每跳一步都可能缓存未命中, - 跑一趟主存。两者的遍历都是 O(n),差的不是复杂度, - 而是常数因子 —— 只是这个常数不小:真机上顺序遍历数组 - 通常快好几倍。工程上的默认选择: + arr[1..15] 因为紧挨着它,顺便一起进了缓存。链表享受不到这个红利 —— 下一个节点在哪,要读完当前节点才知道, + CPU 无法提前加载,几乎每跳一步都可能缓存未命中,跑一趟主存。两者的遍历都是 O(n),差的不是复杂度,而是常数因子 —— 只是这个常数不小:真机上顺序遍历数组通常快好几倍。工程上的默认选择: 先用数组家族,确实需要「拿着节点做 O(1) 插删」时才请链表出场 @@ -594,19 +570,14 @@ export default function LinkedListChapter() { zh={ <>

    - 表里最重要的是第三行的前提。 - 「链表插删 O(1)」这句话被掐头去尾传得太广,完整版是: - 改指针 O(1),找到该改哪根指针 O(n)。 - 所以链表真正的高光场景,是「前驱或节点引用本来就在手上」—— + 表里最重要的是第三行的前提。「链表插删 O(1)」这句话被掐头去尾传得太广,完整版是: + 改指针 O(1),找到该改哪根指针 O(n)。所以链表真正的高光场景,是「前驱或节点引用本来就在手上」—— 比如遍历途中顺手删除,比如 LRU 缓存里哈希表直接把节点递给你。

    - 插入本身只有两步,但顺序决定链表的死活。 - 口诀「先接后断」:新节点先牵住后继( + 插入本身只有两步,但顺序决定链表的死活。口诀「先接后断」:新节点先牵住后继( newNode.next = cur),前驱再改口( - prev.next = newNode)。顺序反了会怎样? - 下面实验室里有一个「反面教材」按钮,亲手丢一次后半条链, - 比背十遍口诀管用: + prev.next = newNode)。顺序反了会怎样?下面实验室里有一个「反面教材」按钮,亲手丢一次后半条链,比背十遍口诀管用:

    } @@ -639,14 +610,10 @@ export default function LinkedListChapter() { } zh={

    - 删除节点 X 通常需要它的前驱,好让前驱的 next 跳过 X。 - 如果只给你 X 本人呢?有个技巧(LC 237):把{" "} + 删除节点 X 通常需要它的前驱,好让前驱的 next 跳过 X。如果只给你 X 本人呢?有个技巧(LC 237):把{" "} X.next 的值抄进 X,然后删掉 X.next{" "} —— 链表的值序列因此正确,代价 O(1)。但它带着两条限制: - X 是最后一个节点时不成立,因为没有下一个值可抄, - 也没法回头找到 X 的前驱;而且真正被留下的节点对象已经换了一个, - 别处若还持有 X.next 的引用, - 那个引用现在指向一个已经不在链上的节点。 + X 是最后一个节点时不成立,因为没有下一个值可抄,也没法回头找到 X 的前驱;而且真正被留下的节点对象已经换了一个,别处若还持有 X.next 的引用,那个引用现在指向一个已经不在链上的节点。

    } /> @@ -679,14 +646,9 @@ export default function LinkedListChapter() { zh={

    ① 先断后接:后半条链失去最后一个引用(上面刚演示过)。②{" "} - 对 null 取字段:对空引用取 .next。 - 循环条件要先判空,而且顺序不能反( + 对 null 取字段:对空引用取 .next。循环条件要先判空,而且顺序不能反( cur != null && cur.next != null —— - && 先算左边,左边成立才算右边, - 两个条件对调就又崩了)。③ 漏掉头节点的特判: - 删头 / 插头时根本没有前驱可改 —— §04 的 dummy 哨兵专治这个。 - 写链表题之前先画图,把指针改动顺序在纸上排好再下手, - 是所有老手的共同习惯。 + && 先算左边,左边成立才算右边,两个条件对调就又崩了)。③ 漏掉头节点的特判:删头 / 插头时根本没有前驱可改 —— §04 的 dummy 哨兵专治这个。写链表题之前先画图,把指针改动顺序在纸上排好再下手,是所有老手的共同习惯。

    } /> @@ -722,8 +684,7 @@ export default function LinkedListChapter() {

    单链表(singly linked list)完整实现。 维护 head、tail、size 三个字段:tail 让尾插降到 O(1),size - 让长度查询降到 O(1) —— 两个「花一点空间买时间」的小决策。 - 所有方法的套路都是同一句话: + 让长度查询降到 O(1) —— 两个「花一点空间买时间」的小决策。所有方法的套路都是同一句话: 找到前驱,改指针:

    } @@ -917,9 +878,7 @@ class MyLinkedList { ), zh: ( <> - 易错点:每个会动 head / tail 的方法都要照顾空链表与 - 单节点两种边界 —— 链表 bug 大多出在这里。 - 测试顺序:空表 → 一个元素 → 两个元素。 + 易错点:每个会动 head / tail 的方法都要照顾空链表与单节点两种边界 —— 链表 bug 大多出在这里。测试顺序:空表 → 一个元素 → 两个元素。 ), }, @@ -1322,8 +1281,7 @@ class MyLinkedList { ), zh: ( <> - 易错点:if (!cur) 判空很顺手, - 但 val 为 0 时 if (!cur.val) 也成立 —— + 易错点:if (!cur) 判空很顺手,但 val 为 0 时 if (!cur.val) 也成立 —— 「节点是否存在」和「值是多少」要分开写。 ), @@ -1350,11 +1308,9 @@ class MyLinkedList { zh={

    双向链表(doubly linked list):把回头路也修上。 - 每个节点多带一根 prev 引用,于是可以从任一节点向两边走。 - 两大收益:① 删除不再需要「找前驱」 —— + 每个节点多带一根 prev 引用,于是可以从任一节点向两边走。两大收益:① 删除不再需要「找前驱」 —— 节点自己就知道前驱是谁,拿到节点即可 O(1) 删除, - LRU 缓存正是靠它;② 支持从尾向头遍历。代价:每个节点多一根引用, - 插入要改四根指针(删除改两根),更容易写错: + LRU 缓存正是靠它;② 支持从尾向头遍历。代价:每个节点多一根引用,插入要改四根指针(删除改两根),更容易写错:

    } /> @@ -1536,12 +1492,9 @@ function remove(node) {

    dummy 哨兵:一个节点换掉一整类 bug。 你可能注意到了,上面 insertAt / removeAt 里 i == 0{" "} - 都要单独写一支。原因很具体:没有任何节点指向头节点, - 「改前驱的 next」这套通用逻辑在它身上无处落笔, - 只能直接给 head 变量赋值。dummy(哑结点 / 哨兵结点) + 都要单独写一支。原因很具体:没有任何节点指向头节点,「改前驱的 next」这套通用逻辑在它身上无处落笔,只能直接给 head 变量赋值。dummy(哑结点 / 哨兵结点) 的办法很直接:造一个假节点站在 head 前面,让 - 每个真节点都有前驱。对比同一道题 - (LC 203:删除所有等于 val 的节点)的两个版本: + 每个真节点都有前驱。对比同一道题(LC 203:删除所有等于 val 的节点)的两个版本:

    } /> @@ -1724,12 +1677,7 @@ var removeElements = function (head, val) { } zh={

    - 一句话判据:答案的头节点可能被改动(删除、在它前面插入、 - 重新接线)时,就用 dummy。删除类(LC 203、19)、 - 构造新链类(LC 21、2)、区间重排类(LC 92、24、25)几乎全中。 - 成本是一个临时节点,换来的是少一个分支、 - 少一类「恰好动到头节点时才触发」的隐藏 bug。 - 记得最后返回 dummy.next 而不是 head。 + 一句话判据:答案的头节点可能被改动(删除、在它前面插入、重新接线)时,就用 dummy。删除类(LC 203、19)、构造新链类(LC 21、2)、区间重排类(LC 92、24、25)几乎全中。成本是一个临时节点,换来的是少一个分支、少一类「恰好动到头节点时才触发」的隐藏 bug。记得最后返回 dummy.next 而不是 head。

    } /> @@ -1768,10 +1716,7 @@ var removeElements = function (head, val) { zh={

    一个可能让你意外的事实: - 三种语言都没有可以直接用于做题的内置单链表。 - 原因正是 §02 那条工程结论 —— 通用场景下动态数组几乎总是更快, - 而单链表值得出场的地方,往往也特殊到值得手写。所以做题时, - 链表就是一个约定俗成的 ListNode, + 三种语言都没有可以直接用于做题的内置单链表。原因正是 §02 那条工程结论 —— 通用场景下动态数组几乎总是更快,而单链表值得出场的地方,往往也特殊到值得手写。所以做题时,链表就是一个约定俗成的 ListNode, LeetCode 帮你定义好,三语言长这样:

    } @@ -1855,8 +1800,7 @@ class ListNode: zh: ( <> 参数名 next 会在这个方法内部遮蔽内置函数{" "} - next()。LeetCode 模板如此, - 自己的工程代码里建议改名。 + next()。LeetCode 模板如此,自己的工程代码里建议改名。 ), }, @@ -2081,12 +2025,8 @@ function ListNode(val, next) { for (int i = 0; i < list.size(); i++) list.get(i) {" "} - 这段代码对 ArrayList 是 O(n),对 LinkedList 是 O(n²): - 每次 get(i) 都要从头(或者从更近的尾)重新走 i 步。 - 十万条数据,前者毫秒级,后者要好几秒。遍历 LinkedList - 必须用 for-each 或迭代器 —— 它们沿着 next 走一遍,整体 O(n)。 - 更实际的建议来自这个类的作者 Joshua Bloch:他说自己也几乎不用它。 - 需要队列用 ArrayDeque,需要列表用 ArrayList,通常都更快。 + 这段代码对 ArrayList 是 O(n),对 LinkedList 是 O(n²):每次 get(i) 都要从头(或者从更近的尾)重新走 i 步。十万条数据,前者毫秒级,后者要好几秒。遍历 LinkedList + 必须用 for-each 或迭代器 —— 它们沿着 next 走一遍,整体 O(n)。更实际的建议来自这个类的作者 Joshua Bloch:他说自己也几乎不用它。需要队列用 ArrayDeque,需要列表用 ArrayList,通常都更快。

    } /> @@ -2114,12 +2054,7 @@ function ListNode(val, next) { } zh={

    - collections.deque 不是一个节点一个元素的教科书链表, - 而是每个节点装一块 64 格的小数组,块与块之间双向链接。 - 这是链表和数组的折中:两端仍然 O(1), - 同时 64 个元素共享一次内存分配、在内存里紧挨着, - 大部分步伐都能吃到 CPU 缓存 —— §02 说的那个缓存问题被削掉一大半。 - 真实工程里的链式结构,大多长这种混血样子。 + collections.deque 不是一个节点一个元素的教科书链表,而是每个节点装一块 64 格的小数组,块与块之间双向链接。这是链表和数组的折中:两端仍然 O(1),同时 64 个元素共享一次内存分配、在内存里紧挨着,大部分步伐都能吃到 CPU 缓存 —— §02 说的那个缓存问题被削掉一大半。真实工程里的链式结构,大多长这种混血样子。

    } /> @@ -2161,9 +2096,7 @@ function ListNode(val, next) { zh={

    数组题多半在拼「想到聪明的遍历方式」,链表题则在拼 - 指针改动的顺序一根不错。 - 好消息是套路极其集中 —— 把下面三招练熟, - 本章题单的 11 道题你都能找到入口: + 指针改动的顺序一根不错。好消息是套路极其集中 —— 把下面三招练熟,本章题单的 11 道题你都能找到入口:

    } /> @@ -2187,9 +2120,7 @@ function ListNode(val, next) { } zh={

    - prev / cur / nxt 三人小队,把箭头逐个调头。 - 整链反转(206)、区间反转(92)、K 组反转(25) - 都是同一个循环的变体 —— 这是链表最核心的基本操作。 + prev / cur / nxt 三人小队,把箭头逐个调头。整链反转(206)、区间反转(92)、K 组反转(25)都是同一个循环的变体 —— 这是链表最核心的基本操作。

    } /> @@ -2215,11 +2146,8 @@ function ListNode(val, next) { } zh={

    - 两个指针速度不同,间距因此可控。快 2 慢 1:找中点(876)、 - 判环(141、142);让 fast 先走 n 步,间距就恒为 n: - 倒数第 n 个(19)。循环条件写成{" "} - fast != null && fast.next != null 时, - 偶数长度的链表,slow 停在两个中点里的第二个。 + 两个指针速度不同,间距因此可控。快 2 慢 1:找中点(876)、判环(141、142);让 fast 先走 n 步,间距就恒为 n:倒数第 n 个(19)。循环条件写成{" "} + fast != null && fast.next != null 时,偶数长度的链表,slow 停在两个中点里的第二个。

    } /> @@ -2242,9 +2170,7 @@ function ListNode(val, next) { } zh={

    - 头节点可能变动?dummy 站到最前面,人人有前驱,特判归零。 - 删除(203、19)、合并构造(21、2)、 - 重排(24、92、25)的标配起手式。 + 头节点可能变动?dummy 站到最前面,人人有前驱,特判归零。删除(203、19)、合并构造(21、2)、重排(24、92、25)的标配起手式。

    } /> @@ -2285,12 +2211,8 @@ function ListNode(val, next) { zh={

    题意:反转单链表,返回新的头节点。暴力: - 把值抄进数组、反转数组、再抄回去 —— O(n) 额外空间, - 而且节点携带复杂对象时「抄值」根本不可行。正解: - 不动任何值,把每根 next 引用原地调头。 - 难点在于:覆盖 cur.next 的瞬间, - 通往后面的路就断了 —— 所以每一轮必须先备份。 - prev / cur / nxt 三人小队,每轮三步: + 把值抄进数组、反转数组、再抄回去 —— O(n) 额外空间,而且节点携带复杂对象时「抄值」根本不可行。正解: + 不动任何值,把每根 next 引用原地调头。难点在于:覆盖 cur.next 的瞬间,通往后面的路就断了 —— 所以每一轮必须先备份。prev / cur / nxt 三人小队,每轮三步: 备份 → 调头 → 前移:

    } @@ -2410,13 +2332,9 @@ function ListNode(val, next) { 时间 O(n)(每个节点处理一次),额外空间 O(1) (三个指针变量)。必考追问一: 为什么返回 prev 而不是 cur? —— - 循环结束的条件是 cur 为 null,此刻 prev 正停在原链的最后一个节点上, - 那就是新链的头。追问二:递归怎么写? ——{" "} + 循环结束的条件是 cur 为 null,此刻 prev 正停在原链的最后一个节点上,那就是新链的头。追问二:递归怎么写? ——{" "} reverseList(head.next) 先把后面整段反转,再用{" "} - head.next.next = head 把自己接到末尾, - 最后 head.next = null 收口。写法优雅, - 但调用栈每个节点占一帧,空间是 O(n) 而不是 O(1), - 链很长时还可能栈溢出 —— 迭代版是更稳妥的答案。 + head.next.next = head 把自己接到末尾,最后 head.next = null 收口。写法优雅,但调用栈每个节点占一帧,空间是 O(n) 而不是 O(1),链很长时还可能栈溢出 —— 迭代版是更稳妥的答案。

    } /> @@ -2457,12 +2375,9 @@ function ListNode(val, next) { zh={

    题意:判断链表里有没有环 —— - 即是否存在某个节点的 next 指回了前面的节点。 - 有环的链表遍历永远不会结束,所以它是「链表操作卡死」的头号嫌犯。 + 即是否存在某个节点的 next 指回了前面的节点。有环的链表遍历永远不会结束,所以它是「链表操作卡死」的头号嫌犯。 暴力:用哈希集合记录见过的节点,重逢即有环 —— O(n) - 时间,但要 O(n) 空间。正解:Floyd 判圈,又名龟兔赛跑: - 两个指针同时出发,slow 每步 1 格,fast 每步 2 格。 - 没有环,fast 先撞上 null;有环,fast 会在环里追上 slow: + 时间,但要 O(n) 空间。正解:Floyd 判圈,又名龟兔赛跑:两个指针同时出发,slow 每步 1 格,fast 每步 2 格。没有环,fast 先撞上 null;有环,fast 会在环里追上 slow:

    } /> @@ -2578,16 +2493,7 @@ function ListNode(val, next) { } zh={

    - 沿着环,量「从 fast 往前走到 slow」的距离。两者都进环之后, - 这个距离是一个不会变成负数的整数;而每走一步,fast 前进 2、 - slow 前进 1,距离恰好减 1。 - 一个每步减 1 的非负整数必然减到 0, - 而 0 就意味着两个指针停在同一个节点上 —— 不存在「擦肩而过」。 - 这也回答了「为什么不是快 3 倍」:相对速度变成 2 时, - 距离每步减 2,可能直接跨过 0 而永远不等于 0。 - 两个指针都从头出发时最终仍会相遇, - 但那需要用同余去证明,而不是这一句话。 - 相对速度为 1 的版本证明最干净、上界也最清楚: + 沿着环,量「从 fast 往前走到 slow」的距离。两者都进环之后,这个距离是一个不会变成负数的整数;而每走一步,fast 前进 2、slow 前进 1,距离恰好减 1。一个每步减 1 的非负整数必然减到 0,而 0 就意味着两个指针停在同一个节点上 —— 不存在「擦肩而过」。这也回答了「为什么不是快 3 倍」:相对速度变成 2 时,距离每步减 2,可能直接跨过 0 而永远不等于 0。两个指针都从头出发时最终仍会相遇,但那需要用同余去证明,而不是这一句话。相对速度为 1 的版本证明最干净、上界也最清楚: slow 进环后不到一圈就会相遇。

    } @@ -2620,11 +2526,7 @@ function ListNode(val, next) {

    时间 O(n),额外空间 O(1) —— 比哈希表解法省掉 O(n) 空间。必考追问: - 环的入口怎么找?(LC 142)相遇后把一个指针放回 head, - 两个指针改为每步一格同速前进,再次相遇处就是入口。 - 背后是等式「头到入口的距离 = 相遇点绕回入口的距离 + 整数圈」, - 由「fast 路程 = 2 × slow 路程」推出。 - 先把 141 的相遇原理讲顺,142 只是一步代数。 + 环的入口怎么找?(LC 142)相遇后把一个指针放回 head,两个指针改为每步一格同速前进,再次相遇处就是入口。背后是等式「头到入口的距离 = 相遇点绕回入口的距离 + 整数圈」,由「fast 路程 = 2 × slow 路程」推出。先把 141 的相遇原理讲顺,142 只是一步代数。

    } /> @@ -2669,8 +2571,7 @@ function ListNode(val, next) {

    题意:两条升序链表,合并成一条升序链表 —— 复用原有节点重新接线,而不是新建值。思路: - 和「合并两摞已排序的考卷」一样:比较两摞最上面那张, - 取小的放进结果堆。难点不在比较, + 和「合并两摞已排序的考卷」一样:比较两摞最上面那张,取小的放进结果堆。难点不在比较, 而在结果链的第一个节点是谁 —— 它可能来自 l1,也可能来自 l2。不想为此写一堆 if? 用 dummy 哨兵起手,tail 从 dummy 出发一路往后挂: @@ -2820,14 +2721,9 @@ function ListNode(val, next) { zh={

    时间 O(n + m)(每个节点被挂一次),额外空间{" "} - O(1)(只多了 dummy 和 tail 两个变量,节点全是复用的)。 - 注意最后那行 tail.next = l1 或 l2: - 链表拼接剩余整段只是一次指针写入,O(1);换成数组合并, - 剩下的元素还得逐个复制。必考追问:合并 K 条呢? - (LC 23,Hard)把各条链依次并入结果是 O(nK); - 用最小堆每次取 K 个当前头节点里最小的,是 O(n log K) —— - 堆章(第 9 章)会讲。这个合并本身也是归并排序的核心步骤, - 链表排序(LC 148)就靠它。 + O(1)(只多了 dummy 和 tail 两个变量,节点全是复用的)。注意最后那行 tail.next = l1 或 l2:链表拼接剩余整段只是一次指针写入,O(1);换成数组合并,剩下的元素还得逐个复制。必考追问:合并 K 条呢? + (LC 23,Hard)把各条链依次并入结果是 O(nK);用最小堆每次取 K 个当前头节点里最小的,是 O(n log K) —— + 堆章(第 9 章)会讲。这个合并本身也是归并排序的核心步骤,链表排序(LC 148)就靠它。

    } /> @@ -2887,10 +2783,8 @@ function ListNode(val, next) { ), zh: ( <> - 链表 = 值 + next 引用的节点散落在内存各处, - 顺序只存在于引用里 —— 没有地址公式, - 访问 / 查找都是 O(n); - 换来的是不需要连续内存、也永远不必为扩容整体搬家。 + 链表 = 值 + next 引用的节点散落在内存各处,顺序只存在于引用里 —— 没有地址公式, + 访问 / 查找都是 O(n);换来的是不需要连续内存、也永远不必为扩容整体搬家。 ), }, @@ -2907,8 +2801,7 @@ function ListNode(val, next) { zh: ( <> 「插删 O(1)」的完整版: - 改指针 O(1),找前驱 O(n)。 - 真正的主场是「节点引用本来就在手上」—— + 改指针 O(1),找前驱 O(n)。真正的主场是「节点引用本来就在手上」—— LRU 缓存(哈希表 + 双向链表)是教科书案例。 ), @@ -2927,9 +2820,7 @@ function ListNode(val, next) { <> 指针操作铁律:先接后断( newNode.next = cur 在前, - prev.next = newNode 在后)。 - 顺序反了,整条后半链会失去最后一个引用。 - 改 next 之前先备份下一个节点。 + prev.next = newNode 在后)。顺序反了,整条后半链会失去最后一个引用。改 next 之前先备份下一个节点。 ), }, @@ -2946,8 +2837,7 @@ function ListNode(val, next) { zh: ( <> 三种套路:三指针反转(备份 → 调头 → 前移)、 - 快慢指针(相对速度 1,距离每步减 1, - 在环里必然相遇)、dummy 哨兵 + 快慢指针(相对速度 1,距离每步减 1,在环里必然相遇)、dummy 哨兵 (人人有前驱,头节点的特判随之消失)。 ), @@ -2964,10 +2854,8 @@ function ListNode(val, next) { ), zh: ( <> - 选型与语言陷阱:默认用数组家族(缓存友好); - 三语言都没有内置单链表,做题时手写 ListNode; - Java 的 LinkedList.get(i) 是 O(n), - 用下标循环遍历就变成 O(n²) —— 它是双端队列,不是数组。 + 选型与语言陷阱:默认用数组家族(缓存友好);三语言都没有内置单链表,做题时手写 ListNode; + Java 的 LinkedList.get(i) 是 O(n),用下标循环遍历就变成 O(n²) —— 它是双端队列,不是数组。 ), }, diff --git a/app/linked-list/viz.tsx b/app/linked-list/viz.tsx index 23eb53f..b24ae79 100644 --- a/app/linked-list/viz.tsx +++ b/app/linked-list/viz.tsx @@ -373,10 +373,8 @@ export function ScatterMap() { } zh={ <> - 数组的三个值排在 1000–1011 这段连续地址上,第 i 个用算式直接算出来; - 链表的三个节点分别在 2096 / 3120 / 1432,逻辑顺序 7 → 2 → 9{" "} - 只存在于 next 引用里,与地址毫无关系。想找第 2 个节点? - 只能从 head 出发,一次跟一根引用。 + 数组的三个值排在 1000–1011 这段连续地址上,第 i 个用算式直接算出来;链表的三个节点分别在 2096 / 3120 / 1432,逻辑顺序 7 → 2 → 9{" "} + 只存在于 next 引用里,与地址毫无关系。想找第 2 个节点?只能从 head 出发,一次跟一根引用。 } /> @@ -439,8 +437,7 @@ export function LinkedLab() { } zh={ <> - 头插第 ① 步 先接:newNode.next = head。 - 新节点先牵住整条链,此刻什么都没丢。 + 头插第 ① 步 先接:newNode.next = head。新节点先牵住整条链,此刻什么都没丢。 } />, @@ -458,8 +455,7 @@ export function LinkedLab() { } zh={ <> - 第 ② 步 换头:head = newNode。两次引用写入, - 成本与链表长度无关 —— 头插是 O(1)。 + 第 ② 步 换头:head = newNode。两次引用写入,成本与链表长度无关 —— 头插是 O(1)。 } />, @@ -479,8 +475,7 @@ export function LinkedLab() { } zh={ <> - 第 ① 步 先接:newNode.next 指向位置 {k} 的节点。 - 旧链完好无损,这一步随时可以反悔。 + 第 ① 步 先接:newNode.next 指向位置 {k} 的节点。旧链完好无损,这一步随时可以反悔。 } />, @@ -498,8 +493,7 @@ export function LinkedLab() { } zh={ <> - 第 ② 步 后断:prev.next = newNode,旧边(虚线)作废。 - 两次指针写入,O(1)。但别忘了:走到 prev 花了 O(n)。 + 第 ② 步 后断:prev.next = newNode,旧边(虚线)作废。两次指针写入,O(1)。但别忘了:走到 prev 花了 O(n)。 } />, @@ -543,8 +537,7 @@ export function LinkedLab() { } zh={ <> - 第 ① 步 绕过:prev.next = target.next。 - 只改这一根指针,目标节点就已经不在链上了。 + 第 ① 步 绕过:prev.next = target.next。只改这一根指针,目标节点就已经不在链上了。 } /> @@ -602,8 +595,7 @@ export function LinkedLab() { } zh={ <> - ⚠ 顺序反了。先断:prev.next = newNode。 - 可是 newNode.next 还是空的(?),而且再没人记得位置 {k} 在哪。 + ⚠ 顺序反了。先断:prev.next = newNode。可是 newNode.next 还是空的(?),而且再没人记得位置 {k} 在哪。 } />, @@ -621,8 +613,7 @@ export function LinkedLab() { } zh={ <> - 位置 {k} 起的整条后半链已经不可达:没有任何引用能到达它们, - 数据等于丢失。这就是「先接后断」四个字要防的事。 + 位置 {k} 起的整条后半链已经不可达:没有任何引用能到达它们,数据等于丢失。这就是「先接后断」四个字要防的事。 } />, @@ -888,8 +879,7 @@ const REV_FRAMES: RevFrame[] = [ } zh={ <> - 初始:prev = null,cur = head。 - prev 是已反转部分的头,cur 是正在处理的节点。目标是把每一根 next + 初始:prev = null,cur = head。prev 是已反转部分的头,cur 是正在处理的节点。目标是把每一根 next 引用原地调头,不新建任何节点。 } @@ -914,8 +904,7 @@ const REV_FRAMES: RevFrame[] = [ } zh={ <> - 第 ① 步 备份:nxt = cur.next,先记住节点 2 在哪。 - 不备份的话,下一行改掉 cur.next,后半条链就再也找不到了 —— + 第 ① 步 备份:nxt = cur.next,先记住节点 2 在哪。不备份的话,下一行改掉 cur.next,后半条链就再也找不到了 —— 和上面的反面教材是同一个问题。 } @@ -940,8 +929,7 @@ const REV_FRAMES: RevFrame[] = [ } zh={ <> - 第 ② 步 调头:cur.next = prev。prev 是 null, - 所以节点 1 现在指向 null —— 它将是新链的最后一个节点。 + 第 ② 步 调头:cur.next = prev。prev 是 null,所以节点 1 现在指向 null —— 它将是新链的最后一个节点。 } /> @@ -963,8 +951,7 @@ const REV_FRAMES: RevFrame[] = [ } zh={ <> - 第 ③ 步 前移:prev = cur,cur = nxt。 - 两个指针一起右移一格。绿色部分已经反转完毕,它的头永远是 prev。 + 第 ③ 步 前移:prev = cur,cur = nxt。两个指针一起右移一格。绿色部分已经反转完毕,它的头永远是 prev。 } /> @@ -988,8 +975,7 @@ const REV_FRAMES: RevFrame[] = [ } zh={ <> - 第二轮,同样三步:备份 nxt = 节点 3,把节点 2 的引用调头指向节点 1,再前移。 - 每一轮只改一根引用,其余原封不动。 + 第二轮,同样三步:备份 nxt = 节点 3,把节点 2 的引用调头指向节点 1,再前移。每一轮只改一根引用,其余原封不动。 } /> @@ -1012,8 +998,7 @@ const REV_FRAMES: RevFrame[] = [ } zh={ <> - 第三轮完成:节点 3 指向节点 2,prev 走到节点 3,cur 走到节点 4。 - 已反转的 [1 ← 2 ← 3] 与未处理的 [4 → ∅] 界限分明。 + 第三轮完成:节点 3 指向节点 2,prev 走到节点 3,cur 走到节点 4。已反转的 [1 ← 2 ← 3] 与未处理的 [4 → ∅] 界限分明。 } /> @@ -1036,8 +1021,7 @@ const REV_FRAMES: RevFrame[] = [ } zh={ <> - 第四轮:nxt 为 null,节点 4 调头指向节点 3,cur 变成 null。 - 循环条件 cur != null 不再成立,循环结束。 + 第四轮:nxt 为 null,节点 4 调头指向节点 3,cur 变成 null。循环条件 cur != null 不再成立,循环结束。 } /> @@ -1061,8 +1045,7 @@ const REV_FRAMES: RevFrame[] = [ } zh={ <> - 返回 prev 而不是 cur:cur 已经是 null,prev 停在原链的最后一个节点上, - 那正是新的头。结果是 4 → 3 → 2 → 1 → ∅。每个节点只处理一次,时间{" "} + 返回 prev 而不是 cur:cur 已经是 null,prev 停在原链的最后一个节点上,那正是新的头。结果是 4 → 3 → 2 → 1 → ∅。每个节点只处理一次,时间{" "} O(n);只用了三个指针变量,额外空间 O(1)。 } @@ -1221,9 +1204,7 @@ const CYC_FRAMES: CycFrame[] = [ } zh={ <> - 第 2 步:slow 到节点 3,fast 到节点 5,两个指针都进入了环。 - 如果没有环,节点 5 就是最后一个节点,fast.next 为 null, - 循环条件 fast != null && fast.next != null{" "} + 第 2 步:slow 到节点 3,fast 到节点 5,两个指针都进入了环。如果没有环,节点 5 就是最后一个节点,fast.next 为 null,循环条件 fast != null && fast.next != null{" "} 会让循环停下并返回 false。 } @@ -1272,10 +1253,7 @@ const CYC_FRAMES: CycFrame[] = [ } zh={ <> - 为什么一定会相遇?沿着环量「从 fast 往前走到 slow」的距离: - 第 2 步时这个距离是 1(5 → 3)。此后每一步 fast 前进 2、slow 前进 1, - 距离恰好减 1。它是一个不会变成负数的整数,所以必然减到 0, - 而 0 就意味着两个指针停在同一个节点上。时间 O(n),额外空间{" "} + 为什么一定会相遇?沿着环量「从 fast 往前走到 slow」的距离:第 2 步时这个距离是 1(5 → 3)。此后每一步 fast 前进 2、slow 前进 1,距离恰好减 1。它是一个不会变成负数的整数,所以必然减到 0,而 0 就意味着两个指针停在同一个节点上。时间 O(n),额外空间{" "} O(1)。用哈希集合记录访问过的节点同样是 O(n) 时间,但要 O(n) 空间。 } @@ -1409,8 +1387,7 @@ const MRG_FRAMES: MrgFrame[] = [ zh={ <> 1 vs 1:用 <= 时相等取 l1,合并保持稳定。 - tail.next 指向这个节点,tail 前移到它上面。 - 节点是整个重新挂接,不拷贝值 —— 这一步是 O(1)。 + tail.next 指向这个节点,tail 前移到它上面。节点是整个重新挂接,不拷贝值 —— 这一步是 O(1)。 } /> @@ -1508,9 +1485,7 @@ const MRG_FRAMES: MrgFrame[] = [ zh={ <> 收尾:l2 剩下的部分用 tail.next = l2{" "} - 整段直接挂上。这只是一次指针写入,O(1);换成数组合并, - 剩余元素还得逐个复制。最后返回 dummy.next,哨兵本身丢弃。 - 时间 O(n + m),额外空间 O(1)。 + 整段直接挂上。这只是一次指针写入,O(1);换成数组合并,剩余元素还得逐个复制。最后返回 dummy.next,哨兵本身丢弃。时间 O(n + m),额外空间 O(1)。 } /> diff --git a/app/page.tsx b/app/page.tsx index 32c6317..d8d9411 100644 --- a/app/page.tsx +++ b/app/page.tsx @@ -488,8 +488,7 @@ export default function Home() { <> 每一章:内存图解 → 交互可视化 →{" "} Java / Python / JavaScript{" "} - 三语言对照 → LeetCode 高频题精讲。由易到难,一章一个结构, - 看见它在内存里的样子,而不是背它的定义。 + 三语言对照 → LeetCode 高频题精讲。由易到难,一章一个结构,看见它在内存里的样子,而不是背它的定义。 } /> @@ -572,15 +571,11 @@ export default function Home() { zh={ <>

    - 盯着上面的动画看一轮:7 个数字从头到尾没变过,变的只是 - 它们的排列方式和互相之间的连线。排成一排、手拉手、分层站好、互相勾连 + 盯着上面的动画看一轮:7 个数字从头到尾没变过,变的只是它们的排列方式和互相之间的连线。排成一排、手拉手、分层站好、互相勾连 —— 这就是数组、链表、树、图。

    - 所以“数据结构”一句话说完:数据的组织方式。 - 而组织方式决定了每种操作的成本 —— 图书馆按拼音排书,找书快、插新书慢; - 按到货顺序堆书,插新书快、找书极慢。没有“最好的结构”, - 只有“最适合这批操作的结构”。整本课程,就是带你认识每一种组织方式的 + 所以“数据结构”一句话说完:数据的组织方式。而组织方式决定了每种操作的成本 —— 图书馆按拼音排书,找书快、插新书慢;按到货顺序堆书,插新书快、找书极慢。没有“最好的结构”,只有“最适合这批操作的结构”。整本课程,就是带你认识每一种组织方式的 特性:它擅长什么,不擅长什么,为什么。

    @@ -627,8 +622,7 @@ export default function Home() { } zh={ <> - LeetCode 的每道题,本质都在问同一句话:“这批操作,用哪种组织方式 - 成本最低?” 高频题精讲每章都有。 + LeetCode 的每道题,本质都在问同一句话:“这批操作,用哪种组织方式成本最低?” 高频题精讲每章都有。 } /> @@ -687,10 +681,7 @@ export default function Home() { } zh={

    - 把内存(RAM)想象成一条无限长的街道,街上全是 - 一模一样的小房间,每间房有一个唯一的门牌号(地址), - 每间房能放一个很小的东西(比如一个字节)。CPU 好比一位送件员: - 你给它任何一个门牌号,它都能用同样的时间找到那间房 + 把内存(RAM)想象成一条无限长的街道,街上全是一模一样的小房间,每间房有一个唯一的门牌号(地址),每间房能放一个很小的东西(比如一个字节)。CPU 好比一位送件员:你给它任何一个门牌号,它都能用同样的时间找到那间房 —— 这就是 RAM(Random Access,随机访问)的含义,也是一切 O(1) 的源头。

    } @@ -748,8 +739,7 @@ export default function Home() { <> 左边 5 间连续的房(数组的住法):知道首地址 1000,第 i 个元素 = 1000 + i×4,一步算出。右边零散的房(链表的住法 - ):每间房里额外记着“下一间在哪”,只能一间间跳。 - 这里每个整数占 4 个字节,也就是 4 间房,所以相邻元素的门牌号相差 4。 + ):每间房里额外记着“下一间在哪”,只能一间间跳。这里每个整数占 4 个字节,也就是 4 间房,所以相邻元素的门牌号相差 4。 } /> @@ -776,8 +766,7 @@ export default function Home() { zh={ <> 地址 = 首地址 + 下标 × 元素大小 —— - 数组 O(1) 访问、哈希表定位桶、堆用数组存树,全都建立在这一条乘加公式上。 - 看懂它,后面 14 章会不断和它重逢。 + 数组 O(1) 访问、哈希表定位桶、堆用数组存树,全都建立在这一条乘加公式上。看懂它,后面 14 章会不断和它重逢。 } /> @@ -826,17 +815,12 @@ export default function Home() { zh={ <>

    - 变量可以想成一张标签。它记录的东西分两类: - 像 7 这样的基本类型的值,直接写在变量里; - 而对象、数组这类复合数据,放在内存长街上的某个盒子里, - 变量里存的只是一张写着盒子地址的纸条 —— + 变量可以想成一张标签。它记录的东西分两类:像 7 这样的基本类型的值,直接写在变量里;而对象、数组这类复合数据,放在内存长街上的某个盒子里,变量里存的只是一张写着盒子地址的纸条 —— 这张纸条,就是引用(reference),C 语言里叫指针(pointer)。

    于是 b = a 这行代码有了两种截然不同的含义:基本类型的值是 - 复印数值,引用是复印纸条。 - 复印纸条之后,两张标签指着同一个盒子 —— 通过任何一张标签修改盒子里的东西, - 另一张标签看到的也变了。亲手试一次: + 复印数值,引用是复印纸条。复印纸条之后,两张标签指着同一个盒子 —— 通过任何一张标签修改盒子里的东西,另一张标签看到的也变了。亲手试一次:

    } @@ -878,9 +862,7 @@ System.out.println(a[0]); // 17`, ), zh: ( <> - 规则:8 种基本类型(int/double/boolean…)变量里直接装值; - 其余一切对象(数组、String、自定义类)变量里装的是引用。 - 赋值和传参永远是复制变量里的内容 —— 对象类型复制的就是那张纸条。 + 规则:8 种基本类型(int/double/boolean…)变量里直接装值;其余一切对象(数组、String、自定义类)变量里装的是引用。赋值和传参永远是复制变量里的内容 —— 对象类型复制的就是那张纸条。 ), }, @@ -991,10 +973,8 @@ console.log(a === b); // true —— 比较的是纸条`, } zh={ <> - 第 3 章链表的每个节点里,都存着一张写着「下一个节点在哪」的纸条; - 树的每个节点存着两张(left/right);图的每个顶点存着一组。 - 所谓“链式结构”,就是用纸条把散落在内存各处的盒子串起来。 - 理解了这个实验室,后面各章就都有了基础。 + 第 3 章链表的每个节点里,都存着一张写着「下一个节点在哪」的纸条;树的每个节点存着两张(left/right);图的每个顶点存着一组。 + 所谓“链式结构”,就是用纸条把散落在内存各处的盒子串起来。理解了这个实验室,后面各章就都有了基础。 } /> @@ -1042,8 +1022,7 @@ console.log(a === b); // true —— 比较的是纸条`, zh={ <>

    - 比较两个算法,不能比“谁在我电脑上跑得快”——机器不同、数据不同,结果不可比。 - 计算机科学的做法是问:数据规模 n 变大时,操作次数以什么方式增长? + 比较两个算法,不能比“谁在我电脑上跑得快”——机器不同、数据不同,结果不可比。计算机科学的做法是问:数据规模 n 变大时,操作次数以什么方式增长? 增长趋势用 O(...) 记号表示,只保留最高阶项、扔掉系数和常数: 3n²+5n+20 → O(n²)。

    @@ -1078,8 +1057,7 @@ console.log(a === b); // true —— 比较的是纸条`, zh={ <> ① Big-O ≠ 耗时:它是趋势,不是秒表。n 很小时,O(n²) 完全可能跑赢 - O(n log n)。② 复杂度看的是最坏、平均还是均摊,说的时候请讲清楚 - (哈希表平均 O(1)、最坏 O(n),就是经典例子)。 + O(n log n)。② 复杂度看的是最坏、平均还是均摊,说的时候请讲清楚(哈希表平均 O(1)、最坏 O(n),就是经典例子)。 } /> @@ -1242,8 +1220,7 @@ console.log(a === b); // true —— 比较的是纸条`, } zh={ <> - 直觉类比 → 内存图解 → 操作拆解。每个结构先回答三个问题: - 长什么样?擅长什么?为什么? + 直觉类比 → 内存图解 → 操作拆解。每个结构先回答三个问题:长什么样?擅长什么?为什么? } /> @@ -1265,8 +1242,7 @@ console.log(a === b); // true —— 比较的是纸条`, } zh={ <> - 每章都有可视化 Playground:亲手插入、删除、遍历,看指针怎么跳、 - 内存怎么搬。亲手操作过的结构,才算真正理解。 + 每章都有可视化 Playground:亲手插入、删除、遍历,看指针怎么跳、内存怎么搬。亲手操作过的结构,才算真正理解。 } /> @@ -1314,9 +1290,7 @@ console.log(a === b); // true —— 比较的是纸条`, } zh={ <> - 顶栏的 Java / Python / JS 切换是全站联动的:切一次,所有代码窗口 - 一起换语言。三种语言的数据结构抽象完全一致(数组就是数组,栈就是栈), - 差异只在实现与 API —— 每章的「三语言对照」会把差异一条条挑明。 + 顶栏的 Java / Python / JS 切换是全站联动的:切一次,所有代码窗口一起换语言。三种语言的数据结构抽象完全一致(数组就是数组,栈就是栈),差异只在实现与 API —— 每章的「三语言对照」会把差异一条条挑明。 } /> @@ -1415,8 +1389,7 @@ console.log(a === b); // true —— 比较的是纸条`, ), zh: ( <> - 六个档位记牢:O(1) → O(log n) → O(n) → O(n log n) → O(n²) → O(2ⁿ), - 一百万数据下它们是“瞬间”与“宇宙年龄”的差距。 + 六个档位记牢:O(1) → O(log n) → O(n) → O(n log n) → O(n²) → O(2ⁿ),一百万数据下它们是“瞬间”与“宇宙年龄”的差距。 ), }, diff --git a/app/queue/page.tsx b/app/queue/page.tsx index 422dfa6..119c4cc 100644 --- a/app/queue/page.tsx +++ b/app/queue/page.tsx @@ -53,8 +53,7 @@ const F239: ArrayFrame[] = [ ), zh: ( <> - nums = [5,3,1,4,2,6],k = 3。暴力做法每个窗口扫 k 个元素,O(nk)。 - 单调队列改成 O(1) 直接读出窗口最大值:队列里存的是下标 + nums = [5,3,1,4,2,6],k = 3。暴力做法每个窗口扫 k 个元素,O(nk)。单调队列改成 O(1) 直接读出窗口最大值:队列里存的是下标 ,对应的值从队头到队尾递减。高亮 = 当前在队列中。 ), @@ -107,8 +106,7 @@ const F239: ArrayFrame[] = [ ), zh: ( <> - i = 1:nums[1] = 3 比队尾的 5 小,不弹任何元素,3 从队尾入队。 - 留着它是有意义的:等 5 滑出窗口,3 可能就是最大值。队列:[5, + i = 1:nums[1] = 3 比队尾的 5 小,不弹任何元素,3 从队尾入队。留着它是有意义的:等 5 滑出窗口,3 可能就是最大值。队列:[5, 3],仍然递减。 ), @@ -199,8 +197,7 @@ const F239: ArrayFrame[] = [ zh: ( <> 窗口滑到 [1..3]:队头是下标 0,已经在窗口外 → 从队头弹出 - 。队列:[4],ans = [5, 4]。两端都在工作:队尾淘汰不够大的候选, - 队头清掉已经过期的下标。 + 。队列:[4],ans = [5, 4]。两端都在工作:队尾淘汰不够大的候选,队头清掉已经过期的下标。 ), }, @@ -258,8 +255,7 @@ const F239: ArrayFrame[] = [ ), zh: ( <> - i = 5:6 到来。队尾的 2、随后的 4 都比它小,全部弹出,队列变成 [6]。 - 窗口 [3..5] → ans = [5, 4, 4, 6]。 + i = 5:6 到来。队尾的 2、随后的 4 都比它小,全部弹出,队列变成 [6]。窗口 [3..5] → ans = [5, 4, 4, 6]。 ), }, @@ -285,10 +281,7 @@ const F239: ArrayFrame[] = [ ), zh: ( <> - 收官:ans = [5, 4, 4, 6]。for 里套着 while,看上去像 O(n²),其实不是: - 每个下标只入队一次、最多出队一次(无论从哪一端), - 整趟扫描的队列操作不超过 2n 次 —— O(n)。 - 暴力做法的工作量大约是它的 k 倍。 + 收官:ans = [5, 4, 4, 6]。for 里套着 while,看上去像 O(n²),其实不是:每个下标只入队一次、最多出队一次(无论从哪一端),整趟扫描的队列操作不超过 2n 次 —— O(n)。暴力做法的工作量大约是它的 k 倍。 ), }, @@ -343,9 +336,7 @@ export default function QueueChapter() { ), zh: ( <> - 队列按到达顺序服务:新元素从队尾加入, - 只有队头的元素能离开 —— 取走的永远是等待最久的那个。 - 这条规则叫 FIFO(先进先出)。而 + 队列按到达顺序服务:新元素从队尾加入,只有队头的元素能离开 —— 取走的永远是等待最久的那个。这条规则叫 FIFO(先进先出)。而 双端队列 deque 把限制放开:两端都能插入、都能删除。 ), @@ -383,11 +374,8 @@ export default function QueueChapter() { } zh={

    - 上一章的栈永远先处理最近的那个。现在想象一家打印店只有一台打印机: - 如果永远先打最新提交的文件,只要不断有新任务进来, - 最早那份文件就永远轮不到 —— 计算机科学管这叫 - 饥饿(starvation)。打印任务、外卖订单、客服工单、 - 消息系统,这些场景要的不是最近优先,而是 + 上一章的栈永远先处理最近的那个。现在想象一家打印店只有一台打印机:如果永远先打最新提交的文件,只要不断有新任务进来,最早那份文件就永远轮不到 —— 计算机科学管这叫 + 饥饿(starvation)。打印任务、外卖订单、客服工单、消息系统,这些场景要的不是最近优先,而是 先来先处理。

    } @@ -407,10 +395,7 @@ export default function QueueChapter() { } zh={

    - 为这种顺序而生的结构就是队列(Queue)。 - 画面感是店门口的队伍:新客人从队尾(rear)加入, - 店员只服务队头(front)的人。 - 没有人能越过别人,所以被服务的永远是等待最久的那个 —— + 为这种顺序而生的结构就是队列(Queue)。画面感是店门口的队伍:新客人从队尾(rear)加入,店员只服务队头(front)的人。没有人能越过别人,所以被服务的永远是等待最久的那个 —— 这就是队列的全部承诺,它有个名字: 先进先出,FIFO(First In, First Out)。由此推出三条规矩:

    @@ -473,8 +458,7 @@ export default function QueueChapter() { } zh={

    - 队列不提供访问 / 修改中间元素的操作。和栈一样:能力锁得越小, - 每个操作越快 —— 全部 O(1)。 + 队列不提供访问 / 修改中间元素的操作。和栈一样:能力锁得越小,每个操作越快 —— 全部 O(1)。

    } /> @@ -501,12 +485,9 @@ export default function QueueChapter() { zh={

    操作系统的任务调度队列、打印机的作业队列、Kafka / RabbitMQ - 这类消息队列(请求先排队,后端按自己的节奏消费)。 - 算法这边,第 7 章的树和第 12 章的图都靠队列驱动 - 广度优先搜索(BFS):正是队列让 BFS - 「一层处理完再处理下一层」,而这个顺序就是 BFS - 能在无权图里找到边数最少路径的原因。BFS 后面再讲, - 这一章先把队列本身学扎实。 + 这类消息队列(请求先排队,后端按自己的节奏消费)。算法这边,第 7 章的树和第 12 章的图都靠队列驱动 + 广度优先搜索(BFS):正是队列让 BFS「一层处理完再处理下一层」,而这个顺序就是 BFS + 能在无权图里找到边数最少路径的原因。BFS 后面再讲,这一章先把队列本身学扎实。

    } /> @@ -545,8 +526,7 @@ export default function QueueChapter() { 用数组装队列,麻烦立刻出现:入队在尾部,这是数组的强项(追加 O(1));可出队在头部 —— 数组章讲过,头部删除要让后面的元素整体左移一格, - 一次出队 O(n),队伍越长越慢。 - 不搬移也行,但队头腾出来的格子就再也用不上了。三种设计并排看: + 一次出队 O(n),队伍越长越慢。不搬移也行,但队头腾出来的格子就再也用不上了。三种设计并排看:

    } /> @@ -569,11 +549,9 @@ export default function QueueChapter() { zh={

    设计三就是循环队列(circular queue) - ,工程里也叫环形缓冲区(ring buffer): - 数组在内存里仍是一条直线,但所有下标运算都以{" "} + ,工程里也叫环形缓冲区(ring buffer):数组在内存里仍是一条直线,但所有下标运算都以{" "} % capacity 结尾,于是它在逻辑上 - 变成一个圈 —— front 在一头消费,rear 绕回来在另一头补充, - 只要没装满,永远有格子可用。§03 的环形队列实验室可以亲手转这个圈。 + 变成一个圈 —— front 在一头消费,rear 绕回来在另一头补充,只要没装满,永远有格子可用。§03 的环形队列实验室可以亲手转这个圈。

    } /> @@ -606,8 +584,7 @@ export default function QueueChapter() {

    维护 head、tail 两个指针:出队 = 摘下头节点(O(1)),入队 = 接在尾节点后(O(1))。为什么不反过来?单链表尾部删除要先找到前驱, - O(n),而头删、尾插都不需要遍历 —— 还是那句话:选不用搬移的那端。 - 链表队列不用扩容、也不会装满,代价是每个元素多一个指针,而且缓存不友好。 + O(n),而头删、尾插都不需要遍历 —— 还是那句话:选不用搬移的那端。链表队列不用扩容、也不会装满,代价是每个元素多一个指针,而且缓存不友好。

    } /> @@ -663,8 +640,7 @@ export default function QueueChapter() { } zh={

    - 网卡驱动的收发包缓冲、音频设备的采样缓冲、日志系统的定长缓冲、 - 高频交易框架 LMAX Disruptor 的核心 —— 全是环形缓冲区。原因每次都一样: + 网卡驱动的收发包缓冲、音频设备的采样缓冲、日志系统的定长缓冲、高频交易框架 LMAX Disruptor 的核心 —— 全是环形缓冲区。原因每次都一样: 定长数组 + 两个绕圈下标 = 零分配、零搬移、访问的内存又挨得很近 。生产者和消费者各追各的下标,互不打扰。

    @@ -831,8 +807,7 @@ export default function QueueChapter() { zh={

    动手转几圈,重点看三件事:①出队时没有任何元素被搬移 - ;②rear 走到最后一格时怎么绕回 0;③「满」和「空」为什么会长得一样, - 以及两种区分方案: + ;②rear 走到最后一格时怎么绕回 0;③「满」和「空」为什么会长得一样,以及两种区分方案:

    } /> @@ -863,13 +838,9 @@ export default function QueueChapter() { } zh={

    - 空,是 front 追上了 rear;满,是 rear 绕完整整一圈追上了 front。 - 两种情况下都是 front == rear,光看下标区分不了。 - 设计上必须消歧,标准答案有两个。方案 A:永久留一格空 —— - 开 k + 1 格,(rear + 1) % cap == front 即为满,不需要额外变量, - 代价是牺牲一格。方案 B:维护 size 计数器 —— 空 = size - == 0,满 = size == cap,格子全能用,代价是每次进出都要更新计数器。 - 两种都对;§04 的实现用的是方案 A,环形队列实验室里可以来回切换。 + 空,是 front 追上了 rear;满,是 rear 绕完整整一圈追上了 front。两种情况下都是 front == rear,光看下标区分不了。设计上必须消歧,标准答案有两个。方案 A:永久留一格空 —— + 开 k + 1 格,(rear + 1) % cap == front 即为满,不需要额外变量,代价是牺牲一格。方案 B:维护 size 计数器 —— 空 = size + == 0,满 = size == cap,格子全能用,代价是每次进出都要更新计数器。两种都对;§04 的实现用的是方案 A,环形队列实验室里可以来回切换。

    } /> @@ -904,9 +875,7 @@ export default function QueueChapter() { zh={

    下面这个类就是 LeetCode 622「设计循环队列」的题解 - :定长数组 + front / rear 两个下标 + 取模绕圈,采用方案 A - 「留一格空」(所以构造时多开一格)。每一行都能对应到环形队列实验室 - 里的一个动作: + :定长数组 + front / rear 两个下标 + 取模绕圈,采用方案 A「留一格空」(所以构造时多开一格)。每一行都能对应到环形队列实验室里的一个动作:

    } /> @@ -1080,8 +1049,7 @@ export default function QueueChapter() { zh: ( <> 细节:Python 里 -1 % 8 == 7 - (结果与除数同号),所以不必像 Java / JavaScript 那样先 + len。 - 但如果你跨语言写代码,统一写{" "} + (结果与除数同号),所以不必像 Java / JavaScript 那样先 + len。但如果你跨语言写代码,统一写{" "} (i - 1 + n) % n 最保险。 ), @@ -1195,8 +1163,7 @@ MyCircularQueue.prototype.isFull = function () { zh={

    链表版队列也值得手写一遍。第 7 章各语言的 BFS - 分别用 ArrayDeque、deque 和数组加读指针,并不用链表队列; - 但链表版藏着一个面试常问的边界问题:tail 的归位。 + 分别用 ArrayDeque、deque 和数组加读指针,并不用链表队列;但链表版藏着一个面试常问的边界问题:tail 的归位。

    } /> @@ -1420,11 +1387,8 @@ class LinkedQueue: } zh={

    - 单链表里,头部删除 O(1);有 tail 指针时尾部插入 O(1); - 尾部删除 O(n)(要先找到前驱)。所以出队必须在头、入队必须在尾 —— - 方向反过来,其中一端就退化成 O(n)。 - 这和「数组栈的栈顶在尾部、链表栈的栈顶在头部」是同一套推理: - 哪端不花钱就用哪端。 + 单链表里,头部删除 O(1);有 tail 指针时尾部插入 O(1);尾部删除 O(n)(要先找到前驱)。所以出队必须在头、入队必须在尾 —— + 方向反过来,其中一端就退化成 O(n)。这和「数组栈的栈顶在尾部、链表栈的栈顶在头部」是同一套推理:哪端不花钱就用哪端。

    } /> @@ -1460,8 +1424,7 @@ class LinkedQueue:

    队列是三种语言标准库差异最大的结构:Java 和 Python 都提供了可以直接用的 deque,JavaScript 什么也没有 ——{" "} - Array.prototype.shift() 看着像出队, - 实际是「取走第一个元素,其余整体前移」, + Array.prototype.shift() 看着像出队,实际是「取走第一个元素,其余整体前移」, 一般情况下是 O(n)。逐个看:

    } @@ -1527,8 +1490,7 @@ Queue slower = new java.util.LinkedList<>();`, zh: ( <> 两套 API:offer / poll / peek 在操作无法完成时返回 false - 或 null;add / remove / element 则抛异常。做题一般用前一组。 - 另外注意 ArrayDeque{" "} + 或 null;add / remove / element 则抛异常。做题一般用前一组。另外注意 ArrayDeque{" "} 不允许存 null,因为 null 被它用作「没有元素」的信号。 @@ -1592,8 +1554,7 @@ bad.pop(0) # O(n):抽走第一个元素,其余整体左移 zh: ( <> 底层结构:deque 是块状双向链表 —— - 每个节点是一个能装 64 个元素的小数组块。两端 O(1), - 内存也比「一个元素一个节点」紧凑;代价是中间随机访问{" "} + 每个节点是一个能装 64 个元素的小数组块。两端 O(1),内存也比「一个元素一个节点」紧凑;代价是中间随机访问{" "} q[i] 退化为 O(n)。 list.pop(0) 是用 Python 做题时最常见的性能问题。 @@ -1644,9 +1605,7 @@ const empty = head === q.length; ), zh: ( <> - 取舍:下标法里「已出队」的元素仍占着内存, - 直到整个数组被回收。做题时程序只运行几百毫秒,完全无所谓; - 长期运行的服务里,要么定期用{" "} + 取舍:下标法里「已出队」的元素仍占着内存,直到整个数组被回收。做题时程序只运行几百毫秒,完全无所谓;长期运行的服务里,要么定期用{" "} q = q.slice(head) 整理一次,要么换链表队列。 ), @@ -1830,8 +1789,7 @@ const empty = head === q.length; } zh={

    - 两个 LIFO 叠出一个 FIFO:反转两次等于恢复原序。 - 它是均摊分析的经典例题。LC 232,精讲 A。 + 两个 LIFO 叠出一个 FIFO:反转两次等于恢复原序。它是均摊分析的经典例题。LC 232,精讲 A。

    } /> @@ -1882,8 +1840,7 @@ const empty = head === q.length; zh={

    回文判断(比较两端再向中间收拢)、0-1 BFS(权为 0 - 的边插队头、权为 1 的边排队尾,属于进阶话题,本课不展开)、工作窃取调度(线程把自己这端当栈用, - 其他线程从另一端取走任务)。 + 的边插队头、权为 1 的边排队尾,属于进阶话题,本课不展开)、工作窃取调度(线程把自己这端当栈用,其他线程从另一端取走任务)。

    } /> @@ -1906,8 +1863,7 @@ const empty = head === q.length; zh={

    单调队列(monotonic deque) - 是一种内部元素始终保持有序的双端队列,靠「插入前先弹出」来维持这个顺序。 - 以滑动窗口最大值为例:队列里存的是 + 是一种内部元素始终保持有序的双端队列,靠「插入前先弹出」来维持这个顺序。以滑动窗口最大值为例:队列里存的是 下标而不是值,这些下标对应的值从队头到队尾 递减。维持它的规则有两条,两端各一条:

    @@ -1936,9 +1892,7 @@ const empty = head === q.length; zh={

    下标 i 入队前,把队尾所有值不大于 nums[i] - 的下标弹出。它们既比新元素小,又比新元素更早离开窗口, - 所以不可能再成为任何窗口的最大值。值相等的下标也会被弹掉, - 因此队列里的值是严格递减的。 + 的下标弹出。它们既比新元素小,又比新元素更早离开窗口,所以不可能再成为任何窗口的最大值。值相等的下标也会被弹掉,因此队列里的值是严格递减的。

    } /> @@ -1960,9 +1914,7 @@ const empty = head === q.length; } zh={

    - 队头下标一旦落到窗口之外,就从队头弹出。 - 只有队头可能过期(它是队列里最老的下标), - 所以每步只需要检查一次。 + 队头下标一旦落到窗口之外,就从队头弹出。只有队头可能过期(它是队列里最老的下标),所以每步只需要检查一次。

    } /> @@ -2008,11 +1960,8 @@ const empty = head === q.length; } zh={

    - 代码里 for 套着 while,很多人据此认定是 O(n²) —— 不是。 - 每个下标只入队一次、最多出队一次 - (无论从哪一端),所以整个数组走完,队列操作总数不超过 2n。 - 时间是 O(n);空间 O(k), - 因为队列里的下标数量不会超过窗口长度。 + 代码里 for 套着 while,很多人据此认定是 O(n²) —— 不是。每个下标只入队一次、最多出队一次 + (无论从哪一端),所以整个数组走完,队列操作总数不超过 2n。时间是 O(n);空间 O(k),因为队列里的下标数量不会超过窗口长度。

    } /> @@ -2040,10 +1989,7 @@ const empty = head === q.length; } zh={

    - 两者拿到 O(n) 的方式相同:提前丢掉「永远不可能成为答案」的元素。 - 区别在元素从哪一端离场。单调栈解决「下一个更大元素」这类问题, - 元素被弹出的那一刻就结算答案;单调队列解决窗口类问题, - 多了一条规则:队头的下标会过期 —— + 两者拿到 O(n) 的方式相同:提前丢掉「永远不可能成为答案」的元素。区别在元素从哪一端离场。单调栈解决「下一个更大元素」这类问题,元素被弹出的那一刻就结算答案;单调队列解决窗口类问题,多了一条规则:队头的下标会过期 —— 窗口向前滑,老下标自然失效。栈用一端就够,窗口必须两端都用。

    } @@ -2085,11 +2031,10 @@ const empty = head === q.length; zh={

    题意:只准用栈(LIFO),实现队列的 push / pop / peek / - empty。 思路:栈把顺序反过来 —— 那就再反一次。 - 朴素做法:每次 push 都借助第二个栈把新元素垫到底部,push - O(n)。 更好的做法:不到必须的时候就不搬 —— in - 栈只负责进,out 栈只负责出, - 只有 out 空了才把 in 整体倒过去: + empty。思路:栈把顺序反过来 —— 那就再反一次。 + 朴素做法:每次 push 都借助第二个栈把新元素垫到底部,push + O(n)。更好的做法:不到必须的时候就不搬 —— in + 栈只负责进,out 栈只负责出,只有 out 空了才把 in 整体倒过去:

    } /> @@ -2279,9 +2224,7 @@ MyQueue.prototype._transfer = function () { 单看一次 pop,最坏是 O(n)(正好赶上转移)。改成盯元素 而不是操作:一个元素一生最多被搬动 4 次 —— 进 in、出 in、进 out、出 out,而且每一段最多发生一次(out - 非空时绝不转移,所以没有元素会被转移第二次)。 - n 次操作总搬动不超过 4n 次,平均每次 O(1)。 - 数组扩容(1 + 2 + 4 + … < 2n)、单调栈(每个元素进出各一次,不超过 + 非空时绝不转移,所以没有元素会被转移第二次)。n 次操作总搬动不超过 4n 次,平均每次 O(1)。数组扩容(1 + 2 + 4 + … < 2n)、单调栈(每个元素进出各一次,不超过 2n)算的是同一本账: 均摊分析就是把偶发的大开销摊到所有操作头上。

    @@ -2310,9 +2253,7 @@ MyQueue.prototype._transfer = function () { } zh={

    - push O(1);pop / peek 均摊 O(1);空间 O(n)。追问一: - 「为什么 out 非空时不能转移?」—— 转移过去的元素会压在更早的元素上面, - 顺序立刻就错了。追问二:「反过来用队列实现栈呢?」—— 那是 LC + push O(1);pop / peek 均摊 O(1);空间 O(n)。追问一:「为什么 out 非空时不能转移?」—— 转移过去的元素会压在更早的元素上面,顺序立刻就错了。追问二:「反过来用队列实现栈呢?」—— 那是 LC 225(题单里有):每次 push 后把前面的 n − 1 个元素挪到队尾,push O(n)、pop O(1),两题互为镜像。

    @@ -2360,11 +2301,10 @@ MyQueue.prototype._transfer = function () { zh={

    题意:长度为 k 的窗口从左滑到右,输出每个位置的窗口最大值。 - 暴力:每个窗口扫 k 个元素,O(nk) —— n = 10⁵ 时会超时。 - 为什么能优化:相邻两个窗口共享 k − 1 个元素,暴力做法 + 暴力:每个窗口扫 k 个元素,O(nk) —— n = 10⁵ 时会超时。 + 为什么能优化:相邻两个窗口共享 k − 1 个元素,暴力做法 把几乎相同的一段反复重扫;而且它扔掉了信息 —— - 一个元素只要右边出现了更大的数,它在此后任何窗口里都不可能是最大值, - 这样的元素根本不必保留。把「还有可能的候选」按递减顺序存进 + 一个元素只要右边出现了更大的数,它在此后任何窗口里都不可能是最大值,这样的元素根本不必保留。把「还有可能的候选」按递减顺序存进 deque,就是单调队列:

    } @@ -2540,12 +2480,9 @@ class Solution: } zh={

    - 时间 O(n):每个下标入队一次、最多出队一次, - 所以队列操作总数不超过 2n —— 尽管代码里 for 套着 while。空间 - O(k)。追问一:「求窗口最小值?」—— 所有比较反向,维护递增队列。 - 追问二:「同时要 max 和 min?」—— - 在同一个窗口上并行跑两个单调队列(LC 1438,题单里有)。追问三: - 「为什么存下标不存值?」——过期判断需要位置信息(队头 ≤ i − + 时间 O(n):每个下标入队一次、最多出队一次,所以队列操作总数不超过 2n —— 尽管代码里 for 套着 while。空间 + O(k)。追问一:「求窗口最小值?」—— 所有比较反向,维护递增队列。追问二:「同时要 max 和 min?」—— + 在同一个窗口上并行跑两个单调队列(LC 1438,题单里有)。追问三:「为什么存下标不存值?」——过期判断需要位置信息(队头 ≤ i − k)。下标能查出值,值查不出下标 —— 和单调栈存下标是同一个道理。

    @@ -2625,8 +2562,7 @@ class Solution: ), zh: ( <> - 朴素数组队列只能二选一:每次出队都搬移(O(n)), - 或者让队头腾出的格子永远闲置。循环队列把所有下标都{" "} + 朴素数组队列只能二选一:每次出队都搬移(O(n)),或者让队头腾出的格子永远闲置。循环队列把所有下标都{" "} % cap,一次解决两个问题。此时 front == rear 既可能是满也可能是空,所以设计上要么留一格空,要么 维护 size 计数器。 @@ -2669,8 +2605,7 @@ class Solution: ), zh: ( <> - 双栈模拟队列:反转两次恢复到达顺序;每个元素一生最多被搬动 4 次, - 所以 pop 是均摊 O(1) —— 和数组扩容、单调栈是同一本账。 + 双栈模拟队列:反转两次恢复到达顺序;每个元素一生最多被搬动 4 次,所以 pop 是均摊 O(1) —— 和数组扩容、单调栈是同一本账。 ), }, @@ -2687,9 +2622,7 @@ class Solution: ), zh: ( <> - 单调队列里存的是下标,对应值从队头到队尾递减: - 队尾弹出所有值不大于新元素的下标,队头弹出已经离开窗口的下标。 - 于是队头永远是当前窗口的最大值,整趟扫描是 O(n) —— + 单调队列里存的是下标,对应值从队头到队尾递减:队尾弹出所有值不大于新元素的下标,队头弹出已经离开窗口的下标。于是队头永远是当前窗口的最大值,整趟扫描是 O(n) —— 因为每个下标只入队一次、最多出队一次。 ), diff --git a/app/queue/viz.tsx b/app/queue/viz.tsx index 2cea91e..b701c48 100644 --- a/app/queue/viz.tsx +++ b/app/queue/viz.tsx @@ -121,10 +121,8 @@ export function QueueMemFig() { } zh={ <> - 不搬移任何元素,只把 front 右移一格,出队变成 O(1)。 - 但 slot[0] 从此永远用不上;而且 12 写进 slot[3] - 之后,下一个写入位置是 4,已经越过数组末尾。 - 一个长期运行的服务会不断把数组撑大 —— 而里面其实只有 3 个元素。 + 不搬移任何元素,只把 front 右移一格,出队变成 O(1)。但 slot[0] 从此永远用不上;而且 12 写进 slot[3] + 之后,下一个写入位置是 4,已经越过数组末尾。一个长期运行的服务会不断把数组撑大 —— 而里面其实只有 3 个元素。 } /> @@ -157,8 +155,7 @@ export function QueueMemFig() { <> 设计二加一条规则:所有下标都对容量取模。图里的状态比上面又往前走了一步 —— 7、9 在 slot[2]、slot[3],2 刚从 slot[1] 出队。下一个写入位置本该是 4, - 4 % 4 = 0,于是 12 写进 slot[0],复用了出队腾出的空间。 - 直线在逻辑上变成了圆环:没有元素搬移,也没有格子浪费 —— 这就是 + 4 % 4 = 0,于是 12 写进 slot[0],复用了出队腾出的空间。直线在逻辑上变成了圆环:没有元素搬移,也没有格子浪费 —— 这就是 循环队列。 } @@ -229,8 +226,7 @@ export function RingLab() { zh={ <> 满了。rear 的下一格就是 front —— 再写进去,「满」和「空」都会变成 - front == rear,无法区分。方案 A 永久空出这一格(虚线格), - 所以 8 格最多装 7 个。想用满 8 格,切到方案 B。 + front == rear,无法区分。方案 A 永久空出这一格(虚线格),所以 8 格最多装 7 个。想用满 8 格,切到方案 B。 } /> @@ -577,8 +573,7 @@ const POUR_FRAMES: PourFrame[] = [ } zh={ <> - 规则只有三条:push 一律进 in;pop / peek 一律找 out; - 只有 out 空了,才把 in 整体倒进 out。 + 规则只有三条:push 一律进 in;pop / peek 一律找 out;只有 out 空了,才把 in 整体倒进 out。 } /> @@ -630,8 +625,7 @@ const POUR_FRAMES: PourFrame[] = [ } zh={ <> - pop(),而 out 是空的 → 触发转移:in 的栈顶是 2,它先被弹出, - 压进 out,落在 out 的底部。 + pop(),而 out 是空的 → 触发转移:in 的栈顶是 2,它先被弹出,压进 out,落在 out 的底部。 } /> @@ -651,8 +645,7 @@ const POUR_FRAMES: PourFrame[] = [ } zh={ <> - 1 随后压入,正好落在 out 的栈顶。反转两次等于没反转: - 先到的 1 回到了「最先出去」的位置。 + 1 随后压入,正好落在 out 的栈顶。反转两次等于没反转:先到的 1 回到了「最先出去」的位置。 } /> @@ -692,8 +685,7 @@ const POUR_FRAMES: PourFrame[] = [ zh={ <> push(3):进 in,完全不打扰 out。纪律:只要 out - 里还有更早的元素,就绝不转移 —— 提前转移会把 3 放到 2 前面, - 顺序立刻错乱。 + 里还有更早的元素,就绝不转移     —— 提前转移会把 3 放到 2 前面,顺序立刻错乱。 } /> @@ -724,9 +716,7 @@ const POUR_FRAMES: PourFrame[] = [ } zh={ <> - pop() = 3:out 空 → 转移把 3 搬过来 → 弹出。算总账: - 每个元素一生最多被搬动 4 次(进 in、出 in、进 out、出 out), - 所以 n 次调用总共不超过 4n 次搬动,即均摊 O(1)。 + pop() = 3:out 空 → 转移把 3 搬过来 → 弹出。算总账:每个元素一生最多被搬动 4 次(进 in、出 in、进 out、出 out),所以 n 次调用总共不超过 4n 次搬动,即均摊 O(1)。 } /> diff --git a/app/stack/page.tsx b/app/stack/page.tsx index c2155b0..bbebd01 100644 --- a/app/stack/page.tsx +++ b/app/stack/page.tsx @@ -50,8 +50,7 @@ const F20: ArrayFrame[] = [ zh={ <> 输入 s = {'"([{}])"'}。规则:每个右括号必须与最近的 - 那个尚未配对的左括号成对 —— 「最近的」正是栈能 O(1) 给你的东西。 - 栈里存的就是「还没等到另一半的左括号」;下面把栈横过来画,右端是栈顶。 + 那个尚未配对的左括号成对 —— 「最近的」正是栈能 O(1) 给你的东西。栈里存的就是「还没等到另一半的左括号」;下面把栈横过来画,右端是栈顶。 } /> @@ -148,8 +147,7 @@ const F20: ArrayFrame[] = [ } zh={ <> - 读到 {"']'"}:{"'{'"} 已经走了,新栈顶是 {"'['"},正好配对,弹出。 - 每个右括号遇到的都是「最近的未配对左括号」—— 这就是 LIFO 与嵌套的咬合点。 + 读到 {"']'"}:{"'{'"} 已经走了,新栈顶是 {"'['"},正好配对,弹出。每个右括号遇到的都是「最近的未配对左括号」—— 这就是 LIFO 与嵌套的咬合点。 } /> @@ -226,9 +224,7 @@ const F155: ArrayFrame[] = [ } zh={ <> - 目标:push / pop / top / getMin 全部 O(1)。做法:主栈旁边再放一个辅助栈, - 每一层记录「push 这一层时,栈内的最小值」。下面把两者画进同一个格子: - 上 = 值,下 = 该层记下的 min。代价是 O(n) 额外空间。 + 目标:push / pop / top / getMin 全部 O(1)。做法:主栈旁边再放一个辅助栈,每一层记录「push 这一层时,栈内的最小值」。下面把两者画进同一个格子:上 = 值,下 = 该层记下的 min。代价是 O(n) 额外空间。 } /> @@ -263,8 +259,7 @@ const F155: ArrayFrame[] = [ } zh={ <> - push(0):这一层的 min = min(0, −2) = −2。注意存的是什么: - 不是 0 本身,而是「包含这一层在内、整段栈的最小值」。 + push(0):这一层的 min = min(0, −2) = −2。注意存的是什么:不是 0 本身,而是「包含这一层在内、整段栈的最小值」。 } /> @@ -325,8 +320,7 @@ const F155: ArrayFrame[] = [ } zh={ <> - pop():−3 连同它那一层的 min 一起弹走,全栈最小值自动回到 −2。 - 为什么可以这样?因为下面那一层记的,正是「−3 入栈之前」那个栈的最小值。 + pop():−3 连同它那一层的 min 一起弹走,全栈最小值自动回到 −2。为什么可以这样?因为下面那一层记的,正是「−3 入栈之前」那个栈的最小值。 } /> @@ -374,9 +368,7 @@ const F739: ArrayFrame[] = [ } zh={ <> - T = [73,74,71,69,75,73],求每天还要等几天才升温。暴力做法是每天向后扫,O(n²)。 - 单调栈里存的是「答案还未确定」的下标,它们的温度自底向上不递增。 - 亮起 = 正在栈中等待,变绿 = 答案已结算。 + T = [73,74,71,69,75,73],求每天还要等几天才升温。暴力做法是每天向后扫,O(n²)。单调栈里存的是「答案还未确定」的下标,它们的温度自底向上不递增。亮起 = 正在栈中等待,变绿 = 答案已结算。 } /> @@ -493,8 +485,7 @@ const F739: ArrayFrame[] = [ } zh={ <> - i=3:69 更冷,继续入栈。栈:[1, 2, 3] —— 每个等待者都比它下面那个冷, - 这就是栈维持的不变量。 + i=3:69 更冷,继续入栈。栈:[1, 2, 3] —— 每个等待者都比它下面那个冷,这就是栈维持的不变量。 } /> @@ -524,8 +515,7 @@ const F739: ArrayFrame[] = [ } zh={ <> - i=4:75 比栈顶的 69 暖 → 弹出 3,ans[3] = 4 − 3 = 1。 - 新栈顶 71 仍然比 75 冷,循环继续。 + i=4:75 比栈顶的 69 暖 → 弹出 3,ans[3] = 4 − 3 = 1。新栈顶 71 仍然比 75 冷,循环继续。 } /> @@ -555,8 +545,7 @@ const F739: ArrayFrame[] = [ } zh={ <> - 继续弹出 2:ans[2] = 4 − 2 = 2。它等了两天,而这两天是在被弹出时 - 用一次减法算出来的 —— 中途完全不用记着它。 + 继续弹出 2:ans[2] = 4 − 2 = 2。它等了两天,而这两天是在被弹出时用一次减法算出来的 —— 中途完全不用记着它。 } /> @@ -586,8 +575,7 @@ const F739: ArrayFrame[] = [ } zh={ <> - 74 也被弹出:ans[1] = 4 − 1 = 3。栈空了,下标 4(75)入栈。 - 一个 75 一次性送走三个等待者 —— 代码里那个 while 循环做的就是这件事。 + 74 也被弹出:ans[1] = 4 − 1 = 3。栈空了,下标 4(75)入栈。一个 75 一次性送走三个等待者 —— 代码里那个 while 循环做的就是这件事。 } /> @@ -640,8 +628,7 @@ const F739: ArrayFrame[] = [ zh={ <> 扫描结束:栈里剩下的 4、5 右边再没有更暖的日子,答案保持 0。结果 - [1,3,2,1,0,0]。每个下标恰好入栈一次、最多出栈一次, - 全程栈操作不超过 2n → O(n)。 + [1,3,2,1,0,0]。每个下标恰好入栈一次、最多出栈一次,全程栈操作不超过 2n → O(n)。 } /> @@ -695,8 +682,7 @@ export default function StackChapter() { ), zh: ( <> - 一摞盘子:放和拿都发生在同一端(栈顶), - 所以取走的永远是最后放进去的那个。就这一条规则 —— 后进先出, + 一摞盘子:放和拿都发生在同一端(栈顶),所以取走的永远是最后放进去的那个。就这一条规则 —— 后进先出, Last In, First Out —— 让它天然贴合嵌套、撤销与函数调用。 ), @@ -749,20 +735,13 @@ export default function StackChapter() { zh={ <>

    - 数组和链表给了我们「存一串东西」的通用能力。但回想几个天天在用的功能: - 编辑器里按 Ctrl+Z,撤销的一定是最近 - 一次修改;浏览器点「后退」,回到的一定是上一个页面; - 一个函数调另一个函数,最后被调用的那个总是最先结束。 - 三件事长得完全不同,骨架却一模一样: + 数组和链表给了我们「存一串东西」的通用能力。但回想几个天天在用的功能:编辑器里按 Ctrl+Z,撤销的一定是最近 + 一次修改;浏览器点「后退」,回到的一定是上一个页面;一个函数调另一个函数,最后被调用的那个总是最先结束。三件事长得完全不同,骨架却一模一样: 最近发生的,最先被处理。

    为这类问题,我们把「随便存取」的自由整个交出去,换一个受限的结构: - 栈(Stack)。想象食堂里那摞叠起来的盘子: - 洗好的盘子放最上面,取盘子也从最上面拿,于是最后放上去的最先被拿走。 - 机制就是这一句:放入和取出发生在同一端,所以取走的永远是最后放进去的那个。 - 这条规则叫 LIFO(Last In, First Out,后进先出)。 - 栈只立三条规矩: + 栈(Stack)。想象食堂里那摞叠起来的盘子:洗好的盘子放最上面,取盘子也从最上面拿,于是最后放上去的最先被拿走。机制就是这一句:放入和取出发生在同一端,所以取走的永远是最后放进去的那个。这条规则叫 LIFO(Last In, First Out,后进先出)。栈只立三条规矩:

    } @@ -785,8 +764,7 @@ export default function StackChapter() { } zh={

    - 放(push)、拿(pop)、看(peek)都只作用于栈顶。 - 栈不提供「动中间那一个」的操作 —— 想拿到它,得先把上面的全拿走。 + 放(push)、拿(pop)、看(peek)都只作用于栈顶。栈不提供「动中间那一个」的操作 —— 想拿到它,得先把上面的全拿走。

    } /> @@ -807,8 +785,7 @@ export default function StackChapter() { } zh={

    - 最后进来的最先出去。这不是限制的副作用,而是目的本身: - 嵌套、撤销、回退,本来就是「最近优先」的顺序。 + 最后进来的最先出去。这不是限制的副作用,而是目的本身:嵌套、撤销、回退,本来就是「最近优先」的顺序。

    } /> @@ -858,9 +835,7 @@ export default function StackChapter() { } zh={

    - 数据结构不只看「能做什么」,也看「禁止做什么」。栈禁止访问中间, - 换回来的是:每个操作都快、顺序绝不出错、实现极其简单。以后看到 - 「最近的先处理」「嵌套配对」「撤销 / 回退」,第一个该想到的就是 + 数据结构不只看「能做什么」,也看「禁止做什么」。栈禁止访问中间,换回来的是:每个操作都快、顺序绝不出错、实现极其简单。以后看到「最近的先处理」「嵌套配对」「撤销 / 回退」,第一个该想到的就是 栈。

    } @@ -881,9 +856,7 @@ export default function StackChapter() { } zh={

    - 编辑器的撤销栈、浏览器的历史栈、JSON / HTML 解析器的标签栈、 - 表达式求值,以及每一门语言运行时的函数调用栈(§03 会讲)…… - 你写的每一行代码,其实都跑在一个栈上。 + 编辑器的撤销栈、浏览器的历史栈、JSON / HTML 解析器的标签栈、表达式求值,以及每一门语言运行时的函数调用栈(§03 会讲)……你写的每一行代码,其实都跑在一个栈上。

    } /> @@ -919,11 +892,9 @@ export default function StackChapter() { } zh={

    - 打开内存看,栈没有自己独特的物理布局:它要么住在 - 一个数组里,要么住在一个链表里。「栈」这个词描述的是 + 打开内存看,栈没有自己独特的物理布局:它要么住在一个数组里,要么住在一个链表里。「栈」这个词描述的是 接口与纪律(只准从一端进出),而不是存储方式 —— - 这叫抽象数据类型(ADT,Abstract Data Type)。 - 同一份合同,两种履行方式: + 这叫抽象数据类型(ADT,Abstract Data Type)。同一份合同,两种履行方式:

    } /> @@ -951,10 +922,7 @@ export default function StackChapter() {

    为什么数组实现的栈顶在尾部,链表实现的栈顶却在 头部?两次的答案是同一句: - 选那端不用搬家、也不用遍历的。 - 数组尾部追加 / 删除是 O(1),放在头部则每次都要全体搬家; - 链表头插 / 头删是 O(1),删尾节点还得从头找到它的前驱。 - 结构变了,原则没变。 + 选那端不用搬家、也不用遍历的。数组尾部追加 / 删除是 O(1),放在头部则每次都要全体搬家;链表头插 / 头删是 O(1),删尾节点还得从头找到它的前驱。结构变了,原则没变。

    } /> @@ -987,15 +955,8 @@ export default function StackChapter() { } zh={

    - 绝大多数标准库选数组实现:连续内存对 CPU 缓存友好, - 扩容的成本也可以接受 —— 单次扩容要复制 n 个元素, - 但容量是按当前规模成比例增长的,摊到每次 push 上是常数。 - 所以数组实现的 push 是均摊 O(1),而不是最坏情况 O(1)。 - 链表实现正相反:push 最坏情况也是 O(1),不会有扩容抖动; - 代价是每次 push 都要分配一个节点,每个节点多背一个{" "} - next 指针,而且节点散落在堆上,访问不如数组缓存友好。 - 「每次操作耗时稳定」这一点在实时性敏感的场景(某些嵌入式 / 音频系统) - 才更重要。Java 的 ArrayDeque、Python 的{" "} + 绝大多数标准库选数组实现:连续内存对 CPU 缓存友好,扩容的成本也可以接受 —— 单次扩容要复制 n 个元素,但容量是按当前规模成比例增长的,摊到每次 push 上是常数。所以数组实现的 push 是均摊 O(1),而不是最坏情况 O(1)。链表实现正相反:push 最坏情况也是 O(1),不会有扩容抖动;代价是每次 push 都要分配一个节点,每个节点多背一个{" "} + next 指针,而且节点散落在堆上,访问不如数组缓存友好。「每次操作耗时稳定」这一点在实时性敏感的场景(某些嵌入式 / 音频系统)才更重要。Java 的 ArrayDeque、Python 的{" "} list、JS 的 Array 全是数组路线。

    } @@ -1170,9 +1131,7 @@ export default function StackChapter() { ArrayDeque 抛 NoSuchElementException ,Python 抛 IndexError,而 JS 的{" "} [].pop() 不报错,直接返回{" "} - undefined —— 静默的那个最危险,错误会跑到很远的地方才暴露。 - 所以模板永远是:先判空,再动手。LC 20 就是直接的例子: - 栈空却遇到右括号,可以立刻返回 false。 + undefined —— 静默的那个最危险,错误会跑到很远的地方才暴露。所以模板永远是:先判空,再动手。LC 20 就是直接的例子:栈空却遇到右括号,可以立刻返回 false。

    } /> @@ -1196,10 +1155,7 @@ export default function StackChapter() {

    接下来看栈在计算机里最重要的一份工作 ——{" "} 调用栈(call stack)。每调用一个函数,就压入一个 - 栈帧(stack frame):帧里装着参数、局部变量, - 以及返回地址(调用方从哪一行继续执行)。 - 每次 return 弹掉一帧。下面是一段小程序, - 演示会逐帧执行它(第 2 行是 main 等待 f 返回的地方): + 栈帧(stack frame):帧里装着参数、局部变量,以及返回地址(调用方从哪一行继续执行)。每次 return 弹掉一帧。下面是一段小程序,演示会逐帧执行它(第 2 行是 main 等待 f 返回的地方):

    } /> @@ -1313,13 +1269,9 @@ main();`, } zh={

    - 操作系统会在内存里划出一块区域专门存放调用栈(称为栈区),每个线程一块。 - 默认大小通常在 1 MB(Windows 和 JVM 线程)到 8 MB(Linux 主线程)之间, - Java 用 -Xss 调整,Linux 用 ulimit -s 调整。一个栈帧几十到几百字节,所以递归深度上限 - 大致在几万层;Python 干脆自己设限,默认只允许 1000 层。 - 这就是为什么处理超深的树 / 图时,工程代码常把递归改写成 - 显式栈 + 迭代(§06 套路三)。任何递归都能这样改写, - 只是改完不一定更好读。 + 操作系统会在内存里划出一块区域专门存放调用栈(称为栈区),每个线程一块。默认大小通常在 1 MB(Windows 和 JVM 线程)到 8 MB(Linux 主线程)之间, + Java 用 -Xss 调整,Linux 用 ulimit -s 调整。一个栈帧几十到几百字节,所以递归深度上限大致在几万层;Python 干脆自己设限,默认只允许 1000 层。这就是为什么处理超深的树 / 图时,工程代码常把递归改写成 + 显式栈 + 迭代(§06 套路三)。任何递归都能这样改写,只是改完不一定更好读。

    } /> @@ -1354,10 +1306,7 @@ main();`, } zh={

    - 用数组章的动态数组亲手造一个栈。你会发现所谓「实现栈」, - 其实就是把数组的能力锁小:只暴露尾部操作, - 其余全部藏起来。Java 版连扩容都自己写,Python / JS 的动态数组自带扩容, - 代码更短 —— 但内存里发生的事完全相同: + 用数组章的动态数组亲手造一个栈。你会发现所谓「实现栈」,其实就是把数组的能力锁小:只暴露尾部操作,其余全部藏起来。Java 版连扩容都自己写,Python / JS 的动态数组自带扩容,代码更短 —— 但内存里发生的事完全相同:

    } /> @@ -1434,8 +1383,7 @@ public class ArrayStack { ), zh: ( <> - 为什么 pop 只是 size 减一:旧值还躺在数组里, - 但已经在「合同」之外,下次 push 会直接覆盖它。删除 = 约定不再看它。 + 为什么 pop 只是 size 减一:旧值还躺在数组里,但已经在「合同」之外,下次 push 会直接覆盖它。删除 = 约定不再看它。 ), }, @@ -1503,9 +1451,7 @@ public class ArrayStack { ), zh: ( <> - 为什么还要封装?list 本来就能 append / pop, - 但拿到 ArrayStack 的人只能按 LIFO 用。 - 把能力锁小,一整类错误就没有发生的机会。 + 为什么还要封装?list 本来就能 append / pop,但拿到 ArrayStack 的人只能按 LIFO 用。把能力锁小,一整类错误就没有发生的机会。 ), }, @@ -1566,8 +1512,7 @@ public class ArrayStack { zh: ( <> 注意:这里主动抛错,补上了原生 Array.pop(){" "} - 在空数组上静默返回 undefined 的问题 —— 封装的另一个价值: - 把语言层面的陷阱挡在算法之外。 + 在空数组上静默返回 undefined 的问题 —— 封装的另一个价值:把语言层面的陷阱挡在算法之外。 ), }, @@ -1663,12 +1608,9 @@ old.push(1); // 能用,但每个方法都带着同步锁`, ,每个方法都是 synchronized ,单线程代码也要付这份用不到的加锁成本;作为 Vector 它还暴露{" "} get(i)、insertElementAt - ,调用方随时能读中间、往中间插,LIFO 纪律形同虚设。 - JDK 文档写明:栈操作应优先使用 ArrayDeque。 - 另外 Deque 有两个细节要记住:push /{" "} + ,调用方随时能读中间、往中间插,LIFO 纪律形同虚设。JDK 文档写明:栈操作应优先使用 ArrayDeque。另外 Deque 有两个细节要记住:push /{" "} pop 都作用在头部 - ,所以把 ArrayDeque 当栈遍历时,顺序是从栈顶到栈底; - 而且 ArrayDeque 不允许存 null。 + ,所以把 ArrayDeque 当栈遍历时,顺序是从栈顶到栈底;而且 ArrayDeque 不允许存 null。 ), }, @@ -1709,8 +1651,7 @@ empty = not stack # 判空的惯用写法 zh: ( <> 易错点:写成 pop(0){" "} - 就变成了头删,其余元素要整体前移,O(n)(数组章讲过)。 - 栈操作永远是不带参数的 pop()。 + 就变成了头删,其余元素要整体前移,O(n)(数组章讲过)。栈操作永远是不带参数的 pop()。 ), }, @@ -1914,8 +1855,7 @@ const empty = stack.length === 0;`, } zh={

    - 括号匹配、相邻消除、嵌套解码:凡是「右半边要找最近的左半边」 - ,就把左半边压栈等着。LC 20、1047、394、150。 + 括号匹配、相邻消除、嵌套解码:凡是「右半边要找最近的左半边」,就把左半边压栈等着。LC 20、1047、394、150。

    } /> @@ -1939,8 +1879,7 @@ const empty = stack.length === 0;`, zh={

    「每个元素右边第一个比它大 / 小的是谁?」→ 单调栈 - ,一遍扫描回答所有问题,把 O(n²) 压成 O(n)。LC 739、496、503、84、42。 - 下面专题详讲。 + ,一遍扫描回答所有问题,把 O(n²) 压成 O(n)。LC 739、496、503、84、42。下面专题详讲。

    } /> @@ -1963,9 +1902,7 @@ const empty = stack.length === 0;`, } zh={

    - 递归本来就跑在调用栈上 —— 把系统的栈换成自己创建的显式栈, - 任何递归都能改成迭代,也就不再受调用栈深度的限制。 - 二叉树迭代遍历(第 7 章)。 + 递归本来就跑在调用栈上 —— 把系统的栈换成自己创建的显式栈,任何递归都能改成迭代,也就不再受调用栈深度的限制。二叉树迭代遍历(第 7 章)。

    } /> @@ -1993,13 +1930,8 @@ const empty = stack.length === 0;`, zh={

    单调栈(monotonic stack) - 是一种栈内元素始终保持有序的栈,靠「入栈前先弹」来维持这个顺序。 - 以「找下一个更大元素」为例:栈里存的是 - 答案还未确定的元素下标,它们的值自底向上不递增。 - 新元素比栈顶大时,它就是栈顶右边第一个更大的元素,于是弹出栈顶并记下答案。 - 为什么被弹出的下标可以彻底忘掉?因为它右边第一个更大的元素刚刚已经找到, - 答案当场记下;栈里只保留还在等待答案的下标,所以它之后不会再被用到。 - 三个问题想清楚,单调栈就通了: + 是一种栈内元素始终保持有序的栈,靠「入栈前先弹」来维持这个顺序。以「找下一个更大元素」为例:栈里存的是 + 答案还未确定的元素下标,它们的值自底向上不递增。新元素比栈顶大时,它就是栈顶右边第一个更大的元素,于是弹出栈顶并记下答案。为什么被弹出的下标可以彻底忘掉?因为它右边第一个更大的元素刚刚已经找到,答案当场记下;栈里只保留还在等待答案的下标,所以它之后不会再被用到。三个问题想清楚,单调栈就通了:

    } /> @@ -2049,8 +1981,7 @@ const empty = stack.length === 0;`, } zh={

    - 新元素破坏单调性时:不递增栈里来了个比栈顶大的, - 就用 while 连续弹,直到栈顶不再比它小(或栈空),然后新元素入栈。 + 新元素破坏单调性时:不递增栈里来了个比栈顶大的,就用 while 连续弹,直到栈顶不再比它小(或栈空),然后新元素入栈。

    } /> @@ -2077,8 +2008,7 @@ const empty = stack.length === 0;`, zh={

    被弹元素的答案就是「弹它的那个元素」:739 结算等待天数 - (下标之差),84 结算以它为高的矩形,42 结算一层雨水。 - 栈里存下标:下标能推出位置和值,值推不出位置。 + (下标之差),84 结算以它为高的矩形,42 结算一层雨水。栈里存下标:下标能推出位置和值,值推不出位置。

    } /> @@ -2102,9 +2032,7 @@ const empty = stack.length === 0;`, zh={

    while 套在 for 里,看着像 O(n²)?算总账:每个下标 - 恰好入栈一次、最多出栈一次,弹出后不再回来, - 全程栈操作不超过 2n。这和数组扩容用的是同一套均摊分析: - 不要盯着最贵的那一步,要算总数。 + 恰好入栈一次、最多出栈一次,弹出后不再回来,全程栈操作不超过 2n。这和数组扩容用的是同一套均摊分析:不要盯着最贵的那一步,要算总数。

    } /> @@ -2145,10 +2073,8 @@ const empty = stack.length === 0;`,

    题意:只含六种括号的字符串,判断是否有效 —— 每个右括号都要与 最近的那个尚未配对的同类左括号成对。 - 暴力:反复扫描,把 ()、[]、 - {"{}"} 这样的相邻对删掉,直到删无可删 —— 每轮 O(n), - 最多 n/2 轮,O(n²)。正解:「最近的未配对左括号」 - 就是栈顶,一遍扫描就够。栈适合这道题不是巧合,这就是原因。 + 暴力:反复扫描,把 ()、[]、 + {"{}"} 这样的相邻对删掉,直到删无可删 —— 每轮 O(n),最多 n/2 轮,O(n²)。正解:「最近的未配对左括号」就是栈顶,一遍扫描就够。栈适合这道题不是巧合,这就是原因。

    } /> @@ -2204,9 +2130,7 @@ const empty = stack.length === 0;`, zh: ( <> 另一种写法:遇到左括号时直接压入它期待的右括号(如{" "} - if (c == '(') stack.push(')')), - 比对时一个 stack.pop() != c 就够,不用查配对表。 - 上面的写法压入左括号,是为了让栈的内容和动画一致。 + if (c == '(') stack.push(')')),比对时一个 stack.pop() != c 就够,不用查配对表。上面的写法压入左括号,是为了让栈的内容和动画一致。 ), }, @@ -2354,7 +2278,7 @@ const empty = stack.length === 0;`, O(1) 返回当前最小值 getMin。暴力:getMin 时扫一遍栈, O(n) —— 正是题目要排除的做法。只存一个全局 min 变量呢? push 时更新没问题,可一旦最小值被 pop 走,第二小是谁?不知道,还得扫。 - 正解:问题出在「历史被丢了」,那就把历史留下来:用一个 + 正解:问题出在「历史被丢了」,那就把历史留下来:用一个 辅助栈记录每次 push 时的最小值,两个栈同进同出:

    } @@ -2530,11 +2454,8 @@ MinStack.prototype.getMin = function () { return this.mins.at(-1); }; // O(1)`,

    关键在栈的纪律本身:栈顶被 pop 后,露出来的恰好就是 这个元素 push 之前的那个栈,而辅助栈在那一层存的 min - 记录的正是那个状态的最小值。换成允许中间删除的结构(比如数组), - 这套「历史快照」立刻失效。是 LIFO 让历史可以被正确回滚。 - 追问:「能省点空间吗?」有两条路。一是只在新值 ≤ 当前最小值时才压辅助栈 - (pop 时相等才弹),平均能省,最坏仍是 O(n); - 二是只用一个栈,遇到新的最小值时压入编码差值{" "} + 记录的正是那个状态的最小值。换成允许中间删除的结构(比如数组),这套「历史快照」立刻失效。是 LIFO 让历史可以被正确回滚。 + 追问:「能省点空间吗?」有两条路。一是只在新值 ≤ 当前最小值时才压辅助栈(pop 时相等才弹),平均能省,最坏仍是 O(n);二是只用一个栈,遇到新的最小值时压入编码差值{" "} 2 * val - min,pop 时反解出上一个最小值 —— 额外空间 O(1),但编码后的值可能达到输入范围的约两倍, 32 位会溢出,必须用 64 位运算。 @@ -2559,8 +2480,7 @@ MinStack.prototype.getMin = function () { return this.mins.at(-1); }; // O(1)`, } zh={

    - 四个操作全部 O(1),辅助栈带来 O(n) 额外空间。 - 这道题真正要带走的是一招通用手法: + 四个操作全部 O(1),辅助栈带来 O(n) 额外空间。这道题真正要带走的是一招通用手法: 「随栈的历史变化的量,用第二个栈把每一层都记下来」 —— 很多「设计一个支持 X 的栈」都是它的变体。

    @@ -2607,8 +2527,7 @@ MinStack.prototype.getMin = function () { return this.mins.at(-1); }; // O(1)`, 才会遇到更高的温度(等不到记 0)。暴力:每天向后线性扫, O(n²) —— n = 10⁵ 时约 10¹⁰ 步,会超时。为什么能优化: 暴力的浪费在于反复重扫同一段:74、71、69 都在等 75, - 75 出现时应该一次性把它们全部结算。 - 把「还在等待的日子」存进栈,新入栈的一定比前一个更冷,这就是单调栈: + 75 出现时应该一次性把它们全部结算。把「还在等待的日子」存进栈,新入栈的一定比前一个更冷,这就是单调栈:

    } /> @@ -2751,13 +2670,8 @@ MinStack.prototype.getMin = function () { return this.mins.at(-1); }; // O(1)`, } zh={

    - 时间 O(n):每个下标入栈一次、最多出栈一次, - 栈操作总数不超过 2n —— 嵌套循环并不意味着 O(n²)。空间 O(n)。 - 追问一:「为什么栈里存下标不存温度?」—— 结算要算 - 两个下标之差,而且下标能推出温度,温度推不出下标。 - 追问二:「找上一个更大的呢?」—— 同一遍扫描里就有: - 下标 i 入栈前,栈顶就是它左边最近的、温度不低于 T[i] 的那一天。 - 追问三:「数组是环形的呢?」—— 下标跑到 2n − 1、访问时用{" "} + 时间 O(n):每个下标入栈一次、最多出栈一次,栈操作总数不超过 2n —— 嵌套循环并不意味着 O(n²)。空间 O(n)。追问一:「为什么栈里存下标不存温度?」—— 结算要算 + 两个下标之差,而且下标能推出温度,温度推不出下标。追问二:「找上一个更大的呢?」—— 同一遍扫描里就有:下标 i 入栈前,栈顶就是它左边最近的、温度不低于 T[i] 的那一天。追问三:「数组是环形的呢?」—— 下标跑到 2n − 1、访问时用{" "} i % n,第二圈只弹不进(LC 503,题单里有)。

    } @@ -2820,8 +2734,7 @@ MinStack.prototype.getMin = function () { return this.mins.at(-1); }; // O(1)`, zh: ( <> 栈 = 只开一个口的容器:pop / peek / isEmpty / size 都是 - O(1);push 在数组实现下是均摊 O(1),在链表实现下最坏也是 O(1), - 代价是每次都要分配一个节点。数组实现栈顶在尾部 + O(1);push 在数组实现下是均摊 O(1),在链表实现下最坏也是 O(1),代价是每次都要分配一个节点。数组实现栈顶在尾部 、链表实现栈顶在头节点 —— 都是选「不用搬家」的那端。 ), @@ -2836,8 +2749,7 @@ MinStack.prototype.getMin = function () { return this.mins.at(-1); }; // O(1)`, ), zh: ( <> - 「最近的先处理」是栈的信号:撤销、后退、括号配对、嵌套解码、 - 函数调用 —— 嵌套结构本身就是 LIFO 顺序。 + 「最近的先处理」是栈的信号:撤销、后退、括号配对、嵌套解码、函数调用 —— 嵌套结构本身就是 LIFO 顺序。 ), }, @@ -2853,9 +2765,7 @@ MinStack.prototype.getMin = function () { return this.mins.at(-1); }; // O(1)`, ), zh: ( <> - 调用栈:每次调用压一帧(参数、局部变量、返回地址), - 每次 return 弹一帧;递归就是函数不断为自己压帧,太深就是栈溢出。 - 出路是显式栈 + 迭代,任何递归都能这样改写。 + 调用栈:每次调用压一帧(参数、局部变量、返回地址),每次 return 弹一帧;递归就是函数不断为自己压帧,太深就是栈溢出。出路是显式栈 + 迭代,任何递归都能这样改写。 ), }, @@ -2871,9 +2781,7 @@ MinStack.prototype.getMin = function () { return this.mins.at(-1); }; // O(1)`, ), zh: ( <> - 单调栈:找下一个更大时,栈内自底向上不递增; - 新元素破坏单调性就弹栈,弹出的瞬间结算被弹元素的答案; - 每个下标入栈一次、最多出栈一次,所以整趟是 O(n)。 + 单调栈:找下一个更大时,栈内自底向上不递增;新元素破坏单调性就弹栈,弹出的瞬间结算被弹元素的答案;每个下标入栈一次、最多出栈一次,所以整趟是 O(n)。 ), }, diff --git a/app/stack/viz.tsx b/app/stack/viz.tsx index 46a2311..6b81c9f 100644 --- a/app/stack/viz.tsx +++ b/app/stack/viz.tsx @@ -111,8 +111,7 @@ export function StackMemFig() { } zh={ <> - ✓ 栈顶 = 头节点:头插 / 头删只改一根指针,最坏情况也是 O(1), - 而且永不扩容。 + ✓ 栈顶 = 头节点:头插 / 头删只改一根指针,最坏情况也是 O(1),而且永不扩容。
    △ 代价:每次 push 都要分配一个节点,每个节点多背一个 next 指针,节点散落在堆上,访问不如数组缓存友好(链表章讲过)。 @@ -170,8 +169,7 @@ export function StackLab() { } zh={ <> - 栈满(容量 {CAPACITY})。定长数组实现会直接拒绝; - 动态数组实现会先扩容到两倍、复制元素,再收下它 —— + 栈满(容量 {CAPACITY})。定长数组实现会直接拒绝;动态数组实现会先扩容到两倍、复制元素,再收下它 —— 这次复制正是 push 只能算「均摊 O(1)」而不是最坏 O(1) 的原因。 } @@ -193,8 +191,7 @@ export function StackLab() { } zh={ <> - push({v}):新盘子只能放到最上面,不惊动下面任何人 —— O(1)。 - top 自动上移一层。 + push({v}):新盘子只能放到最上面,不惊动下面任何人 —— O(1)。top 自动上移一层。 } />, @@ -238,8 +235,7 @@ export function StackLab() { } zh={ <> - pop() = {top.v}:只能拿最上面的盘子 —— O(1)。 - 想拿栈底的?先把上面的全拿走。这不是缺陷,是纪律。 + pop() = {top.v}:只能拿最上面的盘子 —— O(1)。想拿栈底的?先把上面的全拿走。这不是缺陷,是纪律。 } />, @@ -273,8 +269,7 @@ export function StackLab() { } zh={ <> - peek() = {items[items.length - 1].v}:只看不拿,栈保持原样。 - LC 20、LC 739 这类算法每一步都靠它先看一眼栈顶。 + peek() = {items[items.length - 1].v}:只看不拿,栈保持原样。LC 20、LC 739 这类算法每一步都靠它先看一眼栈顶。 } />, @@ -369,8 +364,7 @@ const CS_FRAMES: CSFrame[] = [ } zh={ <> - 程序一启动,main 的栈帧(stack frame)率先入栈。 - 帧里装着这个函数的参数、局部变量,以及「回到哪一行继续」的返回地址。 + 程序一启动,main 的栈帧(stack frame)率先入栈。帧里装着这个函数的参数、局部变量,以及「回到哪一行继续」的返回地址。 } /> @@ -537,8 +531,7 @@ const CS_FRAMES: CSFrame[] = [ <> 再看一种情况:递归忘了写终止条件,栈帧不断堆积 —— 调用栈的地盘(通常 1~8 MB)几毫秒就被填满,程序崩溃。这就是 - 栈溢出:Java 的 StackOverflowError、Python 的 RecursionError。 - 程序员问答网站 Stack Overflow 的名字就来自它。 + 栈溢出:Java 的 StackOverflowError、Python 的 RecursionError。程序员问答网站 Stack Overflow 的名字就来自它。 } /> diff --git a/app/string/page.tsx b/app/string/page.tsx index 0a042df..4e59e7e 100644 --- a/app/string/page.tsx +++ b/app/string/page.tsx @@ -80,8 +80,7 @@ const F125: ArrayFrame[] = [ } zh={ <> - L 的 A 对 R 的 a:都是字母,统一小写后 a = a,这一对匹配。 - 两个指针各向内走一步。 + L 的 A 对 R 的 a:都是字母,统一小写后 a = a,这一对匹配。两个指针各向内走一步。 } /> @@ -111,8 +110,7 @@ const F125: ArrayFrame[] = [ } zh={ <> - L 现在指着 ?:既不是字母也不是数字,不参与判断,直接跳过,L++。 - 这一步不做比较,只挪指针。 + L 现在指着 ?:既不是字母也不是数字,不参与判断,直接跳过,L++。这一步不做比较,只挪指针。 } /> @@ -141,8 +139,7 @@ const F125: ArrayFrame[] = [ } zh={ <> - R 指着 ,:同样是标点,跳过,R--。每个指针各自清理自己那一侧, - 清理完才做比较。 + R 指着 ,:同样是标点,跳过,R--。每个指针各自清理自己那一侧,清理完才做比较。 } /> @@ -235,8 +232,7 @@ const F3: ArrayFrame[] = [ } zh={ <> - 窗口 [l..r] 是当前「无重复字符」的一段;随身带一个 Set, - 记录窗口里现在有哪些字符。 + 窗口 [l..r] 是当前「无重复字符」的一段;随身带一个 Set,记录窗口里现在有哪些字符。 } /> @@ -398,8 +394,7 @@ const F3: ArrayFrame[] = [ } zh={ <> - r=6:b 再次重复。这次要连吐 s[3]=a、s[4]=b 两个,直到窗口里没有 b。 - 窗口 "cb",长度 2。 + r=6:b 再次重复。这次要连吐 s[3]=a、s[4]=b 两个,直到窗口里没有 b。窗口 "cb",长度 2。 } /> @@ -428,8 +423,7 @@ const F3: ArrayFrame[] = [ zh={ <> r=7 同理,窗口缩到 "b"。扫描结束:最长无重复子串是{" "} - "abc",长度 3。l 和 r 都只前进不后退, - 每个字符最多进出窗口一次,所以是 O(n)。 + "abc",长度 3。l 和 r 都只前进不后退,每个字符最多进出窗口一次,所以是 O(n)。 } /> @@ -456,8 +450,7 @@ const F5: ArrayFrame[] = [ zh={ <> 奇数长的回文,中心是一个字符;偶数长的回文,中心是一个空隙。n - 个字符对应 n 个字符中心加 n−1 个空隙中心,共 2n−1 个中心。 - 挨个试,每个中心向两边扩。 + 个字符对应 n 个字符中心加 n−1 个空隙中心,共 2n−1 个中心。挨个试,每个中心向两边扩。 } /> @@ -547,9 +540,7 @@ const F5: ArrayFrame[] = [ } zh={ <> - 中心 i=2(b):左 a = 右 a,得到 "aba",长度 3,与纪录持平。 - 再扩一层:左 b ≠ 右 d,停。让「扩」这个动作成立的不变量是: - 每一步之前 s[l+1..r−1] 已经是回文,所以只要 s[l] = s[r],s[l..r] + 中心 i=2(b):左 a = 右 a,得到 "aba",长度 3,与纪录持平。再扩一层:左 b ≠ 右 d,停。让「扩」这个动作成立的不变量是:每一步之前 s[l+1..r−1] 已经是回文,所以只要 s[l] = s[r],s[l..r] 就也是回文;一层扩不动,以这个中心为轴的更长回文就不可能存在。 } @@ -577,8 +568,7 @@ const F5: ArrayFrame[] = [ zh={ <> 空隙中心也别忘了。以下标 1 和 2 之间的空隙为例:第一步比 a 和 b - 就失败,长度 0。奇偶两套中心都要枚举,不然 "abba" - 这类偶数长回文会被漏掉。 + 就失败,长度 0。奇偶两套中心都要枚举,不然 "abba"这类偶数长回文会被漏掉。 } /> @@ -602,8 +592,7 @@ const F5: ArrayFrame[] = [ } zh={ <> - 中心 i=3(a):左 b ≠ 右 d,长度 1;中心 i=4(d):长度 1。 - 所有中心试完。 + 中心 i=3(a):左 b ≠ 右 d,长度 1;中心 i=4(d):长度 1。所有中心试完。 } /> @@ -708,9 +697,7 @@ export default function StringChapter() { ), zh: ( <> - 一个不许改字的字符数组:读哪个位置都是 O(1), - 但改一个字就要重抄全文。字符的本质是数字, - 而这一章的许多易错点,都与「数字如何变成文字」的编码表有关。 + 一个不许改字的字符数组:读哪个位置都是 O(1),但改一个字就要重抄全文。字符的本质是数字,而这一章的许多易错点,都与「数字如何变成文字」的编码表有关。 ), }} @@ -748,12 +735,9 @@ export default function StringChapter() { } zh={ <> - 上一章的数组像一排可擦写的白板格子: - 想改哪格,擦掉重写就行。字符串像 + 上一章的数组像一排可擦写的白板格子:想改哪格,擦掉重写就行。字符串像 刻在石板上的一行字 —— - 每个字符仍然有自己的格子,从 0 开始编号,这一点和数组一模一样, - 但刻上去就不能再改。想把「明天下雨」改成「明天放晴」? - 只能重新刻一块石板,把没变的字也一并重刻。 + 每个字符仍然有自己的格子,从 0 开始编号,这一点和数组一模一样,但刻上去就不能再改。想把「明天下雨」改成「明天放晴」?只能重新刻一块石板,把没变的字也一并重刻。 } /> @@ -777,9 +761,7 @@ export default function StringChapter() { <> 这条规则叫不可变(immutable),Java 的{" "} String、Python 的 str、JavaScript - 的字符串都遵守它。它是刻意的设计,不是缺陷 - (下面的故事卡会讲原因)。先记住它的后果:所有看起来在「修改」 - 字符串的操作 —— 拼接、替换、大小写转换 —— 背后都在 + 的字符串都遵守它。它是刻意的设计,不是缺陷(下面的故事卡会讲原因)。先记住它的后果:所有看起来在「修改」字符串的操作 —— 拼接、替换、大小写转换 —— 背后都在 整段重抄。这一个事实,直接决定了本章一半的复杂度结论。 } @@ -798,10 +780,8 @@ export default function StringChapter() { } zh={ <> - 还有一件事必须先说破:格子里存的根本不是「字」。计算机只存数字, - 所谓字符,是数字查了一张编码表(character encoding) - 之后的显示结果:65 查表得 'A',23383 查表得「字」。 - 由此有三条家规: + 还有一件事必须先说破:格子里存的根本不是「字」。计算机只存数字,所谓字符,是数字查了一张编码表(character encoding) + 之后的显示结果:65 查表得 'A',23383 查表得「字」。由此有三条家规: } /> @@ -826,8 +806,7 @@ export default function StringChapter() { zh={ <> 创建之后内容固定。replace、 - toUpperCase、拼接统统返回新字符串, - 原件分毫未动 —— 「修改」的真实成本是重抄一遍,O(n)。 + toUpperCase、拼接统统返回新字符串,原件分毫未动 —— 「修改」的真实成本是重抄一遍,O(n)。 } /> @@ -850,9 +829,7 @@ export default function StringChapter() { } zh={ <> - 每个字符都是编码表里的一个编号:'A' = 65、 - 'a' = 97、「字」= 23383。比较、排序、大小写转换, - 本质全是整数运算。 + 每个字符都是编码表里的一个编号:'A' = 65、'a' = 97、「字」= 23383。比较、排序、大小写转换,本质全是整数运算。 } /> @@ -876,9 +853,7 @@ export default function StringChapter() { } zh={ <> - 字符串就像一个只能读、不能写的字符数组:下标 O(1)、支持遍历和切片。 - 但要注意:一个下标不一定等于一个字符(见 §02)。 - 想「原地修改」,先转成真正可变的字符数组,改完再拼回来。 + 字符串就像一个只能读、不能写的字符数组:下标 O(1)、支持遍历和切片。但要注意:一个下标不一定等于一个字符(见 §02)。想「原地修改」,先转成真正可变的字符数组,改完再拼回来。 } /> @@ -913,14 +888,9 @@ export default function StringChapter() { } zh={ <> - ① 安全:字符串是最常见的哈希键(第 6 章)。如果内容能变, - 存进哈希表后再一改,这个键就永远找不回来了;不可变还让 hashCode - 可以算一次就缓存。② 共享:内容不会变,多个变量就能安全地 - 指向同一份 —— Java 的字符串常量池、Python 的字符串驻留都靠它省内存。 - ③ 多线程免锁:不会变的值,多少线程同时读都不会出事。 - 代价只有一个:频繁修改的场景很贵,所以三种语言都配了「可变的替身」 - —— StringBuilder、Python 的 list、JavaScript 的数组。 - §04 我们亲手造一个。 + ① 安全:字符串是最常见的哈希键(第 6 章)。如果内容能变,存进哈希表后再一改,这个键就永远找不回来了;不可变还让 hashCode + 可以算一次就缓存。② 共享:内容不会变,多个变量就能安全地指向同一份 —— Java 的字符串常量池、Python 的字符串驻留都靠它省内存。③ 多线程免锁:不会变的值,多少线程同时读都不会出事。代价只有一个:频繁修改的场景很贵,所以三种语言都配了「可变的替身」 + —— StringBuilder、Python 的 list、JavaScript 的数组。§04 我们亲手造一个。 } /> @@ -960,11 +930,7 @@ export default function StringChapter() { zh={ <> 1963 年的 ASCII 用 0–127 这 128 - 个数字,给英文字母、数字、标点和控制符各发一个编号: - 一个字符一个字节,天下太平 —— 只要你不说英语以外的语言。 - 汉字有几万个,128 个编号塞不下,于是各地各造各的表(GB2312、Big5、 - Shift-JIS……),同一串字节换个国家打开就是乱码。 - 这就是早年大量「乱码」问题的由来。 + 个数字,给英文字母、数字、标点和控制符各发一个编号:一个字符一个字节,天下太平 —— 只要你不说英语以外的语言。汉字有几万个,128 个编号塞不下,于是各地各造各的表(GB2312、Big5、Shift-JIS……),同一串字节换个国家打开就是乱码。这就是早年大量「乱码」问题的由来。 } /> @@ -986,9 +952,7 @@ export default function StringChapter() { } zh={ <> - Unicode 的解法很直接:把全世界的字符排成一张表, - 每个字符发一个唯一编号,叫码点(code point), - 写作 U+XXXX。'A' 是 U+0041,「字」是 U+5B57,🙂 是 + Unicode 的解法很直接:把全世界的字符排成一张表,每个字符发一个唯一编号,叫码点(code point),写作 U+XXXX。'A' 是 U+0041,「字」是 U+5B57,🙂 是 U+1F642 —— 目前已经发出 15 万多个号。但码点只是编号, 编号怎么存成字节是另一件事,这就是 UTF-8 / UTF-16 / UTF-32 三种存法的分工。看「字」这一个字符在各个层次上的样子: @@ -1109,9 +1073,7 @@ export default function StringChapter() { } zh={ <> - UTF-8 能统治互联网,靠的是变长这一手: - 常用的编码短,罕见的才长,而且纯英文文本按 UTF-8 存下来, - 和 1963 年的 ASCII 字节完全一样。它按码点大小分四档: + UTF-8 能统治互联网,靠的是变长这一手:常用的编码短,罕见的才长,而且纯英文文本按 UTF-8 存下来,和 1963 年的 ASCII 字节完全一样。它按码点大小分四档: } /> @@ -1218,10 +1180,7 @@ export default function StringChapter() { Java 和 JavaScript 按 UTF-16 编码单元索引, length 数的是 16 位单元; Python 3 的 str 是码点序列,len{" "} - 数的是码点。注意码点也不等于「人眼看到的一个字符」: - 带音标的字母若写成基字母加组合符号就是两个码点, - 一个家庭 emoji 更是好几个。这些差异在纯英文文本里看不出来, - 一遇到 emoji 就现形 —— 用下面的实验室亲手验证: + 数的是码点。注意码点也不等于「人眼看到的一个字符」:带音标的字母若写成基字母加组合符号就是两个码点,一个家庭 emoji 更是好几个。这些差异在纯英文文本里看不出来,一遇到 emoji 就现形 —— 用下面的实验室亲手验证: } /> @@ -1256,8 +1215,7 @@ export default function StringChapter() { <> 同一个 "👍":你看到 1 个字符;Java 和 JavaScript 的 length = 2(UTF-16 代理对);按 UTF-8 存是{" "} - 4 字节;Python 的 len 是 1(数码点)。 - 按 length 截断字符串、按字节算数据库字段宽度、逐下标遍历 emoji + 4 字节;Python 的 len 是 1(数码点)。按 length 截断字符串、按字节算数据库字段宽度、逐下标遍历 emoji 文本 —— 三个都是真实事故现场。养成一个习惯: 用到长度之前,先问清它数的是什么单位。 @@ -1295,8 +1253,7 @@ export default function StringChapter() { HTML、JSON、HTTP、Git、Linux 文件名……当今互联网绝大多数文本用 UTF-8 传输。原因有三:① 字节层面兼容 ASCII,老系统无痛过渡; ② 以英文为主的文本比 UTF-16 省将近一半空间;③ 字节流自同步 —— - 从任意位置开始都能找到下一个字符边界(首字节和后续字节的位模式不同)。 - Java/JS 选 UTF-16 是 1990 年代「每个字符 2 字节就够了」的历史遗产, + 从任意位置开始都能找到下一个字符边界(首字节和后续字节的位模式不同)。Java/JS 选 UTF-16 是 1990 年代「每个字符 2 字节就够了」的历史遗产, emoji 的流行让这个假设破产,代理对就是那个补丁。Java 9 之后内部会把纯 Latin-1 的字符串存成字节数组,但 API 仍然按 UTF-16 单元计数,你看到的行为没有变。 @@ -1452,9 +1409,7 @@ export default function StringChapter() { } zh={ <> - 全表最值得深挖的是拼接。单次 s + t 是 O(n+m), - 听着还行 —— 真正的问题是循环里的 +=。 - 假设你逐字符攒一个长度为 n 的字符串: + 全表最值得深挖的是拼接。单次 s + t 是 O(n+m),听着还行 —— 真正的问题是循环里的 +=。假设你逐字符攒一个长度为 n 的字符串: } /> @@ -1500,8 +1455,7 @@ export default function StringChapter() { } zh={ <> - 解药是给字符串找一个可变的替身:先在可变容器里攒, - 最后一次性成串 —— 总量回到 O(n)。亲眼看两种策略赛跑: + 解药是给字符串找一个可变的替身:先在可变容器里攒,最后一次性成串 —— 总量回到 O(n)。亲眼看两种策略赛跑: } /> @@ -1548,16 +1502,11 @@ export default function StringChapter() { —— 因为字符串都没法原地续写。Java:Java 8 及以前,编译器把{" "} s += x 展开成「每一圈都 new 一个{" "} StringBuilder 再 toString()」; - Java 9 起改用 invokedynamic(StringConcatFactory)。 - 无论哪种,每一圈都会生成一个新字符串,总量仍是 O(n²), - 必须自己在循环外维护一个 builder。Python: - CPython 有一个优化:当字符串只剩一个引用时可以原地扩容; - 但语言规范不保证,只要多出第二个引用就失效 —— + Java 9 起改用 invokedynamic(StringConcatFactory)。无论哪种,每一圈都会生成一个新字符串,总量仍是 O(n²),必须自己在循环外维护一个 builder。Python: + CPython 有一个优化:当字符串只剩一个引用时可以原地扩容;但语言规范不保证,只要多出第二个引用就失效 —— 惯用法是先把各段收集到 list 里,最后调用一次 "".join()。 JavaScript:V8 把 a + b{" "} - 先表示成一个指向两半的小节点,真正读取时才展平, - 所以循环 += 在实践中常常快于 n²,但展平的成本和内存峰值仍然要付, - 而且没有任何引擎承诺这件事。结论在三种语言里一致: + 先表示成一个指向两半的小节点,真正读取时才展平,所以循环 += 在实践中常常快于 n²,但展平的成本和内存峰值仍然要付,而且没有任何引擎承诺这件事。结论在三种语言里一致: 显式使用可变容器,不要依赖引擎优化。 } @@ -1598,9 +1547,7 @@ export default function StringChapter() { <> 轮子一:字符串构建器。 原理和上一章的动态数组一模一样:内部一个可变字符数组, - append 往空位写(均摊 O(1)),满了就容量翻倍搬一次家, - 只有最后 build 时才一次性拷贝成不可变字符串。 - 看懂它,就看懂了「为什么攒着最后一次成串是 O(n)」: + append 往空位写(均摊 O(1)),满了就容量翻倍搬一次家,只有最后 build 时才一次性拷贝成不可变字符串。看懂它,就看懂了「为什么攒着最后一次成串是 O(n)」: } /> @@ -1678,8 +1625,7 @@ class MyStringBuilder { zh: ( <> JDK 的 StringBuilder 就是这个思路(扩容策略是 - ×2+2)。n 次 append 的总工作量 = n 次写入 + 扩容搬家的拷贝, - 而搬家的拷贝加起来不到 2n,所以整体 O(n),对比循环 += 的 O(n²)。 + ×2+2)。n 次 append 的总工作量 = n 次写入 + 扩容搬家的拷贝,而搬家的拷贝加起来不到 2n,所以整体 O(n),对比循环 += 的 O(n²)。 ), }, @@ -1791,8 +1737,7 @@ console.log(sb.build()); // "hello"`, ), zh: ( <> - V8 让小规模的 += 也不慢,但「攒数组 + join」 - 在任何引擎、任何规模下都稳定 O(n) —— 写库代码时选它。 + V8 让小规模的 += 也不慢,但「攒数组 + join」在任何引擎、任何规模下都稳定 O(n) —— 写库代码时选它。 ), }, @@ -1814,8 +1759,7 @@ console.log(sb.build()); // "hello"`, zh={ <> 轮子二:朴素子串查找(indexOf)。 - 在长度 n 的文本里找长度 m 的模式串:挨个起点试, - 失败就把起点右移一格、从头再比。思路直白,最坏 O(n·m): + 在长度 n 的文本里找长度 m 的模式串:挨个起点试,失败就把起点右移一格、从头再比。思路直白,最坏 O(n·m): } /> @@ -1943,12 +1887,9 @@ console.log(sb.build()); // "hello"`, } zh={ <> - 思想课:KMP —— 失败也是情报。朴素法慢在哪? - 看一次典型的失败:在文本 ABABABC 里找{" "} - ABABC,前 4 个字符 ABAB 都对上了, - 第 5 个失配。朴素法的反应是:起点右移一格, - 把刚才的记忆全部清零,从头再比。 - 但我们明明已经知道文本那 4 个字符就是 ABAB —— + 思想课:KMP —— 失败也是情报。朴素法慢在哪?看一次典型的失败:在文本 ABABABC 里找{" "} + ABABC,前 4 个字符 ABAB 都对上了,第 5 个失配。朴素法的反应是:起点右移一格, + 把刚才的记忆全部清零,从头再比。但我们明明已经知道文本那 4 个字符就是 ABAB —— 这份情报被白白扔掉了。 } @@ -2008,10 +1949,8 @@ KMP: "ABAB" 的开头和结尾最长重叠是 "AB"(长度 2) } zh={ <> - KMP(Knuth–Morris–Pratt)的全部秘密就在上图那一步「滑」:失配时, - 已匹配段 ABAB 的结尾和模式串的 - 开头有一段最长重叠 AB。 - 把模式滑到重叠对齐的位置,重叠部分不用重比 —— + KMP(Knuth–Morris–Pratt)的全部秘密就在上图那一步「滑」:失配时,已匹配段 ABAB 的结尾和模式串的 + 开头有一段最长重叠 AB。把模式滑到重叠对齐的位置,重叠部分不用重比 —— 它们刚刚才比过,一定相等 —— 直接从重叠长度处继续。于是文本指针 永远不回退,整体 O(n+m)。 @@ -2049,8 +1988,7 @@ KMP: "ABAB" 的开头和结尾最长重叠是 "AB"(长度 2) 的最长真前缀的长度,且这个真前缀同时是{" "} pattern[0..i] 的后缀 - 。「真」= 不能是 pattern[0..i] 自己, - 否则答案永远是 i+1。以 ABABC 为例: + 。「真」= 不能是 pattern[0..i] 自己,否则答案永远是 i+1。以 ABABC 为例: } /> @@ -2186,11 +2124,8 @@ KMP: "ABAB" 的开头和结尾最长重叠是 "AB"(长度 2) 在 j 处失配,就让 j 跳到 next[j−1] 再试一次;只有 j 已经是 0 时,文本指针才前进 - 。为什么这样不会漏解?因为 next 给的是最长重叠, - 而所有更短的对齐方式都由「再跳一次」覆盖 —— - 跳一次不行就再跳,沿着链一路退到 0。完整实现如下, - 预处理 next 的代码和匹配的代码长得几乎一样, - 因为预处理本质就是「模式串自己和自己做匹配」: + 。为什么这样不会漏解?因为 next 给的是最长重叠,而所有更短的对齐方式都由「再跳一次」覆盖 —— + 跳一次不行就再跳,沿着链一路退到 0。完整实现如下,预处理 next 的代码和匹配的代码长得几乎一样,因为预处理本质就是「模式串自己和自己做匹配」: } /> @@ -2402,15 +2337,8 @@ KMP: "ABAB" 的开头和结尾最长重叠是 "AB"(长度 2) } zh={ <> - 预处理 O(m) + 匹配 O(n) = O(n+m),额外空间 O(m)。 - 内层的 while 让匹配循环看起来像 O(n·m), - 但换个角度:别数循环,数 j 的变化。外层每转一圈,j 最多加 1, - 所以整趟下来 j 增加的次数不超过 n。内层每转一圈,j 被设成{" "} - next[j−1],而它严格小于 j,所以 j 至少减 1, - 而且 j 永远不小于 0。一个总共只上升 n 次、又不能低于 0 的量, - 总共最多被下降 n 次 —— 因此所有内层循环加起来最多跑 n 次, - 匹配就是 O(n)。预处理里把 j 换成 k、n 换成 m,论证完全一样。 - 面试很少让你默写 KMP,但常考三连问:暴力浪费了什么情报 + 预处理 O(m) + 匹配 O(n) = O(n+m),额外空间 O(m)。内层的 while 让匹配循环看起来像 O(n·m),但换个角度:别数循环,数 j 的变化。外层每转一圈,j 最多加 1,所以整趟下来 j 增加的次数不超过 n。内层每转一圈,j 被设成{" "} + next[j−1],而它严格小于 j,所以 j 至少减 1,而且 j 永远不小于 0。一个总共只上升 n 次、又不能低于 0 的量,总共最多被下降 n 次 —— 因此所有内层循环加起来最多跑 n 次,匹配就是 O(n)。预处理里把 j 换成 k、n 换成 m,论证完全一样。面试很少让你默写 KMP,但常考三连问:暴力浪费了什么情报 (已匹配段的内容是已知的)、next 数组是什么 (每个前缀的最长真前缀且同时是后缀的长度)、 为什么主串指针不用回退(滑动后重叠段已知相等)。 @@ -2517,8 +2445,7 @@ String s = sb.toString(); // "012" zh: ( <> 易错点:== 比引用,equals{" "} - 比内容。两个字面量因为常量池碰巧 == 为 true, - 这正是最容易骗新手的地方。面试追问:StringBuilder(快,不加锁) + 比内容。两个字面量因为常量池碰巧 == 为 true,这正是最容易骗新手的地方。面试追问:StringBuilder(快,不加锁) vs StringBuffer(线程安全,慢),单线程一律前者。 ), @@ -2574,9 +2501,7 @@ s = "".join(parts) # "012":整体 O(n)`, ), zh: ( <> - 易错点:s[0] 返回的是 str 不是数字, - 想拿码点要用 ord();str 是码点序列, - 所以 len("👍") = 1 —— + 易错点:s[0] 返回的是 str 不是数字,想拿码点要用 ord();str 是码点序列,所以 len("👍") = 1 —— 三种语言里唯一数成 1 的。 ), @@ -2636,8 +2561,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, 易错点:处理可能含 emoji 的文本,遍历用{" "} for...of、计数用 Array.from(s).length 、取码点用 codePointAt。charAt、 - length、普通下标都是按 UTF-16 单元算的, - 会把代理对劈成两半。 + length、普通下标都是按 UTF-16 单元算的,会把代理对劈成两半。 ), }, @@ -2853,11 +2777,9 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, * JavaScript 的{" "} s.replace("a", "b"){" "} 传字符串时只替换第一处 —— 想全换用 replaceAll - ,或者正则加 g 标志,这是从其他语言迁移过来最容易踩的一脚。 - † O(n·m) 是朴素扫描的最坏情况,Java 的 indexOf{" "} + ,或者正则加 g 标志,这是从其他语言迁移过来最容易踩的一脚。† O(n·m) 是朴素扫描的最坏情况,Java 的 indexOf{" "} 就是这么做的;CPython 的 str.find{" "} - 用了更聪明的算法,最坏 O(n+m),JavaScript 各引擎实现不一。 - 另外,所有「返回新串」的操作,空间也都是 O(n)。 + 用了更聪明的算法,最坏 O(n+m),JavaScript 各引擎实现不一。另外,所有「返回新串」的操作,空间也都是 O(n)。 } /> @@ -2896,8 +2818,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, zh={ <> 「内容相同的字符串共享同一份内存」有个学名: - 字符串驻留(string interning)。Java 把编译期字面量放进常量池, - 运行期可以手动 s.intern();Python + 字符串驻留(string interning)。Java 把编译期字面量放进常量池,运行期可以手动 s.intern();Python 会自动驻留标识符样式的短字符串,所以{" "} "abc" is "abc"{" "} 有时为 True —— 那是实现细节,不是承诺: @@ -2905,11 +2826,9 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, 判相等用 ==,is{" "} 只用来问「是不是同一个对象」 - 。JavaScript 引擎内部也做同样的共享,但你永远看不见, - 因为 === 对字符串比的是值。所以三种语言的差别正在这里: + 。JavaScript 引擎内部也做同样的共享,但你永远看不见,因为 === 对字符串比的是值。所以三种语言的差别正在这里: Java 必须用 equals,Python 要用 =={" "} - 而不是 is,JavaScript 没有对应的陷阱。 - 这一切成立的前提正是 §01 的不可变 —— + 而不是 is,JavaScript 没有对应的陷阱。这一切成立的前提正是 §01 的不可变 —— 内容会变的对象,谁敢共享? } @@ -2955,11 +2874,9 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, } zh={ <> - 字符串的套路和数组高度同源(两者的结构本来就很接近),但有三种套路属于这一章。 - 拿到题先对信号:回文 / 反转 → 对撞指针; + 字符串的套路和数组高度同源(两者的结构本来就很接近),但有三种套路属于这一章。拿到题先对信号:回文 / 反转 → 对撞指针; 连续子串的最值 → 滑动窗口; - 异位词 / 字符统计 → 计数数组。 - 这三种套路能解决本章题单的大部分题目: + 异位词 / 字符统计 → 计数数组。这三种套路能解决本章题单的大部分题目: } /> @@ -2986,9 +2903,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, } zh={ <> - 两端出发,每步比较一对字符。不变量是:区间之外的部分都已核对完毕。 - 回文验证、原地反转的标配;「中心扩展」是它的反向版: - 从中间向两边推。见 LC 125、344、5。 + 两端出发,每步比较一对字符。不变量是:区间之外的部分都已核对完毕。回文验证、原地反转的标配;「中心扩展」是它的反向版:从中间向两边推。见 LC 125、344、5。 } /> @@ -3013,8 +2928,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, } zh={ <> - 「答案是连续子串 + 窗口内条件可增量维护」= 滑窗。 - 窗口里养一个 Set 或计数器,右端吃、左端吐。见 LC 3、438、76。 + 「答案是连续子串 + 窗口内条件可增量维护」= 滑窗。窗口里养一个 Set 或计数器,右端吃、左端吐。见 LC 3、438、76。 } /> @@ -3039,9 +2953,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, } zh={ <> - 字符集有限且已知时(26 个小写字母 / 128 个 ASCII 码), - 用定长 int 数组代替哈希表:更快、更省、代码更短。 - 见 LC 242、438、383。输入是任意 Unicode 时,还是要换回哈希表。 + 字符集有限且已知时(26 个小写字母 / 128 个 ASCII 码),用定长 int 数组代替哈希表:更快、更省、代码更短。见 LC 242、438、383。输入是任意 Unicode 时,还是要换回哈希表。 } /> @@ -3226,8 +3138,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, zh={ <> 时间 O(n)(每个字符最多被 l 或 r 看一次),额外空间{" "} - O(1)。对比「过滤 + 反转」解法的 O(n) 额外空间, - 这就是原地双指针的意义。追问一:「如果允许 + O(1)。对比「过滤 + 反转」解法的 O(n) 额外空间,这就是原地双指针的意义。追问一:「如果允许 删除至多一个字符再判回文?」(LC 680:失配时分两路试 l+1 和 r−1,各自继续对撞)。追问二:「为什么内层 while 也要带{" "} l < r?」(全是标点的串会让指针越界 —— @@ -3277,8 +3188,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, 题意:求最长的、不含重复字符的连续子串长度。 暴力:枚举所有子串的起终点、逐个检查有无重复,O(n³) (加 Set 可优化到 O(n²))。正解: - 滑窗的两大信号全亮 —— 连续,且条件可增量维护。关键洞察: - 窗口 [l..r] 无重复时,撞上重复字符只需要从左边吐, + 滑窗的两大信号全亮 —— 连续,且条件可增量维护。关键洞察:窗口 [l..r] 无重复时,撞上重复字符只需要从左边吐, l 绝不需要回头 —— 更靠左的起点仍然包含刚被吐掉的那个重复字符: @@ -3427,12 +3337,8 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, <> 循环不变量:每一步结束时,s[l..r] 里没有重复字符。l 和 r 各自最多向前走 n 步,每个字符进出 Set 各一次,所以时间{" "} - O(n),空间 O(min(n, 字符集大小))。追问一: - 「怎么再快一点?」用哈希表记每个字符最后出现的位置, - 撞上重复时 l 直接跳过去,省掉内层循环。追问二: - 「输入含 emoji 怎么办?」§02 学的立刻用上:JavaScript 里要先{" "} - Array.from(s) 按码点切分, - 否则代理对会被劈成两个不是字符的半块。 + O(n),空间 O(min(n, 字符集大小))。追问一:「怎么再快一点?」用哈希表记每个字符最后出现的位置,撞上重复时 l 直接跳过去,省掉内层循环。追问二:「输入含 emoji 怎么办?」§02 学的立刻用上:JavaScript 里要先{" "} + Array.from(s) 按码点切分,否则代理对会被劈成两个不是字符的半块。 } /> @@ -3483,10 +3389,8 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, 题意:找出最长的回文连续子串 (注意是寻找,不是判断)。暴力:枚举所有 O(n²) 个子串、每个花 O(n) 验证 → O(n³)。正解:换个枚举对象 —— - 别枚举子串,枚举回文的中心。回文有个好性质: - 两端各去掉一个字符仍是回文;反过来说, - 从中心一层层向外扩,扩到两侧不等为止, - 就是该中心的最长回文。中心只有 2n−1 个:n 个字符加 n−1 个空隙。 + 别枚举子串,枚举回文的中心。回文有个好性质:两端各去掉一个字符仍是回文;反过来说, + 从中心一层层向外扩,扩到两侧不等为止,就是该中心的最长回文。中心只有 2n−1 个:n 个字符加 n−1 个空隙。 } /> @@ -3669,10 +3573,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, 已经是回文,所以只要 s[l] = s[r],s[l..r] 就也是回文。2n−1 个中心 × 每个最多扩 O(n) 层 → 时间 O(n²),额外空间{" "} O(1)。追问一:「有没有更快的?」有, - Manacher 算法 O(n):在字符间插分隔符统一奇偶, - 再复用已知回文的对称信息;实现复杂,面试说出名字和思想通常就够了。 - 追问二:「动态规划行不行?」行,dp[i][j] 表示 s[i..j] 是否回文, - 同样 O(n²) 时间,但要 O(n²) 空间 —— 中心扩展在空间上明显更优。 + Manacher 算法 O(n):在字符间插分隔符统一奇偶,再复用已知回文的对称信息;实现复杂,面试说出名字和思想通常就够了。追问二:「动态规划行不行?」行,dp[i][j] 表示 s[i..j] 是否回文,同样 O(n²) 时间,但要 O(n²) 空间 —— 中心扩展在空间上明显更优。 } /> @@ -3733,8 +3634,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, ), zh: ( <> - 字符串 = 不可变的字符数组:读 O(1),任何「修改」都是重抄。 - 拼接 O(n+m),循环里的 += 在 Java、Python、JavaScript 里都是 + 字符串 = 不可变的字符数组:读 O(1),任何「修改」都是重抄。拼接 O(n+m),循环里的 += 在 Java、Python、JavaScript 里都是 O(n²) —— 用 StringBuilder、list 或数组攒着,最后一次性成串。 ), @@ -3771,8 +3671,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, zh: ( <> 子串查找:朴素 O(n·m)。KMP 用前缀函数 - (next[i] = pattern[0..i] 的最长真前缀且同时是后缀的长度), - 让主串指针永不回退 → O(n+m)。记住三问:暴力浪费了什么、next + (next[i] = pattern[0..i] 的最长真前缀且同时是后缀的长度),让主串指针永不回退 → O(n+m)。记住三问:暴力浪费了什么、next 是什么、为什么不用回退。 ), @@ -3810,8 +3709,7 @@ for (const ch of "a👍") console.log(ch); // 'a'、'👍':按码点遍历`, <> 语言差异速查:Java == 比引用、equals 比内容;Python 没有 char(长度 1 的 str),拼接用 join,而且 is 不是{" "} - ==;JavaScript 的 === 对字符串比的是值, - 但 charAt 会劈开代理对,处理 emoji 用{" "} + ==;JavaScript 的 === 对字符串比的是值,但 charAt 会劈开代理对,处理 emoji 用{" "} for...of / codePointAt。 ), diff --git a/app/string/viz.tsx b/app/string/viz.tsx index 1378169..f2b424e 100644 --- a/app/string/viz.tsx +++ b/app/string/viz.tsx @@ -227,8 +227,7 @@ export function EncodeLab() { } zh={ <> - 同一个字符,三个身份:你看到的字形、Unicode 给它的编号(码点)、 - 以及硬盘里存下的字节。试试输入一个 emoji,看看会发生什么。 + 同一个字符,三个身份:你看到的字形、Unicode 给它的编号(码点)、以及硬盘里存下的字节。试试输入一个 emoji,看看会发生什么。 } /> @@ -353,8 +352,7 @@ export function ConcatLab() { } zh={ <> - 两种做法完成同一件事:往字符串尾部追加 {N} 个字符。 - 追加次数完全一样,比的是背后总共拷贝了多少字符。 + 两种做法完成同一件事:往字符串尾部追加 {N} 个字符。追加次数完全一样,比的是背后总共拷贝了多少字符。 } /> @@ -372,10 +370,8 @@ export function ConcatLab() { } zh={ <> - 终点:+= 拷贝了 {nv} 个字符(≈ n²/2), - 可变缓冲区只拷贝了 {bv} 个(≈ 2n,含扩容搬家)—— - 相差 {Math.round(nv / bv)} 倍。n 再大十倍,差距就是百倍: - 这就是 O(n²) 与 O(n) 的区别。 + 终点:+= 拷贝了 {nv} 个字符(≈ n²/2),可变缓冲区只拷贝了 {bv} 个(≈ 2n,含扩容搬家)—— + 相差 {Math.round(nv / bv)} 倍。n 再大十倍,差距就是百倍:这就是 O(n²) 与 O(n) 的区别。 } /> @@ -396,8 +392,7 @@ export function ConcatLab() { zh={ <> 第 {step} 次追加:+= 要新建长度 {step}{" "} - 的串并重抄全部旧字符(本次拷贝 {step} 个); - 可变缓冲区只往数组空位写 1 个 + 的串并重抄全部旧字符(本次拷贝 {step} 个);可变缓冲区只往数组空位写 1 个 {builder[step] - builder[step - 1] > 1 ? ",这一步刚好装满,顺带扩容搬家一次" : ""} diff --git a/app/trie/page.tsx b/app/trie/page.tsx index dee7f8b..cc7b93a 100644 --- a/app/trie/page.tsx +++ b/app/trie/page.tsx @@ -67,10 +67,8 @@ const A208_FRAMES: TStepFrame[] = [ } zh={ <> - insert("app"):从 root 出发。a、p、p 都还不存在, - 于是每个字母新建一个节点连上边。走到最后一个 p,把它的{" "} - isEnd = true —— 只有这个标记能说明「app 是一个单词」。 - 图中 l、e 两个节点是淡的,它们在下一步才出现。 + insert("app"):从 root 出发。a、p、p 都还不存在,于是每个字母新建一个节点连上边。走到最后一个 p,把它的{" "} + isEnd = true —— 只有这个标记能说明「app 是一个单词」。图中 l、e 两个节点是淡的,它们在下一步才出现。 } /> @@ -91,8 +89,7 @@ const A208_FRAMES: TStepFrame[] = [ zh={ <> insert("apple"):前三个字母 a-p-p{" "} - 已经存在,直接沿用 —— 相同的开头只存一份。只新建 l、e 两个节点, - 末节点 e 标 isEnd = true。 + 已经存在,直接沿用 —— 相同的开头只存一份。只新建 l、e 两个节点,末节点 e 标 isEnd = true。 } /> @@ -138,8 +135,7 @@ const A208_FRAMES: TStepFrame[] = [ zh={ <> search("ap"):路径走得通,但停下的节点{" "} - isEnd = false —— ap 只是别的词的开头,不是被插入过的单词。 - 所以 search 返回 false,而 startsWith("ap") 返回{" "} + isEnd = false —— ap 只是别的词的开头,不是被插入过的单词。所以 search 返回 false,而 startsWith("ap") 返回{" "} true。一个标记之差,分开了「精确匹配」和「前缀匹配」。 } @@ -182,8 +178,7 @@ const A208_FRAMES: TStepFrame[] = [ zh={ <> search("banana"):root 的 children 里没有 - 'b' 这条边,第一个字母就断路,立即返回 false, - 只花了 1 步。树里存一百万个词,这次查询也还是 1 步。 + 'b' 这条边,第一个字母就断路,立即返回 false,只花了 1 步。树里存一百万个词,这次查询也还是 1 步。 } /> @@ -233,8 +228,7 @@ const A211_FRAMES: TStepFrame[] = [ zh={ <> search(".ad"):第 1 个字符是通配符{" "} - '.',能匹配任意字母。这一步不知道该走哪条边, - 于是 root 底下的 b、d、m 三条边都要试 —— DFS 在这里第一次分叉。 + '.',能匹配任意字母。这一步不知道该走哪条边,于是 root 底下的 b、d、m 三条边都要试 —— DFS 在这里第一次分叉。 } /> @@ -255,8 +249,7 @@ const A211_FRAMES: TStepFrame[] = [ zh={ <> 第 2 个字符是普通的 'a':三条分支各自沿自己的 a - 边下沉一层,分别到达 bad、dad、mad 路径上的 a 节点。 - 普通字符不分叉,只走对应的那一条边。 + 边下沉一层,分别到达 bad、dad、mad 路径上的 a 节点。普通字符不分叉,只走对应的那一条边。 } /> @@ -280,10 +273,7 @@ const A211_FRAMES: TStepFrame[] = [ zh={ <> 第 3 个字符 'd':三条路都停在 isEnd = true{" "} - 的节点上,所以 ".ad" 匹配 bad、dad、mad。 - 真实的 search 只要第一条分支成功就返回 true,这里把三条都画出来, - 是为了看清通配符能碰到哪些词。'.' 的代价, - 就是当前节点的每个 child 都得试一遍。 + 的节点上,所以 ".ad" 匹配 bad、dad、mad。真实的 search 只要第一条分支成功就返回 true,这里把三条都画出来,是为了看清通配符能碰到哪些词。'.' 的代价,就是当前节点的每个 child 都得试一遍。 } /> @@ -334,9 +324,7 @@ export default function TrieChapter() { ), zh: ( <> - Trie 把一组单词存成一棵树:从根走下来的路径拼出单词, - 开头相同的词因此共用同一段节点,每一段相同的开头只存一份。 - 它花掉的是内存,换来的是哈希表答不了的一个问题: + Trie 把一组单词存成一棵树:从根走下来的路径拼出单词,开头相同的词因此共用同一段节点,每一段相同的开头只存一份。它花掉的是内存,换来的是哈希表答不了的一个问题: 哪些已存的词以这段开头? ), @@ -397,13 +385,10 @@ export default function TrieChapter() {

    第 6 章的哈希表是为精确查找而生的:判断{" "} - cat 在不在词典里,它把整个单词算成一个数, - 直接跳到那个槽位。就「已存词数」而言,这是平均 O(1) —— - 尽管它仍要读完整个单词才能算出哈希。可正是这次计算, - 让前缀查询没了指望:cat 和 car{" "} + cat 在不在词典里,它把整个单词算成一个数,直接跳到那个槽位。就「已存词数」而言,这是平均 O(1) —— + 尽管它仍要读完整个单词才能算出哈希。可正是这次计算,让前缀查询没了指望:cat 和 car{" "} 算出的哈希值毫不相干,表里 - 没有任何东西记得它俩共享 ca 这个开头。 - 想列出以 ca 开头的词,它只能读遍全部 N 个词、逐个比对开头 —— + 没有任何东西记得它俩共享 ca 这个开头。想列出以 ca 开头的词,它只能读遍全部 N 个词、逐个比对开头 —— O(N·L)。词典越大越慢。

    @@ -454,11 +439,7 @@ export default function TrieChapter() { } zh={

    - 主意很朴素:把 cat、car、card 三个词竖着写, - 前两个字母 ca 一模一样 —— 那就只存一次, - 在 a 之后再分叉。一万个单词这么存下来,就长成了一棵树。 - 从根走到任意节点,一路读到的字符就是一个前缀; - 想找所有以 ca 开头的词,走到 ca 那个节点, + 主意很朴素:把 cat、car、card 三个词竖着写,前两个字母 ca 一模一样 —— 那就只存一次,在 a 之后再分叉。一万个单词这么存下来,就长成了一棵树。从根走到任意节点,一路读到的字符就是一个前缀;想找所有以 ca 开头的词,走到 ca 那个节点, 它下面整棵子树就是答案,别的词一眼都不用看。

    } @@ -482,8 +463,7 @@ export default function TrieChapter() { zh: ( <> 由 car、card、cat、dog 建成的 Trie。 - car / card / cat 共享 c-a 这个开头(只存一份), - 到 a 之后才分叉;dog 开头不同,自成一支。绿色双圈 = + car / card / cat 共享 c-a 这个开头(只存一份),到 a 之后才分叉;dog 开头不同,自成一支。绿色双圈 = 有单词在此结束(isEnd)。注意 car 结束的那个 r 节点还带着孩子(通向 card)—— §02 会用到这个细节。 @@ -513,8 +493,7 @@ export default function TrieChapter() { zh={

    每条边上贴着一个字符,从根读到任意节点, - 拼出来就是一个前缀。前缀查询在别的结构里很别扭, - 在 Trie 里就是「顺着路往下走」。 + 拼出来就是一个前缀。前缀查询在别的结构里很别扭,在 Trie 里就是「顺着路往下走」。

    } /> @@ -537,8 +516,7 @@ export default function TrieChapter() { } zh={

    - 开头相同的词共用同一批节点。词与词在开头重叠得越多(自然语言单词、 - URL、文件路径),共享的节点就越多。它的另一个名字 + 开头相同的词共用同一批节点。词与词在开头重叠得越多(自然语言单词、URL、文件路径),共享的节点就越多。它的另一个名字 「字典树 / 前缀树」就是这么来的。

    } @@ -564,9 +542,7 @@ export default function TrieChapter() { } zh={

    - 插入或查询一个词的代价 = 这个词的长度 L。 - 树里已经有 10 个词还是 1000 万个词,不出现在这个代价里。 - §03 讲清楚为什么。 + 插入或查询一个词的代价 = 这个词的长度 L。树里已经有 10 个词还是 1000 万个词,不出现在这个代价里。§03 讲清楚为什么。

    } /> @@ -595,9 +571,7 @@ export default function TrieChapter() { zh={

    Trie 一词由 Edward Fredkin 在 1960 年提出,取自单词 retrie - val(检索)的中间四个字母。于是有点尴尬:按词源应该读作 - “tree”,可 tree 已经是另一种结构的名字了,所以多数人读它作 - “try”。两种读法你都会听到,不必纠结;它的中文名是「前缀树 / 字典树」。 + val(检索)的中间四个字母。于是有点尴尬:按词源应该读作“tree”,可 tree 已经是另一种结构的名字了,所以多数人读它作“try”。两种读法你都会听到,不必纠结;它的中文名是「前缀树 / 字典树」。

    } /> @@ -650,12 +624,8 @@ export default function TrieChapter() { } zh={ <> - children(孩子表):从「字符」到「子节点」的映射。 - 二叉树固定两个孩子,Trie 的孩子数由字符集决定: - 只处理小写英文字母就是最多 26 个,可以用长度 26 的数组 - TrieNode[26](下标 = 字母 − 'a'), - 也可以用哈希表 Map<Character, Node>。 - 两者的取舍见 §03。 + children(孩子表):从「字符」到「子节点」的映射。二叉树固定两个孩子,Trie 的孩子数由字符集决定:只处理小写英文字母就是最多 26 个,可以用长度 26 的数组 + TrieNode[26](下标 = 字母 − 'a'),也可以用哈希表 Map<Character, Node>。两者的取舍见 §03。 } /> @@ -692,11 +662,7 @@ export default function TrieChapter() { } zh={

    - 有一点容易看漏:字符并不存在节点里, - 它贴在边上 —— 等价地说,一个节点是由「父亲用哪个字符找到它」来标识的。 - 所以拼出 key 的是路径,不是节点。 - 根节点不代表任何字符,它是所有词共同的起点,一个空前缀。 - 从根往下走 k 条边,读到的 k 个字符,就是一个长度为 k 的前缀。 + 有一点容易看漏:字符并不存在节点里,它贴在边上 —— 等价地说,一个节点是由「父亲用哪个字符找到它」来标识的。所以拼出 key 的是路径,不是节点。根节点不代表任何字符,它是所有词共同的起点,一个空前缀。从根往下走 k 条边,读到的 k 个字符,就是一个长度为 k 的前缀。

    } /> @@ -731,9 +697,7 @@ export default function TrieChapter() { (继续接 t-l-e)。现在问:cat 是一个词吗?没有 isEnd 就无从回答。「这个节点有没有孩子」帮不上忙 —— 它确实有孩子(为了 cattle),可 cat 确确实实是个词;反过来, - catt 也走得通、也有孩子,却不是词。 - 节点本身并不存词,所以这个答案没有别的地方可放, - 只能是节点上的一个标记 isEnd = true:有词在此结束。 + catt 也走得通、也有孩子,却不是词。节点本身并不存词,所以这个答案没有别的地方可放,只能是节点上的一个标记 isEnd = true:有词在此结束。

    } /> @@ -754,9 +718,7 @@ export default function TrieChapter() { ), zh: ( <> - cat 与 cattle 共享 c-a-t。高亮的 t 节点 isEnd = true, - 说明 cat 是一个已存的词,而它同时还有孩子继续通向 cattle。 - 没有这个标记,就分不清「一个已存的词」和「只是路过的节点」。 + cat 与 cattle 共享 c-a-t。高亮的 t 节点 isEnd = true,说明 cat 是一个已存的词,而它同时还有孩子继续通向 cattle。没有这个标记,就分不清「一个已存的词」和「只是路过的节点」。 ), }} @@ -776,8 +738,7 @@ export default function TrieChapter() { } zh={

    - 下面这个实验室里已经住着 5 个词。插入新词,看路径哪一段被复用; - 查询单词或前缀,看路径怎么逐节点点亮。有三种结局值得亲手制造一遍: + 下面这个实验室里已经住着 5 个词。插入新词,看路径哪一段被复用;查询单词或前缀,看路径怎么逐节点点亮。有三种结局值得亲手制造一遍: 命中一个已存的词、是前缀但不是词、 中途断路。

    @@ -810,15 +771,11 @@ export default function TrieChapter() { } zh={

    - Trie 藏在你每天用的东西里:搜索引擎和输入法的自动补全、 - 路由器转发 IP 包时的最长前缀匹配、拼写检查。 - 数据库和文件系统里用的多是它的压缩形态 —— 基数树 Radix Tree + Trie 藏在你每天用的东西里:搜索引擎和输入法的自动补全、路由器转发 IP 包时的最长前缀匹配、拼写检查。数据库和文件系统里用的多是它的压缩形态 —— 基数树 Radix Tree (也叫 Patricia trie): - 把「只有一个孩子的节点链」合并成一条边,一条边上带多个字符, - 省掉大部分空转节点。代价是插入更复杂 —— + 把「只有一个孩子的节点链」合并成一条边,一条边上带多个字符,省掉大部分空转节点。代价是插入更复杂 —— 加一个词可能需要把已有的边一分为二。Redis 用基数树存 stream ID, - Linux 内核也曾用它做页缓存索引。朴素 Trie 想明白了, - 这些不过是它的压缩版。 + Linux 内核也曾用它做页缓存索引。朴素 Trie 想明白了,这些不过是它的压缩版。

    } /> @@ -859,8 +816,7 @@ export default function TrieChapter() { zh={

    Trie 的三个操作骨架完全一样: - 从根出发,拿着输入串的字符一个一个往下走。 - 区别只在两处:路上缺边怎么办,以及到达终点后检查什么。 + 从根出发,拿着输入串的字符一个一个往下走。区别只在两处:路上缺边怎么办,以及到达终点后检查什么。

    } /> @@ -1048,12 +1004,9 @@ export default function TrieChapter() { } zh={

    - 每一步只是一次 child 查找(数组下标,或平均 O(1) 的哈希表查找)。 - 走多少步?L 步 —— 你传进来的字符串有多长。 - 词典里是 10 个词还是 5000 万个词,查 apple{" "} + 每一步只是一次 child 查找(数组下标,或平均 O(1) 的哈希表查找)。走多少步?L 步 —— 你传进来的字符串有多长。词典里是 10 个词还是 5000 万个词,查 apple{" "} 永远是 5 步。哈希表做一次精确查找也是 O(L)(它要读完整个 key - 才能算哈希),所以 Trie 在精确匹配上并不更快。 - Trie 多出来的是前缀查询,选它就是为了这个。 + 才能算哈希),所以 Trie 在精确匹配上并不更快。Trie 多出来的是前缀查询,选它就是为了这个。

    } /> @@ -1077,9 +1030,7 @@ export default function TrieChapter() { } zh={

    - 这份速度是拿内存换的:每条路径上的每个字符都要一个节点, - 而每个节点都得带一张 children 表。这张表怎么存, - 是 Trie 唯一真正的设计抉择: + 这份速度是拿内存换的:每条路径上的每个字符都要一个节点,而每个节点都得带一张 children 表。这张表怎么存,是 Trie 唯一真正的设计抉择:

    } /> @@ -1107,12 +1058,9 @@ export default function TrieChapter() { } zh={

    - 下标 = 字符 − 'a',一次数组读取就拿到孩子, - 常数最小。代价有两个: - 每个节点无论用不用,都占着 26 个指针, - 词稀疏时浪费惊人;而且 26 只覆盖小写 ASCII 字母 —— - 输入里有数字、大写字母或非 ASCII 文本,就得换一张表。 - 适合明确「只有小写字母」的做题场景。 + 下标 = 字符 − 'a',一次数组读取就拿到孩子,常数最小。代价有两个: + 每个节点无论用不用,都占着 26 个指针,词稀疏时浪费惊人;而且 26 只覆盖小写 ASCII 字母 —— + 输入里有数字、大写字母或非 ASCII 文本,就得换一张表。适合明确「只有小写字母」的做题场景。

    } /> @@ -1136,9 +1084,7 @@ export default function TrieChapter() { } zh={

    - 有几个孩子就存几个,稀疏数据省下大量内存; - 而且任何字符都能当键:大写、数字、中文、任意非 ASCII 文本都行。 - 代价是单次查找的常数比数组下标略大。面对真实输入,它是更稳的默认选择。 + 有几个孩子就存几个,稀疏数据省下大量内存;而且任何字符都能当键:大写、数字、中文、任意非 ASCII 文本都行。代价是单次查找的常数比数组下标略大。面对真实输入,它是更稳的默认选择。

    } /> @@ -1325,9 +1271,7 @@ export default function TrieChapter() { zh={

    下面这段代码, - 逐字就是 LeetCode 208「实现 Trie」的满分答案。 - 三个方法共用一个私有小工具 find:沿路径走, - 缺边就返回空。search 和 startsWith{" "} + 逐字就是 LeetCode 208「实现 Trie」的满分答案。三个方法共用一个私有小工具 find:沿路径走,缺边就返回空。search 和 startsWith{" "} 都调它,只在最后一步分道扬镳。对着注释读一遍,再盖住默写一遍{" "} insert,它就是你的了。

    @@ -1430,8 +1374,7 @@ class Trie { <> 26 槽数组版:把 Map<Character, Node>{" "} 换成 Node[] children = new Node[26],用{" "} - c - 'a' 当下标。更快、常数更小, - 但每个节点从此固定占 26 个指针,而且只在输入为小写 ASCII 时成立。 + c - 'a' 当下标。更快、常数更小,但每个节点从此固定占 26 个指针,而且只在输入为小写 ASCII 时成立。 ), }, @@ -1602,8 +1545,7 @@ class Trie { zh: ( <> 易错点:用普通对象 {"{}"} 存 children - 也能跑,但键若是 __proto__ 之类, - 取到的会是原型而不是子节点。建议用{" "} + 也能跑,但键若是 __proto__ 之类,取到的会是原型而不是子节点。建议用{" "} Object.create(null) 或 Map。 26 槽数组版: new Array(26) + c.charCodeAt(0) - 97。 @@ -1679,10 +1621,7 @@ class Trie {

    和数组、哈希表不同,三种语言的标准库里都没有 Trie —— 面试要用就得手写(§04)。所以这一节比的不是 API,而是 - 同一个节点的 children 用什么容器装, - 以及各自要注意什么。抉择还是那两条:定长数组(最快、 - 费内存、只认小写 ASCII)vs 哈希表(稀疏数据省内存、 - 任意字符集)。 + 同一个节点的 children 用什么容器装,以及各自要注意什么。抉择还是那两条:定长数组(最快、费内存、只认小写 ASCII)vs 哈希表(稀疏数据省内存、任意字符集)。

    } /> @@ -1829,14 +1768,10 @@ class Trie { zh={

    「共享前缀 → 省空间」这个直觉,要看数据。词与词 - 在开头重叠得多(自然语言、URL、文件路径、电话号码), - 折叠公共开头确实省;可若词很短、彼此几乎没有共同开头, - Trie 比直接存字符串更费:每个字符一个节点, - 每个节点还带一张 children 表(数组版一律 26 个指针)。 + 在开头重叠得多(自然语言、URL、文件路径、电话号码),折叠公共开头确实省;可若词很短、彼此几乎没有共同开头, + Trie 比直接存字符串更费:每个字符一个节点,每个节点还带一张 children 表(数组版一律 26 个指针)。 指针开销很容易超过省下的字符。所以工程里常用它的压缩形态 —— - 基数树 Radix Tree 或双数组 Trie: - 把「只有一个孩子的节点链」合并成一条边,代价是插入更复杂。 - 结论:选 Trie 是为了前缀查询,不是为了省内存。 + 基数树 Radix Tree 或双数组 Trie:把「只有一个孩子的节点链」合并成一条边,代价是插入更复杂。结论:选 Trie 是为了前缀查询,不是为了省内存。

    } /> @@ -1879,9 +1814,7 @@ class Trie {

    Trie 的题目几乎都是「208 模板 + 一点新东西」。A{" "} 把模板本身逐帧走一遍:插入怎么复用前缀,查询有哪三种结局。 - B 给查询加一个通配符,逼着「走」在节点处分叉, - 变成 DFS。C 把 Trie 和网格回溯结合, - 用它提前砍掉分支 —— 这是 Trie 最有价值的用法。 + B 给查询加一个通配符,逼着「走」在节点处分叉,变成 DFS。C 把 Trie 和网格回溯结合,用它提前砍掉分支 —— 这是 Trie 最有价值的用法。

    } /> @@ -1924,13 +1857,10 @@ class Trie { zh={

    题意:实现 insert / search / startsWith 三个方法。 - 暴力:用一个 HashSet<String> 存所有词 —— + 暴力:用一个 HashSet<String> 存所有词 —— search 确实 O(L),但 startsWith 只能读遍集合里每个词、逐个比对开头, O(N·L),词典一大就无法接受。 - 正解:就是 §04 那份 Trie。代码不再重复, - 我们把它跑一遍:先插入 app, - 再插入 apple(看前缀怎么复用),然后做四次查询, - 把三种结局都看一遍。 + 正解:就是 §04 那份 Trie。代码不再重复,我们把它跑一遍:先插入 app,再插入 apple(看前缀怎么复用),然后做四次查询,把三种结局都看一遍。

    } /> @@ -1976,8 +1906,7 @@ class Trie { × 一张 children 表的大小。追问预备:①{" "} 「startsWith 和 search 差在哪?」—— 差一个{" "} isEnd 判断。②「怎么删除一个词?」—— - 走到末节点清掉 isEnd;若要回收内存,自底向上删掉 - 「没有孩子、也不是任何词尾」的节点。③ + 走到末节点清掉 isEnd;若要回收内存,自底向上删掉「没有孩子、也不是任何词尾」的节点。③ 「怎么统计某前缀下有几个词?」—— 在节点上存一个计数, insert 时沿路每个节点 +1(这就是 LC 677 的思路)。

    @@ -2026,14 +1955,11 @@ class Trie { 题意:设计一个结构支持 addWord,以及 search —— search 的字符串里可能出现 '.',它 匹配任意一个字母。 - 卡点:普通字符告诉你该走哪条边,而{" "} + 卡点:普通字符告诉你该走哪条边,而{" "} '.' - 不告诉你,于是每条子边都得试。 - 「对所有分支各递归一次」的循环,就是带回溯的 DFS。 - 正解:addWord 照搬 LC 208;search 改成递归: - 普通字符只钻对应的那个 child,遇到 '.'{" "} - 就遍历当前节点的所有 child 分别递归, - 任意一条成功就返回 true。 + 不告诉你,于是每条子边都得试。「对所有分支各递归一次」的循环,就是带回溯的 DFS。 + 正解:addWord 照搬 LC 208;search 改成递归:普通字符只钻对应的那个 child,遇到 '.'{" "} + 就遍历当前节点的所有 child 分别递归,任意一条成功就返回 true。

    } /> @@ -2127,9 +2053,7 @@ class WordDictionary { ), zh: ( <> - 复杂度:addWord O(L);没有通配符时 search 也是 O(L)。 - 开头是一串 '.' 的模式会朝 O(26^L) 扇出, - 但搜索访问的节点数不会超过整棵树的节点数,而且缺边会立刻中断一条分支。 + 复杂度:addWord O(L);没有通配符时 search 也是 O(L)。开头是一串 '.' 的模式会朝 O(26^L) 扇出,但搜索访问的节点数不会超过整棵树的节点数,而且缺边会立刻中断一条分支。 ), }, @@ -2191,8 +2115,7 @@ class WordDictionary: ), zh: ( <> - any(...) 天然短路:第一条返回 True 的分支之后, - 其余分支不再尝试。 + any(...) 天然短路:第一条返回 True 的分支之后,其余分支不再尝试。 ), }, @@ -2324,18 +2247,12 @@ class WordDictionary { zh={ <>

    - 题意:给一个字母网格 board 和一个词表 words, - 找出所有能在网格中沿相邻格子(上下左右、 - 同一格不重复用)拼出的单词。 - 暴力:对 words 里每个词各做一次网格搜索。 - 词表一大(几千个词)、很多词开头还相同, - 「从某个 c 出发」这件事会被重复搜千百遍,必然超时。 + 题意:给一个字母网格 board 和一个词表 words,找出所有能在网格中沿相邻格子(上下左右、同一格不重复用)拼出的单词。 + 暴力:对 words 里每个词各做一次网格搜索。词表一大(几千个词)、很多词开头还相同,「从某个 c 出发」这件事会被重复搜千百遍,必然超时。

    - 为什么 Trie 能解决这个问题:先把所有词建成一棵 Trie, - 然后只在网格上走一次, - DFS 每走一步,就在 Trie 上同步下沉一步。 - 两个结果随之而来: + 为什么 Trie 能解决这个问题:先把所有词建成一棵 Trie,然后只在网格上走一次, + DFS 每走一步,就在 Trie 上同步下沉一步。两个结果随之而来:

    } @@ -2378,8 +2295,7 @@ class WordDictionary { zh={ <> 缺边就立刻结束这条分支 —— 这就是剪枝。 - 如果当前字母在当前 Trie 节点上没有对应的 child, - 说明没有任何词这样开头,从这里再往下走都是白走。 + 如果当前字母在当前 Trie 节点上没有对应的 child,说明没有任何词这样开头,从这里再往下走都是白走。 立即返回,整条分支消失。正是这一步把搜索拉回可接受的范围。 } @@ -2424,10 +2340,8 @@ class WordDictionary { zh={

    实现上有两个小技巧。其一, - 在词尾节点直接存整个单词(而不是只放一个布尔位), - 命中时不必回头拼字符串。其二, - 收集之后把该字段清空, - 不用额外记录就完成了去重。 + 在词尾节点直接存整个单词(而不是只放一个布尔位),命中时不必回头拼字符串。其二, + 收集之后把该字段清空,不用额外记录就完成了去重。

    } /> @@ -2631,9 +2545,7 @@ class Solution: ), zh: ( <> - 嵌套 dict 是 Python 里最省事的 Trie 写法 —— 连节点类都不用定义。 - 用一个非字母的键(这里是 '#')存整词, - 不会和普通字符键冲突。 + 嵌套 dict 是 Python 里最省事的 Trie 写法 —— 连节点类都不用定义。用一个非字母的键(这里是 '#')存整词,不会和普通字符键冲突。 ), }, @@ -2710,10 +2622,7 @@ var findWords = function (board, words) { ), zh: ( <> - node[c] ??= {"{}"} 就是「有就复用,没有就建」。 - 用 word 字段存整词、收集后置 null, - 一举完成「收集」和「去重」。这里的键都是单个字符, - 所以用普通对象是安全的。 + node[c] ??= {"{}"} 就是「有就复用,没有就建」。用 word 字段存整词、收集后置 null,一举完成「收集」和「去重」。这里的键都是单个字符,所以用普通对象是安全的。 ), }, @@ -2747,10 +2656,7 @@ var findWords = function (board, words) { 不是「为每个词搜一遍网格」,而是「网格上的一次 DFS 沿着 Trie 走,顺路把所有词都测了」。     {" "} - Trie 在这里担两个角色:开头相同的词共用一条路径; - 没有任何词有的开头,立刻结束这条分支。这是「多模式串匹配」的通用形状。 - 再往前一步就是 AC 自动机(Aho-Corasick):在 Trie 上加失配指针, - 让搜索永远不必从头重来。 + Trie 在这里担两个角色:开头相同的词共用一条路径;没有任何词有的开头,立刻结束这条分支。这是「多模式串匹配」的通用形状。再往前一步就是 AC 自动机(Aho-Corasick):在 Trie 上加失配指针,让搜索永远不必从头重来。

    } /> @@ -2814,9 +2720,7 @@ var findWords = function (board, words) { zh: ( <> Trie 的存在只有一个理由: - 哈希表把整个 key 算成一个数,丢掉了「开头」这个信息, - 因此答不了前缀问题。Trie 让开头相同的词待在同一条路径上, - 「以 X 开头」就退化成「顺着这条路往下走」。 + 哈希表把整个 key 算成一个数,丢掉了「开头」这个信息,因此答不了前缀问题。Trie 让开头相同的词待在同一条路径上,「以 X 开头」就退化成「顺着这条路往下走」。 ), }, @@ -2835,9 +2739,7 @@ var findWords = function (board, words) { zh: ( <> 结构极简:节点 = children(字符 → 子节点) +{" "} - isEnd(布尔)。字符贴在边上,拼出词的是路径, - 节点本身不存词。isEnd 必不可少 —— 没有它, - 就分不清 cat 和「cattle 路过同一批节点」这两回事。 + isEnd(布尔)。字符贴在边上,拼出词的是路径,节点本身不存词。isEnd 必不可少 —— 没有它,就分不清 cat 和「cattle 路过同一批节点」这两回事。 ), }, @@ -2854,8 +2756,7 @@ var findWords = function (board, words) { zh: ( <> insert / search / startsWith 全是 O(L),L 是 - 字符串长度,不是词数。这份「与词典大小无关」正是这个结构的意义所在。 - search 比 startsWith 只多一个 isEnd 判断。 + 字符串长度,不是词数。这份「与词典大小无关」正是这个结构的意义所在。search 比 startsWith 只多一个 isEnd 判断。 ), }, @@ -2872,10 +2773,8 @@ var findWords = function (board, words) { ), zh: ( <> - children 表是唯一的设计抉择:定长 26 槽数组最快, - 但每个节点占 26 个指针,而且只认小写 ASCII; - 哈希表只存实际存在的孩子、任意字符都能用,常数略大。 - Trie 是用内存买前缀查询,不是反过来。 + children 表是唯一的设计抉择:定长 26 槽数组最快,但每个节点占 26 个指针,而且只认小写 ASCII; + 哈希表只存实际存在的孩子、任意字符都能用,常数略大。Trie 是用内存买前缀查询,不是反过来。 ), }, @@ -2894,9 +2793,7 @@ var findWords = function (board, words) { <> 三大套路:LC 208 模板 →{" "} LC 211,通配符让「走」在节点处分叉成 DFS →{" "} - LC 212,前缀不存在就立刻结束这条网格分支; - 再加一个 0/1 Trie(把整数按比特建树)解最大异或。 - 题面里出现「前缀 / 补全 / 共同开头」,就该想到它。 + LC 212,前缀不存在就立刻结束这条网格分支;再加一个 0/1 Trie(把整数按比特建树)解最大异或。题面里出现「前缀 / 补全 / 共同开头」,就该想到它。 ), }, diff --git a/app/trie/viz.tsx b/app/trie/viz.tsx index 1f7f82c..ccdb4fa 100644 --- a/app/trie/viz.tsx +++ b/app/trie/viz.tsx @@ -206,8 +206,7 @@ export function TrieLab() { zh={ <> 这棵 Trie 里已经存了 car、card、cat、do、dog 五个词。试着插入{" "} - care 或 cab,看路径哪一段被复用;再查询 ca, - 看看「前缀」长什么样。 + care 或 cab,看路径哪一段被复用;再查询 ca,看看「前缀」长什么样。 } />, @@ -313,8 +312,7 @@ export function TrieLab() { } zh={ <> - {w} 之前就插入过。这次只是把同一个末节点的 isEnd 又标了一遍, - 树的形状没有变化。 + {w} 之前就插入过。这次只是把同一个末节点的 isEnd 又标了一遍,树的形状没有变化。 } /> @@ -385,9 +383,7 @@ export function TrieLab() { } zh={ <> - 查询 {w}:算上根节点走到第 {acc.length} 个节点时, - 下一个字母没有对应的 child,路径到此为止。未命中, - 而且整棵树里不可能有以 {w} 开头的词 —— 有的话,它必然长在这条路径上。 + 查询 {w}:算上根节点走到第 {acc.length} 个节点时,下一个字母没有对应的 child,路径到此为止。未命中,而且整棵树里不可能有以 {w} 开头的词 —— 有的话,它必然长在这条路径上。 } />, @@ -447,8 +443,7 @@ export function TrieLab() { zh={ <> search({w}):路径走得通,但末节点 isEnd = false —— {w}{" "} - 只是别的词的开头,不是被插入过的单词。所以 search 返回 false, - 而 startsWith 会返回 true。isEnd 就是为这种情况存在的。 + 只是别的词的开头,不是被插入过的单词。所以 search 返回 false,而 startsWith 会返回 true。isEnd 就是为这种情况存在的。 } />, diff --git a/app/union-find/page.tsx b/app/union-find/page.tsx index 4072b2c..ffd3fec 100644 --- a/app/union-find/page.tsx +++ b/app/union-find/page.tsx @@ -60,8 +60,7 @@ const F547: ArrayFrame[] = [ zh: ( <> 4 个城市,parent = [0,1,2,3],每个城市都是自己所在树的根, - count = 4。矩阵里 M[i][j] = 1 表示 i、j 直接相连。 - 下面逐格扫上三角(j > i)—— 矩阵对称,下三角不用看。 + count = 4。矩阵里 M[i][j] = 1 表示 i、j 直接相连。下面逐格扫上三角(j > i)—— 矩阵对称,下三角不用看。 ), }, @@ -120,8 +119,7 @@ const F547: ArrayFrame[] = [ ), zh: ( <> - M[1][2] = 1,执行 union(1, 2)。find(1) = 1、find(2) = 2 不同, - 于是 parent[1] = 2,count 3 → 2。城市 0 一个字节都没动就跟着过来了: + M[1][2] = 1,执行 union(1, 2)。find(1) = 1、find(2) = 2 不同,于是 parent[1] = 2,count 3 → 2。城市 0 一个字节都没动就跟着过来了: find(0) 现在爬 0 → 1 → 2。 ), @@ -139,8 +137,7 @@ const F547: ArrayFrame[] = [ ), zh: ( <> - 剩下的格子全是 0。扫描结束,count = 2 就是答案: - 省份是 {"{0,1,2}"} 和 {"{3}"}。全程没有做任何图遍历 —— + 剩下的格子全是 0。扫描结束,count = 2 就是答案:省份是 {"{0,1,2}"} 和 {"{3}"}。全程没有做任何图遍历 —— count 在合并过程中一直是对的。 ), @@ -170,8 +167,7 @@ const F684: ArrayFrame[] = [ ), zh: ( <> - 边:[1,2] [2,3] [3,4] [1,4] [1,5]。一棵树多加一条边,恰好含一个环。 - 按给定顺序逐边处理,哪条边的两个端点「已经连通」,哪条就是多余的那条。 + 边:[1,2] [2,3] [3,4] [1,4] [1,5]。一棵树多加一条边,恰好含一个环。按给定顺序逐边处理,哪条边的两个端点「已经连通」,哪条就是多余的那条。 ), }, @@ -238,8 +234,7 @@ const F684: ArrayFrame[] = [ ), zh: ( <> - 边 [3,4]:find(3) = 3、find(4) = 4 不同,合并,parent[3] = 4。 - 此时 1、2、3、4 已经在同一棵树里(1 → 2 → 3 → 4)。 + 边 [3,4]:find(3) = 3、find(4) = 4 不同,合并,parent[3] = 4。此时 1、2、3、4 已经在同一棵树里(1 → 2 → 3 → 4)。 ), }, @@ -269,8 +264,7 @@ const F684: ArrayFrame[] = [ zh: ( <> 边 [1,4]:find(1) 一路爬 1 → 2 → 3 → 4,返回 4,find(4) - 也返回 4。根相同,说明 1 和 4 之间早已有路径, - 这条边一加必然闭合成环。答案是 [1,4]。 + 也返回 4。根相同,说明 1 和 4 之间早已有路径,这条边一加必然闭合成环。答案是 [1,4]。 ), }, @@ -296,9 +290,7 @@ const F684: ArrayFrame[] = [ ), zh: ( <> - 题目要求返回在输入中最后出现的那条成环边,而按顺序逐边处理正好直接给出它: - 环上其余的边都在它之前加入,所以它是唯一一条两端已经连通的边。 - 边 [1,5] 根本不会被检查到。 + 题目要求返回在输入中最后出现的那条成环边,而按顺序逐边处理正好直接给出它:环上其余的边都在它之前加入,所以它是唯一一条两端已经连通的边。边 [1,5] 根本不会被检查到。 ), }, @@ -324,8 +316,7 @@ const F200: ArrayFrame[] = [ ), zh: ( <> - 2×4 网格拍扁成一维:idx = r×4 + c,前 4 格是第 0 行,后 4 格是第 1 行。 - 陆地(值 1)共 5 块,初始 count = 5 —— 先假设每块陆地各是一座岛。 + 2×4 网格拍扁成一维:idx = r×4 + c,前 4 格是第 0 行,后 4 格是第 1 行。陆地(值 1)共 5 块,初始 count = 5 —— 先假设每块陆地各是一座岛。 ), }, @@ -347,8 +338,7 @@ const F200: ArrayFrame[] = [ ), zh: ( <> - 扫到 (0,0):右邻 (0,1) 也是陆地 → union(0, 1),count 5 → 4。 - 每格只看右邻和下邻就够 —— 左邻、上邻在处理更早的格子时已经连过了。 + 扫到 (0,0):右邻 (0,1) 也是陆地 → union(0, 1),count 5 → 4。每格只看右邻和下邻就够 —— 左邻、上邻在处理更早的格子时已经连过了。 ), }, @@ -392,8 +382,7 @@ const F200: ArrayFrame[] = [ ), zh: ( <> - (0,1) 的右邻和下邻都是水,跳过。到 (0,3):右邻出界, - 下邻 (1,3)(idx = 7)是陆地 → union(3, 7),count 3 → 2。 + (0,1) 的右邻和下邻都是水,跳过。到 (0,3):右邻出界,下邻 (1,3)(idx = 7)是陆地 → union(3, 7),count 3 → 2。 ), }, @@ -413,8 +402,7 @@ const F200: ArrayFrame[] = [ ), zh: ( <> - 第 1 行的陆地 (1,0)、(1,3),右邻不是陆地,下邻出界。 - 扫描结束,count = 2,两座岛:{"{(0,0),(0,1),(1,0)}"} 与{" "} + 第 1 行的陆地 (1,0)、(1,3),右邻不是陆地,下邻出界。扫描结束,count = 2,两座岛:{"{(0,0),(0,1),(1,0)}"} 与{" "} {"{(0,3),(1,3)}"}。 ), @@ -477,11 +465,8 @@ export default function UnionFindChapter() { ), zh: ( <> - 它只回答两个问题:两个元素是否在同一个集合; - 把两个集合合并。它把元素组织成一片森林 - —— 一个集合就是一棵树,树根就是这个集合的代表元。 - 一个整型数组装下全部结构,两个优化都开时, - 每次操作的代价近乎常数。 + 它只回答两个问题:两个元素是否在同一个集合;把两个集合合并。它把元素组织成一片森林 + —— 一个集合就是一棵树,树根就是这个集合的代表元。一个整型数组装下全部结构,两个优化都开时,每次操作的代价近乎常数。 ), }} @@ -529,8 +514,7 @@ export default function UnionFindChapter() { 成为好友,B 和 C 成为好友……其间随时有人来问: A 和 D 现在算同一组吗? 「同组」这层关系是可传递的:A—B、B—C、C—D - 都成立,那么 A 和 D 哪怕素未谋面,也属于同一组。 - 这类问题有个名字:动态连通性(dynamic connectivity) + 都成立,那么 A 和 D 哪怕素未谋面,也属于同一组。这类问题有个名字:动态连通性(dynamic connectivity) —— 连接关系随时间增加,查询随时可能到来。

    @@ -565,8 +549,7 @@ export default function UnionFindChapter() { } zh={

    - 每个集合推举一个成员当代表元,也就是根。 - 想知道 A 和 D 是不是同一集合,不必顺着好友关系链走一遍 —— + 每个集合推举一个成员当代表元,也就是根。想知道 A 和 D 是不是同一集合,不必顺着好友关系链走一遍 —— 问一句「A 的代表元是谁?D 的代表元是谁?」 代表元相同就是同一集合。 这一步把「连通吗」变成了「这两个数相等吗」,整个结构的思想就在这里。 @@ -597,8 +580,7 @@ export default function UnionFindChapter() { zh={

    a 和 b 成为好友:先找出两边各自的代表元,再 - 让一个代表元指向另一个。两个集合立刻并成一个。 - 被并走的那个集合里,其余成员一个都不用访问 —— + 让一个代表元指向另一个。两个集合立刻并成一个。被并走的那个集合里,其余成员一个都不用访问 —— 反正它们最终都会爬到同一个根。

    } @@ -622,9 +604,7 @@ export default function UnionFindChapter() { zh={

    为什么不用图遍历?把边存下来,每次从 A 出发做一遍 DFS/BFS - 看能否到达 D 也可以(第 12 章会讲)。问题是每来一次查询就要重新遍历一遍, - 单次 O(V+E),而且边还在不断增加,上一次遍历的结果没法复用。 - 并查集正是为这种形态的问题设计的,它的另一个名字是 + 看能否到达 D 也可以(第 12 章会讲)。问题是每来一次查询就要重新遍历一遍,单次 O(V+E),而且边还在不断增加,上一次遍历的结果没法复用。并查集正是为这种形态的问题设计的,它的另一个名字是 不相交集合(disjoint set union,简称 DSU)。

    } @@ -729,18 +709,13 @@ export default function UnionFindChapter() { <>

    并查集之所以快,是因为它只保留结论,丢掉细节: - union 之后,「A 和 D 是怎么连起来的」这条信息就没有了, - 剩下的只有「它们在同一个集合里」。所以它答不了「A 到 D 怎么走」, - 也答不了「相隔多远」。 + union 之后,「A 和 D 是怎么连起来的」这条信息就没有了,剩下的只有「它们在同一个集合里」。所以它答不了「A 到 D 怎么走」,也答不了「相隔多远」。

    还有第二个限制,而且最常被略过:并查集只能合并, 不能把一个集合拆回去。它没有高效的撤销手段 —— - 合并进来的元素和原本就在里面的元素已经无法区分。 - 如果题目要求删除边,标准做法是先把所有操作读完,再 - 倒着处理,让每一次删除变成一次加入。 - 这要求你能提前看到整个操作序列,也就是所谓的离线做法; - 否则就要用可撤销变体 —— 记一份撤销日志,并放弃路径压缩。 + 合并进来的元素和原本就在里面的元素已经无法区分。如果题目要求删除边,标准做法是先把所有操作读完,再 + 倒着处理,让每一次删除变成一次加入。这要求你能提前看到整个操作序列,也就是所谓的离线做法;否则就要用可撤销变体 —— 记一份撤销日志,并放弃路径压缩。

    } @@ -772,12 +747,7 @@ export default function UnionFindChapter() { zh={

    这个结构由 Galler 和 Fischer 在 1964 年提出,至今仍随处可见。 - Kruskal 最小生成树算法把边按权重排序后逐条加入, - 每加一条之前先问并查集:这条边的两个端点是否已经连通? - 若已连通,加上它就会形成环,于是跳过。 - 编译器在类型推导里用同一个结构合并必须相等的类型变量; - 图像处理用它标记像素的连通区域。核心不过三个短方法, - 而它运行时间的匹配下界要到 1989 年才由 Fredman 和 Saks 证明出来。 + Kruskal 最小生成树算法把边按权重排序后逐条加入,每加一条之前先问并查集:这条边的两个端点是否已经连通?若已连通,加上它就会形成环,于是跳过。编译器在类型推导里用同一个结构合并必须相等的类型变量;图像处理用它标记像素的连通区域。核心不过三个短方法,而它运行时间的匹配下界要到 1989 年才由 Fredman 和 Saks 证明出来。

    } /> @@ -832,8 +802,7 @@ export default function UnionFindChapter() { zh={ <>

    - 并查集的全部数据,就是一个整型数组 parent, - 规则只有两条。 + 并查集的全部数据,就是一个整型数组 parent,规则只有两条。

    • @@ -846,11 +815,8 @@ export default function UnionFindChapter() {

    - 为什么用「自己指自己」来标记根?因为根没有上一级, - 而这个格子总得存点什么。存 i 自己不额外占内存,不需要再开一个标记数组, - 还让终止判断变成一次比较:parent[x] == x —— - 根和非根用同一段循环处理。find 因此写成这样: - 从 x 出发一路往上,直到某个元素指向它自己。 + 为什么用「自己指自己」来标记根?因为根没有上一级,而这个格子总得存点什么。存 i 自己不额外占内存,不需要再开一个标记数组,还让终止判断变成一次比较:parent[x] == x —— + 根和非根用同一段循环处理。find 因此写成这样:从 x 出发一路往上,直到某个元素指向它自己。

    } @@ -938,19 +904,10 @@ find(x) { zh={ <>

    - 换个角度看这个数组:给每个 i 画一条指向 parent[i] 的箭头, - 整个数组就成了一片森林 —— 若干棵树, - 一棵树对应一个集合,树根代表这个集合。 - 这是全书第二次「数组扮演树」: - 堆用 2i+1、2i+2 的下标运算隐式编码父子关系, - 并查集更直接 —— 把每个节点的父节点显式存下来。 - 两种情形里树都只是逻辑形状,物理上始终只有一排连续的整数。 + 换个角度看这个数组:给每个 i 画一条指向 parent[i] 的箭头,整个数组就成了一片森林 —— 若干棵树,一棵树对应一个集合,树根代表这个集合。这是全书第二次「数组扮演树」:堆用 2i+1、2i+2 的下标运算隐式编码父子关系,并查集更直接 —— 把每个节点的父节点显式存下来。两种情形里树都只是逻辑形状,物理上始终只有一排连续的整数。

    - 下面亲手试试:点两个节点, - 看 union 如何先对两边各做一次 find 找到两个根,再把一个根挂到另一个下面; - 同时盯着下方的 parent 数组,确认图里发生的一切, - 不过是数组里改了一个数。然后点 + 下面亲手试试:点两个节点,看 union 如何先对两边各做一次 find 找到两个根,再把一个根挂到另一个下面;同时盯着下方的 parent 数组,确认图里发生的一切,不过是数组里改了一个数。然后点 「最坏顺序 union」,看看会出什么问题。

    @@ -980,11 +937,8 @@ find(x) { } zh={

    - union(0,1) 把 0 挂到 1 下面,union(1,2) 又把这棵树的根挂到 2 下面, - 依此类推。每一步都是把已有的根挂到一个新的单节点下面, - 于是树只长高、不长宽。10 个元素最后连成一条链,find(0) - 要走 9 步才能到根,复杂度 O(n), - 并查集赖以成名的速度荡然无存。问题不在结构本身, + union(0,1) 把 0 挂到 1 下面,union(1,2) 又把这棵树的根挂到 2 下面,依此类推。每一步都是把已有的根挂到一个新的单节点下面,于是树只长高、不长宽。10 个元素最后连成一条链,find(0) + 要走 9 步才能到根,复杂度 O(n),并查集赖以成名的速度荡然无存。问题不在结构本身, 而在 union 选择「谁挂到谁下面」的做法 —— 下一节正是要修这个。

    } @@ -1024,9 +978,7 @@ find(x) { } zh={

    - 上一节的病根是树太高:find 的代价等于节点到根之间的层数。 - 两个优化的目标一致 —— 把树压矮,但它们作用的时刻不同, - 防的问题也不同。两个都重要,而且要能说清各自干了什么。 + 上一节的病根是树太高:find 的代价等于节点到根之间的层数。两个优化的目标一致 —— 把树压矮,但它们作用的时刻不同,防的问题也不同。两个都重要,而且要能说清各自干了什么。

    } /> @@ -1057,8 +1009,7 @@ find(x) { } zh={

    - find(x) 反正要从 x 一路走到根,走完之后,途中经过的每个节点的根都已经确定了, - 没有理由让它们继续指着中间节点。 + find(x) 反正要从 x 一路走到根,走完之后,途中经过的每个节点的根都已经确定了,没有理由让它们继续指着中间节点。 爬到根之后,把沿途每个节点的 parent 直接改成根。

    } @@ -1150,11 +1101,7 @@ find(x) { } zh={

    - 额外代价很小:这条路本来就要走,压缩只是在回程多做几次赋值。 - 收益却是持久的:一个节点被压缩过之后, - 之后对它的 find 只要一步,直到后来的某次 union 在它头上又加了新的根。 - 路径压缩防的是同一条长路径被反复重走。 - 即使不配按秩合并,单独使用它也已经把均摊代价降到{" "} + 额外代价很小:这条路本来就要走,压缩只是在回程多做几次赋值。收益却是持久的:一个节点被压缩过之后,之后对它的 find 只要一步,直到后来的某次 union 在它头上又加了新的根。路径压缩防的是同一条长路径被反复重走。即使不配按秩合并,单独使用它也已经把均摊代价降到{" "} 。

    } @@ -1233,8 +1180,7 @@ find(x) {

    • - 矮树挂到高树下:新高度 = max(高树高, 矮树高 + 1)。 - 只要矮树严格更矮,结果就等于高树的高度,树高 + 矮树挂到高树下:新高度 = max(高树高, 矮树高 + 1)。只要矮树严格更矮,结果就等于高树的高度,树高 不变。
    • @@ -1247,24 +1193,15 @@ find(x) {

    - 所以给每个根记一个 rank(秩), - 它是这棵树高度的上界。union 时,rank 小的根挂到 rank 大的根下面; - 两个 rank 相等时随便挂,并把新根的 rank 加 1。 - 只用这一条,树高就被压在 O(log n) 以内 —— - 因为 rank 为 r 的树至少含 2ʳ 个元素:rank 只在两棵等秩的树合并时才 +1, - 而那至少让规模翻倍。这和动态数组「扩容必翻倍」是同一套论证。 - 也有实现用 size(集合大小)代替 rank, - 小集合挂到大集合下面,界是一样的,还顺带得到每个集合的大小 —— + 所以给每个根记一个 rank(秩),它是这棵树高度的上界。union 时,rank 小的根挂到 rank 大的根下面;两个 rank 相等时随便挂,并把新根的 rank 加 1。只用这一条,树高就被压在 O(log n) 以内 —— + 因为 rank 为 r 的树至少含 2ʳ 个元素:rank 只在两棵等秩的树合并时才 +1,而那至少让规模翻倍。这和动态数组「扩容必翻倍」是同一套论证。也有实现用 size(集合大小)代替 rank,小集合挂到大集合下面,界是一样的,还顺带得到每个集合的大小 —— 好几道题正需要这个。

    - 路径压缩防不了这个问题:它只在 find 时运行, - 而且只能修一条已经形成的路径;按秩合并则让高树根本长不出来。 - 这就是两者不可互相替代的原因。 + 路径压缩防不了这个问题:它只在 find 时运行,而且只能修一条已经形成的路径;按秩合并则让高树根本长不出来。这就是两者不可互相替代的原因。

    - 现在回实验室验证:把两个开关都打开, - 再点一次「最坏顺序 union」,那条 10 个元素的长链会变成一棵深度为 1 的树。 + 现在回实验室验证:把两个开关都打开,再点一次「最坏顺序 union」,那条 10 个元素的长链会变成一棵深度为 1 的树。

    } @@ -1307,16 +1244,11 @@ find(x) { <>

    两个优化都开时,n 个元素上的 m 次操作总代价是 O(m · α(n)), - α 是反阿克曼函数。阿克曼函数比任何原始递归函数增长都快, - 所以它的反函数增长慢到极点:直到 n 约为 2^65536(远超任何机器能容纳的元素个数), + α 是反阿克曼函数。阿克曼函数比任何原始递归函数增长都快,所以它的反函数增长慢到极点:直到 n 约为 2^65536(远超任何机器能容纳的元素个数), α(n) 都不超过 4。实践中每次操作就是常数级的几步。

    - 措辞要小心。这个界是均摊的,不是最坏情形: - 单次 find 仍可能走一条较长的路径,只有把整串操作平均起来代价才这么小。 - 而且 O(α(n)) 不等于 O(1) —— α 确实会增长, - 只是慢得难以想象。说「近乎常数」是准确的,说「它是 O(1)」则不准确。 - 上界的证明来自 Tarjan(1975),远超本课范围。 + 措辞要小心。这个界是均摊的,不是最坏情形:单次 find 仍可能走一条较长的路径,只有把整串操作平均起来代价才这么小。而且 O(α(n)) 不等于 O(1) —— α 确实会增长,只是慢得难以想象。说「近乎常数」是准确的,说「它是 O(1)」则不准确。上界的证明来自 Tarjan(1975),远超本课范围。

    } @@ -1348,15 +1280,9 @@ find(x) { } zh={

    - 它会让 rank 变得不精确,而这没有关系。 - 压缩把树压扁,却不会调低已经记下的 rank, - 所以压缩之后 rank 是树高的上界,而不是树高本身 —— - 这个字段之所以叫「秩」而不叫「高度」,原因就在这里。 - 上界永远成立,所以正确性和复杂度分析都不受影响。 - 实践中也可以只写路径压缩、完全不要 rank,均摊 O(log n), - 做题已经够用。但面试官问「两个优化各自干什么」时,答案必须准确: - 压缩缩短的是已经存在的路径,按秩合并阻止高树形成, - 只有两者叠加才有 O(α(n))。 + 它会让 rank 变得不精确,而这没有关系。压缩把树压扁,却不会调低已经记下的 rank,所以压缩之后 rank 是树高的上界,而不是树高本身 —— + 这个字段之所以叫「秩」而不叫「高度」,原因就在这里。上界永远成立,所以正确性和复杂度分析都不受影响。实践中也可以只写路径压缩、完全不要 rank,均摊 O(log n),做题已经够用。但面试官问「两个优化各自干什么」时,答案必须准确: + 压缩缩短的是已经存在的路径,按秩合并阻止高树形成,只有两者叠加才有 O(α(n))。

    } /> @@ -1391,9 +1317,7 @@ find(x) { } zh={

    - 并查集是极少数值得逐字背熟的数据结构: - 没有哪个标准库提供它,所以在题目里它永远以「手写模板 + 一点建模」 - 的形式出现。下面这版同时带有两个优化,外加两个题目里反复用到的方法: + 并查集是极少数值得逐字背熟的数据结构:没有哪个标准库提供它,所以在题目里它永远以「手写模板 + 一点建模」的形式出现。下面这版同时带有两个优化,外加两个题目里反复用到的方法: connected 判连通,以及当前连通块数量 count。

    } @@ -1493,9 +1417,7 @@ find(x) { ), zh: ( <> - 路径减半(path halving):这个循环不做完整压缩, - 而是边爬边把每个节点改指向它的祖父。一趟循环,无递归、无第二次遍历, - 与按秩合并配合时同样是 O(α(n))。竞赛里最常见的正是这种写法。 + 路径减半(path halving):这个循环不做完整压缩,而是边爬边把每个节点改指向它的祖父。一趟循环,无递归、无第二次遍历,与按秩合并配合时同样是 O(α(n))。竞赛里最常见的正是这种写法。 ), }, @@ -1575,11 +1497,7 @@ find(x) { ), zh: ( <> - 易错点:Python 默认递归深度上限是 1000。 - 开启按秩合并时树高不超过 log₂n,递归本来是安全的; - 但只写路径压缩时,链长可能达到 n,递归版 find 就会抛 RecursionError。 - 所以这里用两趟迭代实现完整的路径压缩,两种情况下都安全。 - Java 和 JavaScript 的调用栈更大,但同样有限,道理相同。 + 易错点:Python 默认递归深度上限是 1000。开启按秩合并时树高不超过 log₂n,递归本来是安全的;但只写路径压缩时,链长可能达到 n,递归版 find 就会抛 RecursionError。所以这里用两趟迭代实现完整的路径压缩,两种情况下都安全。Java 和 JavaScript 的调用栈更大,但同样有限,道理相同。 ), }, @@ -1712,16 +1630,11 @@ find(x) {
  • count 初始为 n,只在真正发生合并时才减 1。 - 每个元素起初各成一个集合,所以有 n 个集合; - 一次成功的 union 把两个集合换成一个,数量正好减 1。 - 而两边根本来就相同的 union 什么也没合并, - 此时若照样减 1,报出的连通块数就会比实际少。 - 这正是 if (ra == rb) return false; 要写在{" "} + 每个元素起初各成一个集合,所以有 n 个集合;一次成功的 union 把两个集合换成一个,数量正好减 1。而两边根本来就相同的 union 什么也没合并,此时若照样减 1,报出的连通块数就会比实际少。这正是 if (ra == rb) return false; 要写在{" "} count-- 之前的原因。
  • - 合并前永远先找两边的根。union 的第一行不可能是别的。 - union 合并的是两个集合,不是那两个具体元素。 + 合并前永远先找两边的根。union 的第一行不可能是别的。union 合并的是两个集合,不是那两个具体元素。
    • @@ -1759,9 +1672,7 @@ find(x) { zh={

    三门语言的标准库都没有并查集,C++ 也没有 —— 只有 Boost - 或竞赛模板库里才有。原因是这个结构太小,而且每道题需要的细节都不一样, - 与其设计一套通用 API,不如花三十秒手写一个贴合题意的。 - 所以真正值得对照的不是 API,而是容器选型。 + 或竞赛模板库里才有。原因是这个结构太小,而且每道题需要的细节都不一样,与其设计一套通用 API,不如花三十秒手写一个贴合题意的。所以真正值得对照的不是 API,而是容器选型。

    } /> @@ -1875,8 +1786,7 @@ find(x) { 有一个实战问题反复出现:key 不是 0 到 n−1 的整数怎么办? LC 721 的 key 是邮箱地址,LC 128 的 key 是任意整数 —— 可能为负,也可能大到 10⁹。答案是第 6 章的哈希表: - 先把每个 key 映射成一个连续的新编号,再照常开数组。 - 哈希表负责翻译,并查集负责合并。 + 先把每个 key 映射成一个连续的新编号,再照常开数组。哈希表负责翻译,并查集负责合并。

    } /> @@ -1975,11 +1885,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, zh={

    直接拿 Map<String, String> 当 parent(key - 映射到它的上一级 key)也能实现并查集,省掉编号那一步。 - 代价是 find 的每一步都从数组下标访问变成一次哈希查找, - 单步慢好几倍。一条实用准则:元素能编号就编号。 - 数组是并查集最好的载体,理由和数组章说过的一样: - 连续内存加下标直达。 + 映射到它的上一级 key)也能实现并查集,省掉编号那一步。代价是 find 的每一步都从数组下标访问变成一次哈希查找,单步慢好几倍。一条实用准则:元素能编号就编号。数组是并查集最好的载体,理由和数组章说过的一样:连续内存加下标直达。

    } /> @@ -2018,8 +1924,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, zh={

    并查集题目里 90% 的代码是同一份模板,真正的考点是 - 建模 —— 把题面翻译成「谁是节点、什么算边」。 - 翻译完成之后,套路只有三种。 + 建模 —— 把题面翻译成「谁是节点、什么算边」。翻译完成之后,套路只有三种。

    } /> @@ -2042,8 +1947,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, } zh={

    - 有几个省份、几座岛、几个组?count 初始为 n, - 每成功 union 一次减 1,扫完直接读答案。LC 547、200、2316。 + 有几个省份、几座岛、几个组?count 初始为 n,每成功 union 一次减 1,扫完直接读答案。LC 547、200、2316。

    } /> @@ -2065,8 +1969,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, } zh={

    - 逐边加入,某条边的两个端点已经连通, - 它就会闭合成环。这与 Kruskal 算法用的判断完全相同。LC 684、685。 + 逐边加入,某条边的两个端点已经连通,它就会闭合成环。这与 Kruskal 算法用的判断完全相同。LC 684、685。

    } /> @@ -2088,8 +1991,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, } zh={

    - 「相等」「相似」「同账户」这类关系,一旦按它分组就有传递性。 - 全部 union 起来,再按根检查或分组。LC 990、721、839。 + 「相等」「相似」「同账户」这类关系,一旦按它分组就有传递性。全部 union 起来,再按根检查或分组。LC 990、721、839。

    } /> @@ -2126,12 +2028,10 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, } zh={

    - 题意:n 个城市,isConnected[i][j] = 1 表示 i、j 直接相连; - 相连关系可传递,求省份(也就是连通块)的个数。 - 暴力做法:对每个没访问过的城市做一次 DFS + 题意:n 个城市,isConnected[i][j] = 1 表示 i、j 直接相连;相连关系可传递,求省份(也就是连通块)的个数。 + 暴力做法:对每个没访问过的城市做一次 DFS 把整个省份标掉,数发起了几次 —— 可行,O(n²),第 12 章会讲。 - 并查集视角:矩阵里的每个 1 就是一条边,逐格 union, - 让 count 从 n 一路减,剩下多少就是几个省 —— 连访问标记数组都不需要。 + 并查集视角:矩阵里的每个 1 就是一条边,逐格 union,让 count 从 n 一路减,剩下多少就是几个省 —— 连访问标记数组都不需要。

    } /> @@ -2252,13 +2152,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, } zh={

    - 时间 O(n²·α(n)) —— 矩阵本身就有 n² 个格子,读一遍已是下限; - 空间 O(n)。追问一:DFS 也是 O(n²),并查集好在哪? - 在这份输入上没有优势。但如果关系是一条条到来、 - 中途要随时报数,并查集增量维护,DFS 则要从头再来。 - 追问二:为什么只扫上三角?矩阵对称,i-j 和 j-i 是同一条边; - 扫两遍只是浪费,不会出错 —— 同一对元素第二次 union 会返回 false, - 什么都不改。 + 时间 O(n²·α(n)) —— 矩阵本身就有 n² 个格子,读一遍已是下限;空间 O(n)。追问一:DFS 也是 O(n²),并查集好在哪?在这份输入上没有优势。但如果关系是一条条到来、中途要随时报数,并查集增量维护,DFS 则要从头再来。追问二:为什么只扫上三角?矩阵对称,i-j 和 j-i 是同一条边;扫两遍只是浪费,不会出错 —— 同一对元素第二次 union 会返回 false,什么都不改。

    } /> @@ -2313,24 +2207,15 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, zh={ <>

    - 题意:一棵 n 个节点的树本应只有 n−1 条边, - 现在多给了 1 条,于是图里恰好含一个环。 - edges 按输入顺序给出,要求返回那条多余的边; - 若有多条候选,返回在输入里最后出现的那条。 + 题意:一棵 n 个节点的树本应只有 n−1 条边,现在多给了 1 条,于是图里恰好含一个环。edges 按输入顺序给出,要求返回那条多余的边;若有多条候选,返回在输入里最后出现的那条。

    - 思路:树的定义是「连通且无环」。逐条边做 union: - 正常情况下一条边的两个端点分属不同集合,合并成功,连通块少一个; - 但一旦某条边的两端已经同根,说明它们之间早有路径, - 再接上这条边就闭合成环 —— 它就是那条冗余边。 + 思路:树的定义是「连通且无环」。逐条边做 union:正常情况下一条边的两个端点分属不同集合,合并成功,连通块少一个;但一旦某条边的两端已经同根,说明它们之间早有路径,再接上这条边就闭合成环 —— 它就是那条冗余边。

    为什么天然就是「最后出现」的那条? - 图里恰好只有一个环。不在环上的边连接的是两个原本分离的部分, - 永远不会触发这个判断;而环上的边中,除了输入顺序里最后一条, - 其余都在环闭合之前就加进去了。所以触发判断的边是 - 唯一可能触发的那条,而它正是环上输入顺序最后的那条边。 - 下面按边逐步合并 parent 数组,冲突边的两端会被标出。 + 图里恰好只有一个环。不在环上的边连接的是两个原本分离的部分,永远不会触发这个判断;而环上的边中,除了输入顺序里最后一条,其余都在环闭合之前就加进去了。所以触发判断的边是 + 唯一可能触发的那条,而它正是环上输入顺序最后的那条边。下面按边逐步合并 parent 数组,冲突边的两端会被标出。

    } @@ -2390,8 +2275,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, zh: ( <> 节点编号从 1 开始,所以数组开 n + 1 格,0 - 号位闲置。用 connected 判断意图最直白; - 也可以写成 if (!uf.union(u, v)) return e; —— + 号位闲置。用 connected 判断意图最直白;也可以写成 if (!uf.union(u, v)) return e; —— §04 让 union 返回 boolean 正是为了这个场景。 ), @@ -2465,13 +2349,8 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, } zh={

    - 时间 O(n·α(n)):n 条边,每条边一次 union, - 每次 union 内含两次 find;空间 O(n) 存 parent 数组。 - 追问:LC 685 冗余连接 II 把图改成有向,难度陡增 —— - 多出来的边会造成两类问题:某个节点入度变成 2(有了两个父节点), - 或者图里出现有向环,两者还可能同时发生。 - 必须先分类讨论、锁定候选边,再用并查集验证, - 不能像本题一样一路 union 到底。 + 时间 O(n·α(n)):n 条边,每条边一次 union,每次 union 内含两次 find;空间 O(n) 存 parent 数组。追问:LC 685 冗余连接 II 把图改成有向,难度陡增 —— + 多出来的边会造成两类问题:某个节点入度变成 2(有了两个父节点),或者图里出现有向环,两者还可能同时发生。必须先分类讨论、锁定候选边,再用并查集验证,不能像本题一样一路 union 到底。

    } /> @@ -2528,21 +2407,15 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`,

    题意:一张只含 '1'(陆地)和 '0'(水) 的网格,上下左右相邻的陆地连成一座岛,求岛屿总数。 - 更常见的解法是 DFS/BFS 淹没法,图论章会细讲。 - 这里换并查集视角:把每个陆地格子看成一个节点, - 相邻的两块陆地之间连一条边,最后剩几个连通块就是几座岛。 + 更常见的解法是 DFS/BFS 淹没法,图论章会细讲。这里换并查集视角:把每个陆地格子看成一个节点,相邻的两块陆地之间连一条边,最后剩几个连通块就是几座岛。

    两个要点。其一,二维坐标 (r, c) 要先拍扁成一维下标{" "} id = r×cols + c 才能放进 parent 数组 —— - 这正是数组章讲过的行主序(row-major)展平。 - 其二,每格只需向右邻和下邻看:左邻、上邻在处理更早的格子时 - 已经连过了,重复检查纯属浪费 —— 和 547 只扫上三角是同一个道理。 + 这正是数组章讲过的行主序(row-major)展平。其二,每格只需向右邻和下邻看:左邻、上邻在处理更早的格子时已经连过了,重复检查纯属浪费 —— 和 547 只扫上三角是同一个道理。

    - count 初始为陆地总数(先假设每块陆地各是一座岛), - 之后每成功 union 一次就少一座岛。 - 下面把 2×4 网格拍扁,扫描并合并,看 count 从 5 递减。 + count 初始为陆地总数(先假设每块陆地各是一座岛),之后每成功 union 一次就少一座岛。下面把 2×4 网格拍扁,扫描并合并,看 count 从 5 递减。

    } @@ -2738,16 +2611,13 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, zh={ <>

    - 平心而论,这道题 DFS 淹没法更短也更好读: - 从任一块陆地出发,递归把整座岛染成水,发起了几次染色就是几座岛。 + 平心而论,这道题 DFS 淹没法更短也更好读:从任一块陆地出发,递归把整座岛染成水,发起了几次染色就是几座岛。 图论章会用这个思路把本题再解一遍。 并查集在这里并不占优:要多写一个模板类,还得手动做二维转一维。

    那并查集的主场在哪?在程序运行过程中不断新增陆地的场景 —— - 见 LC 305《岛屿数量 II》:新陆地一块块冒出来, - 每加一块都要立刻报出当前岛数。DFS 每次都得重扫全图, - 而并查集只需把新格子和它的四个邻居 union 一下,随到随答。 + 见 LC 305《岛屿数量 II》:新陆地一块块冒出来,每加一块都要立刻报出当前岛数。DFS 每次都得重扫全图,而并查集只需把新格子和它的四个邻居 union 一下,随到随答。 静态网格数一次用 DFS,持续动态合并用并查集。

    @@ -2810,8 +2680,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, zh: ( <> 并查集只做两件事:find 返回一个元素所在集合的根,union - 合并两个集合。两个元素连通,当且仅当它们的根相同。 - 它放弃路径信息,换来廉价的动态连通性维护。 + 合并两个集合。两个元素连通,当且仅当它们的根相同。它放弃路径信息,换来廉价的动态连通性维护。 ), }, @@ -2826,9 +2695,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, ), zh: ( <> - 一个 parent 数组就是整片森林。parent[i] = i 标记根, - 不额外占内存,还让 find 的循环条件变成一次比较。 - 继堆之后,这是第二次「数组扮演树」。 + 一个 parent 数组就是整片森林。parent[i] = i 标记根,不额外占内存,还让 find 的循环条件变成一次比较。继堆之后,这是第二次「数组扮演树」。 ), }, @@ -2846,8 +2713,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, zh: ( <> 两个优化各司其职:路径压缩在 find 时压平已经形成的路径, - 按秩合并在 union 时阻止高树长出来。 - 单用其中一个是均摊 O(log n);两个叠加,m 次操作是 O(m·α(n)) —— + 按秩合并在 union 时阻止高树长出来。单用其中一个是均摊 O(log n);两个叠加,m 次操作是 O(m·α(n)) —— 近乎常数,但不是 O(1)。 ), @@ -2864,9 +2730,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, ), zh: ( <> - union 永远先找出两边的根 —— 它合并的是集合,不是个别元素。 - 统计连通块时,count 初始为 n,只在 union 真的合并了才减 1; - 两端本来就同根的 union 绝不能减。 + union 永远先找出两边的根 —— 它合并的是集合,不是个别元素。统计连通块时,count 初始为 n,只在 union 真的合并了才减 1;两端本来就同根的 union 绝不能减。 ), }, @@ -2883,8 +2747,7 @@ uf.union(ids.get("a@x.com"), ids.get("b@x.com"));`, ), zh: ( <> - 选型口诀:连接不断加入、只问连通性 → 并查集; - 要具体路径 → BFS/DFS;key 不是 0 到 n−1 的整数 → + 选型口诀:连接不断加入、只问连通性 → 并查集;要具体路径 → BFS/DFS;key 不是 0 到 n−1 的整数 → 先用哈希表映射成编号;需要把元素从集合里拿走 → 并查集不能拆分,若能提前看到全部操作,就倒序处理。 diff --git a/app/union-find/viz.tsx b/app/union-find/viz.tsx index 7cd59da..af63956 100644 --- a/app/union-find/viz.tsx +++ b/app/union-find/viz.tsx @@ -372,8 +372,7 @@ export function UFLab({ zh={ <> 按秩合并已生效:每次都是矮树挂高树,最深的节点距离根也只有{" "} - {depth} 步。单靠按秩合并,树高就被压在 O(log n) 以内。 - 关掉开关再跑一次,对比一下。 + {depth} 步。单靠按秩合并,树高就被压在 O(log n) 以内。关掉开关再跑一次,对比一下。 } /> @@ -391,9 +390,7 @@ export function UFLab({ zh={ <> 退化情形:不按秩合并时,每次都把旧的根挂到一个新的单节点下面, - 10 个元素连成了一条链。最深的节点距离根 {depth} 步, - 此时 find 的代价是 O(n),和扫一遍链表没有区别。 - 打开下面的开关再跑一次。 + 10 个元素连成了一条链。最深的节点距离根 {depth} 步,此时 find 的代价是 O(n),和扫一遍链表没有区别。打开下面的开关再跑一次。 } /> diff --git a/lib/advanced-problems.tsx b/lib/advanced-problems.tsx index f6382f5..263b759 100644 --- a/lib/advanced-problems.tsx +++ b/lib/advanced-problems.tsx @@ -36,10 +36,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 前缀和:pre[i] = 前 i 个元素之和,sumRange(l, r) = pre[r+1] − pre[l]。 - 预处理 O(n),此后每次查询 O(1),实现只要三行。把它和 LC 307 - 放在一起看:两题只差「数组能不能改」这一个条件,答案就从三行前缀和 - 变成一棵线段树 —— 操作组合决定选型,这对姊妹题讲得最清楚。 + 前缀和:pre[i] = 前 i 个元素之和,sumRange(l, r) = pre[r+1] − pre[l]。预处理 O(n),此后每次查询 O(1),实现只要三行。把它和 LC 307 + 放在一起看:两题只差「数组能不能改」这一个条件,答案就从三行前缀和变成一棵线段树 —— 操作组合决定选型,这对姊妹题讲得最清楚。 ), }, @@ -72,8 +70,7 @@ export const PROBLEMS: Problem[] = [ <> 取一个质数当桶数(比如 769),每个桶挂一条链表(或小的动态数组): hash(key) = key % 769 定位桶,桶内线性查找处理冲突。add / remove / - contains 平均 O(1)。用本章的眼光重看:哈希集合本身就是「数组 + 链表」 - 拼出来的组合结构 —— 你在第 6 章就已经见过组合设计了。 + contains 平均 O(1)。用本章的眼光重看:哈希集合本身就是「数组 + 链表」拼出来的组合结构 —— 你在第 6 章就已经见过组合设计了。 ), }, @@ -107,10 +104,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 哈希表存 key → 链表节点引用(一步定位),双向链表按访问序排列 - (头新尾旧,维护顺序)。get 命中就把节点摘下来插回头部;put 超容量就摘掉 - tail.prev,并同步删除它的哈希条目。哑头哑尾省掉全部判空。 - 必须双向:摘除一个节点要改前驱的 next,单链表的节点拿不到前驱。§02 + 哈希表存 key → 链表节点引用(一步定位),双向链表按访问序排列(头新尾旧,维护顺序)。get 命中就把节点摘下来插回头部;put 超容量就摘掉 + tail.prev,并同步删除它的哈希条目。哑头哑尾省掉全部判空。必须双向:摘除一个节点要改前驱的 next,单链表的节点拿不到前驱。§02 有完整推导 + 逐行实现 + 交互实验室。 ), @@ -145,9 +140,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> pre[i][j] = 以 (0,0) 到 (i−1,j−1) 为对角的矩形和。任意子矩形 = - pre[r2+1][c2+1] − pre[r1][c2+1] − pre[r2+1][c1] + pre[r1][c1]: - 减上、减左,左上角那块被减了两次,再加回来一次。预处理 O(mn),查询 O(1)。 - 建表时用同一个思路:pre[i][j] = 元素 + 上 + 左 − 左上。 + pre[r2+1][c2+1] − pre[r1][c2+1] − pre[r2+1][c1] + pre[r1][c1]:减上、减左,左上角那块被减了两次,再加回来一次。预处理 O(mn),查询 O(1)。建表时用同一个思路:pre[i][j] = 元素 + 上 + 左 − 左上。 ), }, @@ -216,11 +209,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 三份状态:key → (val, freq);freq → 该频次的有序桶(桶内按时间序, - 天然是个小 LRU);再加一个 minFreq 变量。访问 = 把 key 从 freq 桶搬进 - freq+1 桶;淘汰 = 移除 minFreq 桶里最老的 key,也就是「频次最低者中最久未用的那个」。 - minFreq 不用搜索:旧桶被搬空时 +1,插入新 key 时归 1。所有操作 O(1)。 - §03 有分桶图解和三语言核心实现。 + 三份状态:key → (val, freq);freq → 该频次的有序桶(桶内按时间序,天然是个小 LRU);再加一个 minFreq 变量。访问 = 把 key 从 freq 桶搬进 + freq+1 桶;淘汰 = 移除 minFreq 桶里最老的 key,也就是「频次最低者中最久未用的那个」。minFreq 不用搜索:旧桶被搬空时 +1,插入新 key 时归 1。所有操作 O(1)。§03 有分桶图解和三语言核心实现。 ), }, @@ -257,9 +247,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 先把数值离散化成排名 1..n(排序去重后二分定位)。从右到左遍历:ans[i] = - query(rank − 1)(已登记的、比它小的个数),然后 add(rank, 1) 把自己登记进去。 - 「边插入、边问前缀和」正是树状数组的主场,整体 O(n log n)。 - 归并排序统计逆序对也能解,但 BIT 版短得多。 + query(rank − 1)(已登记的、比它小的个数),然后 add(rank, 1) 把自己登记进去。「边插入、边问前缀和」正是树状数组的主场,整体 O(n log n)。归并排序统计逆序对也能解,但 BIT 版短得多。 ), }, @@ -295,9 +283,7 @@ export const PROBLEMS: Problem[] = [ <> 每个节点存一个 next[] 指针数组(长度 = 它的层数)。search 从顶层开始,右邻比目标小就向右走,否则下楼;add 先像 search - 一样走一遍、记下每层最后停留的节点 update[i],再逐层做普通链表插入 - (层数由抛硬币决定:每多长一层的概率是 1/2);erase 同理逐层绕过目标节点。 - 期望 O(log n),§06 有完整三语言实现。 + 一样走一遍、记下每层最后停留的节点 update[i],再逐层做普通链表插入(层数由抛硬币决定:每多长一层的概率是 1/2);erase 同理逐层绕过目标节点。期望 O(log n),§06 有完整三语言实现。 ), }, diff --git a/lib/advanced-quiz.tsx b/lib/advanced-quiz.tsx index 079d6bf..d295aab 100644 --- a/lib/advanced-quiz.tsx +++ b/lib/advanced-quiz.tsx @@ -60,8 +60,7 @@ export const QUIZ: QuizItem[] = [ zh: ( <> Java 里 new LinkedHashMap<>(cap, 0.75f, true) 加一个{" "} - removeEldestEntry 覆写,就是一个现成的 LRU。它能做到这一点, - 靠的是内部本来就维护着什么? + removeEldestEntry 覆写,就是一个现成的 LRU。它能做到这一点,靠的是内部本来就维护着什么? ), }, diff --git a/lib/array-problems.tsx b/lib/array-problems.tsx index b77b5ab..395f389 100644 --- a/lib/array-problems.tsx +++ b/lib/array-problems.tsx @@ -112,9 +112,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 标准闭区间二分:while (left ≤ right),nums[mid] 与 target 分三种情况。 - 写完默背三个细节:循环条件、区间怎么收缩、Java 里防溢出的 mid 写法。 - 这是后续所有二分变体(找边界、旋转数组)的地基。 + 标准闭区间二分:while (left ≤ right),nums[mid] 与 target 分三种情况。写完默背三个细节:循环条件、区间怎么收缩、Java 里防溢出的 mid 写法。这是后续所有二分变体(找边界、旋转数组)的地基。 ), }, @@ -141,8 +139,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 与 704 同一个模板,唯一的区别是找不到时返回 left —— - 循环结束时 left 正好是「第一个 ≥ target 的位置」。 - 理解这一点,就理解了二分找边界的本质(C++ 的 lower_bound、Python 的 + 循环结束时 left 正好是「第一个 ≥ target 的位置」。理解这一点,就理解了二分找边界的本质(C++ 的 lower_bound、Python 的 bisect_left)。 ), @@ -171,8 +168,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 三指针从后往前:p1 指 nums1 的有效尾、p2 指 nums2 的尾、p 指 nums1 - 真正的尾。每次把较大者写到 p。从后往前写就不会覆盖还没处理的元素, - 这个「倒着来」的技巧在原地类题目里反复出现。 + 真正的尾。每次把较大者写到 p。从后往前写就不会覆盖还没处理的元素,这个「倒着来」的技巧在原地类题目里反复出现。 ), }, @@ -202,8 +198,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 一次遍历,维护 minPrice 与 maxProfit:每到一天,先用 prices[i] − minPrice - 更新答案,再用 prices[i] 更新 minPrice。时间 O(n)、空间 O(1)。 - 本质是「前缀最小值」思想 —— 很多数组题都是在维护某种前缀信息。 + 更新答案,再用 prices[i] 更新 minPrice。时间 O(n)、空间 O(1)。本质是「前缀最小值」思想 —— 很多数组题都是在维护某种前缀信息。 ), }, @@ -230,8 +225,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> slow 指向「下一个非零元素该放的位置」,fast 扫完全程,遇到非零就与 slow - 交换并 slow++。一次遍历,时间 O(n)、空间 O(1),且保持相对顺序。 - 本章 §08 有逐帧动画。 + 交换并 slow++。一次遍历,时间 O(n)、空间 O(1),且保持相对顺序。本章 §08 有逐帧动画。 ), }, @@ -261,8 +255,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 对撞指针:sum > target 时 right--(只有减小右边的值才能让和变小), - sum < target 时 left++。每一步都能安全排除一个元素,总共 O(n)。 - 「有序 + 找配对」几乎总是对撞指针的信号。 + sum < target 时 left++。每一步都能安全排除一个元素,总共 O(n)。「有序 + 找配对」几乎总是对撞指针的信号。 ), }, @@ -292,8 +285,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 第一遍从左到右,把「左侧前缀积」写进答案数组;第二遍从右到左, - 用一个变量滚动「右侧后缀积」乘上去。时间 O(n),不算输出数组的话额外空间 + 第一遍从左到右,把「左侧前缀积」写进答案数组;第二遍从右到左,用一个变量滚动「右侧后缀积」乘上去。时间 O(n),不算输出数组的话额外空间 O(1)。前缀思想(前缀和 / 前缀积 / 前缀最值)是数组题的常用零件。 ), @@ -320,9 +312,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - Kadane 算法:cur = max(nums[i], cur + nums[i]),ans = max(ans, cur)。 - 一旦前面那段的和变成负数,它只会让后面的和更小,直接丢弃。 - 时间 O(n)、空间 O(1)。它也是进入动态规划最短的一条路:cur + Kadane 算法:cur = max(nums[i], cur + nums[i]),ans = max(ans, cur)。一旦前面那段的和变成负数,它只会让后面的和更小,直接丢弃。时间 O(n)、空间 O(1)。它也是进入动态规划最短的一条路:cur 的状态定义就是「以 i 结尾的子数组的最大和」。 ), @@ -349,8 +339,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 按 start 排序后线性扫描:当前区间的 start ≤ 结果集最后一个区间的 end - 就合并(end 取较大者),否则新开一段。排序主导,总共 O(n log n)。 - 区间题的第一反应:排序 + 一次扫描。 + 就合并(end 取较大者),否则新开一段。排序主导,总共 O(n log n)。区间题的第一反应:排序 + 一次扫描。 ), }, @@ -377,8 +366,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 排序 O(n log n);外层枚举 i(跳过与前一个相同的值),内层用 left/right - 对撞找 −nums[i],命中后两侧同时跳过重复值。总共 O(n²)。 - 「固定一维、把剩下的降为双指针」是三数之和 / 四数之和的通用打法。 + 对撞找 −nums[i],命中后两侧同时跳过重复值。总共 O(n²)。「固定一维、把剩下的降为双指针」是三数之和 / 四数之和的通用打法。 ), }, @@ -403,9 +391,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 先 k %= n,然后 reverse(0, n−1) → reverse(0, k−1) → reverse(k, n−1)。 - 时间 O(n)、空间 O(1)。别忘了 k %= n:k 大于 n 时不取模会越界。 - 翻转技巧是数组原地重排的常客,值得单独记住。 + 先 k %= n,然后 reverse(0, n−1) → reverse(0, k−1) → reverse(k, n−1)。时间 O(n)、空间 O(1)。别忘了 k %= n:k 大于 n 时不取模会越界。翻转技巧是数组原地重排的常客,值得单独记住。 ), }, @@ -432,8 +418,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 四边界模拟:每走完一条边就收缩对应边界(top++ / right-- / bottom-- / - left++),边界交错时停止。走反向的两条边之前要再检查一次 top ≤ bottom、 - left ≤ right,否则单行或单列会被重复输出 —— 这是本题唯一容易出错的地方。 + left++),边界交错时停止。走反向的两条边之前要再检查一次 top ≤ bottom、left ≤ right,否则单行或单列会被重复输出 —— 这是本题唯一容易出错的地方。 ), }, @@ -458,9 +443,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 转置(交换 matrix[i][j] 与 matrix[j][i],只扫上三角)+ 每行 reverse, - 两步都是原地操作,额外空间 O(1)。把一个几何操作拆成两个简单变换, - 比背「四点轮换」公式好记得多。 + 转置(交换 matrix[i][j] 与 matrix[j][i],只扫上三角)+ 每行 reverse,两步都是原地操作,额外空间 O(1)。把一个几何操作拆成两个简单变换,比背「四点轮换」公式好记得多。 ), }, @@ -487,9 +470,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 用第一行和第一列记录「该行 / 该列要清零」,再用两个布尔变量单独记录第一行、 - 第一列自身是否含零。先扫内部区域做标记,再按标记清零,最后处理第一行和第一列。 - 「借数据自身当标记空间」是原地算法的经典手法。 + 用第一行和第一列记录「该行 / 该列要清零」,再用两个布尔变量单独记录第一行、第一列自身是否含零。先扫内部区域做标记,再按标记清零,最后处理第一行和第一列。「借数据自身当标记空间」是原地算法的经典手法。 ), }, @@ -517,8 +498,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 对撞指针 + 两侧最大值:维护 leftMax / rightMax,哪一边的最大值更小就处理哪一边 - —— 那一边的限制已经确定,另一边不可能更矮。累加 max − height 后把指针内移。 - 时间 O(n)、空间 O(1)。它也可以用单调栈解,栈那一章会再遇到同一道题。 + —— 那一边的限制已经确定,另一边不可能更矮。累加 max − height 后把指针内移。时间 O(n)、空间 O(1)。它也可以用单调栈解,栈那一章会再遇到同一道题。 ), }, diff --git a/lib/binary-tree-problems.tsx b/lib/binary-tree-problems.tsx index 793b1d9..1437f74 100644 --- a/lib/binary-tree-problems.tsx +++ b/lib/binary-tree-problems.tsx @@ -42,8 +42,7 @@ export const PROBLEMS: Problem[] = [ 终止条件:两个都空 → true;只有一个空 → false。 合并这一步:值必须相等,并且{" "} same(p.left, q.left) 与{" "} - same(p.right, q.right) 都为 true。较小那棵树的每个节点只访问一次, - 时间 O(n),栈空间 O(h)。这是「双树同步递归」的模板 —— LC 101(对称) + same(p.right, q.right) 都为 true。较小那棵树的每个节点只访问一次,时间 O(n),栈空间 O(h)。这是「双树同步递归」的模板 —— LC 101(对称) 把它改成左对右的镜像版,LC 572(子树)在外面再套一层。 ), @@ -78,11 +77,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 陷阱:最小深度是到叶子的距离,而只有一个孩子的节点不是叶子。 - 直接写 1 + min(左, 右) 会在这种节点上返回 1 —— 空的那侧报了 0。 - 所以递归要特判:一侧为空时只能走另一侧。更干净的解法是 BFS: - 层序遍历,出队时遇到的第一个没有孩子的节点就是答案。它在第一个叶子处就停, - 不必像 DFS 那样把整棵树走完 —— 「求最浅」是 BFS 的主场,「求最深」才是 DFS 的。 + 陷阱:最小深度是到叶子的距离,而只有一个孩子的节点不是叶子。直接写 1 + min(左, 右) 会在这种节点上返回 1 —— 空的那侧报了 0。所以递归要特判:一侧为空时只能走另一侧。更干净的解法是 BFS:层序遍历,出队时遇到的第一个没有孩子的节点就是答案。它在第一个叶子处就停,不必像 DFS 那样把整棵树走完 —— 「求最浅」是 BFS 的主场,「求最深」才是 DFS 的。 ), }, @@ -122,9 +117,7 @@ export const PROBLEMS: Problem[] = [ rest」。终止条件:空节点返回 false;叶子返回{" "} rest == node.val。合并这一步: hasPath(左, rest − val) || hasPath(右, rest − val) —— - 有一条就够。时间 O(n),栈空间 O(h)。判定必须发生在叶子上: - 不能在 rest 减到 0 时提前返回,因为下面可能还有节点继续加。 - 这是「参数下传」型递归的最小样板 —— 参数装着祖先已经贡献的部分。 + 有一条就够。时间 O(n),栈空间 O(h)。判定必须发生在叶子上:不能在 rest 减到 0 时提前返回,因为下面可能还有节点继续加。这是「参数下传」型递归的最小样板 —— 参数装着祖先已经贡献的部分。 ), }, @@ -158,11 +151,8 @@ export const PROBLEMS: Problem[] = [ zh: ( <> DFS 多带一个参数:目前拼好的路径。到叶子时拼成{" "} - "1->2->5" 收进结果。字符串参数在每次调用时被复制, - 每条分支各拿一份,不需要手动撤销;如果改用列表存路径, - 递归返回后必须把最后一个元素弹掉,兄弟分支才能从正确状态出发 —— - 这个「撤销」动作就是回溯(backtracking),本题是它第一次露面。 - 生成全部路径的时间是 O(n · h),因为路径字符串的总长度就是这个量级。 + "1->2->5" 收进结果。字符串参数在每次调用时被复制,每条分支各拿一份,不需要手动撤销;如果改用列表存路径,递归返回后必须把最后一个元素弹掉,兄弟分支才能从正确状态出发 —— + 这个「撤销」动作就是回溯(backtracking),本题是它第一次露面。生成全部路径的时间是 O(n · h),因为路径字符串的总长度就是这个量级。 ), }, @@ -202,12 +192,9 @@ export const PROBLEMS: Problem[] = [ 这是「返回值和答案不是同一个东西」最经典的例子。 返回值的含义: depth(node) 返回「从 node 往下延伸的最长路径上有几个节点」, - depth(null) = 0 —— 这是父节点需要的东西。答案是直径 - (按边数算),用递归之外的一个变量收集。在每个节点上, - depth(左) + depth(右) 正是「在这里拐弯」的那条路径的边数, - 返回前拿它挑战一下最大值。而返回给父亲的是{" "} - 1 + max(depth(左), depth(右)):路径继续往上走时只能取一侧, - 不能分叉。每个节点访问一次,时间 O(n),栈空间 O(h)。LC 124 是同一形状的困难版。 + depth(null) = 0 —— 这是父节点需要的东西。答案是直径(按边数算),用递归之外的一个变量收集。在每个节点上, + depth(左) + depth(右) 正是「在这里拐弯」的那条路径的边数,返回前拿它挑战一下最大值。而返回给父亲的是{" "} + 1 + max(depth(左), depth(右)):路径继续往上走时只能取一侧,不能分叉。每个节点访问一次,时间 O(n),栈空间 O(h)。LC 124 是同一形状的困难版。 ), }, @@ -247,12 +234,10 @@ export const PROBLEMS: Problem[] = [ <> 朴素做法在每个节点都单独调一次求高度的函数,高度被反复重算,最坏 O(n²)。 改法:在同一次后序遍历里既算高度、又判平衡。返回值的含义: - 按节点数计的子树高度(空树为 0、叶子为 1),或者用 −1 表示「下面已经失衡了」。 - 这里改按节点数计高度(本章其他地方按边数计,空树为 −1),正是为了把 −1 空出来当信号。 + 按节点数计的子树高度(空树为 0、叶子为 1),或者用 −1 表示「下面已经失衡了」。这里改按节点数计高度(本章其他地方按边数计,空树为 −1),正是为了把 −1 空出来当信号。 合并这一步:任何一个孩子返回 −1 就立刻返回 −1;否则若{" "} |左 − 右| > 1 返回 −1;否则返回{" "} - 1 + max(左, 右)。一趟走完,时间 O(n),栈空间 O(h)。 - 「用一个特殊返回值携带失败信号」是自底向上递归的常用技巧。 + 1 + max(左, 右)。一趟走完,时间 O(n),栈空间 O(h)。「用一个特殊返回值携带失败信号」是自底向上递归的常用技巧。 ), }, @@ -284,9 +269,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - BFS:层序遍历,每层取最后一个节点,分层靠「先记 size」。 - DFS 版同样简短:按「根 → 右 → 左」的顺序遍历,并把当前深度当参数带下去, - 每个深度第一次到达的节点就是右视图,满足{" "} + BFS:层序遍历,每层取最后一个节点,分层靠「先记 size」。DFS 版同样简短:按「根 → 右 → 左」的顺序遍历,并把当前深度当参数带下去,每个深度第一次到达的节点就是右视图,满足{" "} depth == 结果长度 时收进答案。两者时间都是 O(n); BFS 吃 O(w) 队列空间,DFS 吃 O(h) 栈空间。面试常在你答完一种后追问另一种。 @@ -324,11 +307,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 前序 = [根 | 左子树 | 右子树],中序 = [左子树 | 根 | 右子树]。 - 每一轮:取前序的首元素当根,在中序区间里定位它,读出左半部分的长度 k; - k 就告诉你前序里哪 k 个值属于左子树 —— 两边各自递归到更小的区间。 - 每次都去中序里线性查找是最坏 O(n²);先用哈希表存好「值 → 下标」, - 每次查找降到 O(1),整体 O(n)。前提是节点值互不相同 —— 题目保证了这一点。 + 前序 = [根 | 左子树 | 右子树],中序 = [左子树 | 根 | 右子树]。每一轮:取前序的首元素当根,在中序区间里定位它,读出左半部分的长度 k; + k 就告诉你前序里哪 k 个值属于左子树 —— 两边各自递归到更小的区间。每次都去中序里线性查找是最坏 O(n²);先用哈希表存好「值 → 下标」,每次查找降到 O(1),整体 O(n)。前提是节点值互不相同 —— 题目保证了这一点。 ), }, @@ -366,13 +346,9 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 自底向上:先递归展开左、右子树,再用三步接线 —— 把展开好的左链接到{" "} - root.right,沿 right 走到这条链的尾部, - 把尾部的 right 接上原来的右链,最后{" "} + root.right,沿 right 走到这条链的尾部,把尾部的 right 接上原来的右链,最后{" "} root.left = null。另有一种 Morris 风格的迭代写法, - 额外空间 O(1):对每个节点,把右子树挂到左子树最右节点的下面, - 再把左子树整体移到右边。Morris 风格的做法是靠改写树里的指针来代替栈的; - 真正的 Morris 遍历会把改动过的指针全部复原, - 而本题的改动本身就是要求的结果,所以保留。核心考点: + 额外空间 O(1):对每个节点,把右子树挂到左子树最右节点的下面,再把左子树整体移到右边。Morris 风格的做法是靠改写树里的指针来代替栈的;真正的 Morris 遍历会把改动过的指针全部复原,而本题的改动本身就是要求的结果,所以保留。核心考点: 信任递归已经把子问题做完,只设计「合并」这一步。 ), @@ -419,11 +395,7 @@ export const PROBLEMS: Problem[] = [ lca(node) 在这棵子树里既没有 p 也没有 q 时返回 null; 两个都在时返回最近公共祖先;只找到其中一个时返回找到的那一个。 终止条件:空节点返回 null;节点本身是 p 或 q 就返回自己。 - 合并这一步:左右都返回了非空 ⇒ p、q 分居两侧,当前节点就是最近公共祖先; - 只有一侧非空 ⇒ 把那一侧的结果原样上报。一趟后序,时间 O(n),栈空间 O(h)。 - 它的正确性依赖题目的前提:p 和 q 一定都在树里。 - 如果不保证,q 不存在时函数会把 p 返回上去。这题是全书讲「设计返回值语义」 - 最好的一课:返回值不是答案本身,而是携带足够信息、让父节点能下判断的信号。 + 合并这一步:左右都返回了非空 ⇒ p、q 分居两侧,当前节点就是最近公共祖先;只有一侧非空 ⇒ 把那一侧的结果原样上报。一趟后序,时间 O(n),栈空间 O(h)。它的正确性依赖题目的前提:p 和 q 一定都在树里。如果不保证,q 不存在时函数会把 p 返回上去。这题是全书讲「设计返回值语义」最好的一课:返回值不是答案本身,而是携带足够信息、让父节点能下判断的信号。 ), }, @@ -463,12 +435,9 @@ export const PROBLEMS: Problem[] = [ 返回值的含义: gain(node) 返回「从 node 出发、只向下、只走一个方向 的路径的最大和」,即{" "} - val + max(gain(左), gain(右), 0)。这个 0 是与 543 最大的不同: - 总和为负的子树不如不要。答案单独收集:在每个节点上, - val + max(gain(左), 0) + max(gain(右), 0) 是「在这里拐弯」 - 的最优路径,用它挑战全局最大值。返回值只能带一条腿 —— - 路径经过 node 继续往上时不能分叉。时间 O(n),栈空间 O(h)。 - 把 543、110、124 连着做完,「自底向上返回值 + 单独的全局答案」这一套就掌握了。 + val + max(gain(左), gain(右), 0)。这个 0 是与 543 最大的不同:总和为负的子树不如不要。答案单独收集:在每个节点上, + val + max(gain(左), 0) + max(gain(右), 0) 是「在这里拐弯」的最优路径,用它挑战全局最大值。返回值只能带一条腿 —— + 路径经过 node 继续往上时不能分叉。时间 O(n),栈空间 O(h)。把 543、110、124 连着做完,「自底向上返回值 + 单独的全局答案」这一套就掌握了。 ), }, diff --git a/lib/binary-tree-quiz.tsx b/lib/binary-tree-quiz.tsx index bb5c238..33af5a8 100644 --- a/lib/binary-tree-quiz.tsx +++ b/lib/binary-tree-quiz.tsx @@ -107,8 +107,7 @@ export const QUIZ: QuizItem[] = [ ), zh: ( <> - 一棵小树:根 4,左孩子 2(它的左右孩子是 1、3),右孩子 6。 - 它的中序遍历输出是?(数字用空格或逗号分隔) + 一棵小树:根 4,左孩子 2(它的左右孩子是 1、3),右孩子 6。它的中序遍历输出是?(数字用空格或逗号分隔) ), }, diff --git a/lib/bst-problems.tsx b/lib/bst-problems.tsx index 29df7ad..a377ac6 100644 --- a/lib/bst-problems.tsx +++ b/lib/bst-problems.tsx @@ -37,9 +37,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 从根出发:相等即命中;小往左、大往右;撞到空孩子就说明整棵树都没有。 - 迭代版一个 while 循环写完,O(h) 时间、O(1) 额外空间。 - 这是 BST 的裸模板题,后面所有题的第一步都藏着这个动作。 + 从根出发:相等即命中;小往左、大往右;撞到空孩子就说明整棵树都没有。迭代版一个 while 循环写完,O(h) 时间、O(1) 额外空间。这是 BST 的裸模板题,后面所有题的第一步都藏着这个动作。 ), }, @@ -73,10 +71,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 两条路:① 任意遍历 + 哈希集合查 k − v,O(n) 时间 O(n) 空间, - 连 BST 性质都不需要;② 中序展开成升序数组 + 对撞双指针(即 LC 167 的做法), - 同样 O(n),但用上了 BST 的有序性。面试中更进一步的答法:用两个 BST 迭代器分别从最小、 - 最大两端向中间逼近,空间压到 O(h)。 + 两条路:① 任意遍历 + 哈希集合查 k − v,O(n) 时间 O(n) 空间,连 BST 性质都不需要;② 中序展开成升序数组 + 对撞双指针(即 LC 167 的做法),同样 O(n),但用上了 BST 的有序性。面试中更进一步的答法:用两个 BST 迭代器分别从最小、最大两端向中间逼近,空间压到 O(h)。 ), }, @@ -110,9 +105,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 中序遍历时维护 prev(上一个访问的值),每步用 cur − prev 更新答案。 - 为什么只看相邻:有序序列里任意两数之差,都不小于它们之间某对相邻数之差。 - 一次中序 O(n)、栈空间 O(h)。口诀:BST 题看到「差值 / 相邻 / 第 k」先想中序。 + 中序遍历时维护 prev(上一个访问的值),每步用 cur − prev 更新答案。为什么只看相邻:有序序列里任意两数之差,都不小于它们之间某对相邻数之差。一次中序 O(n)、栈空间 O(h)。口诀:BST 题看到「差值 / 相邻 / 第 k」先想中序。 ), }, @@ -143,8 +136,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> DFS + 有序性剪枝:val < low → 左子树全体更小,只递归右子树; - val > high → 只递归左子树;落在区间内 → 累加自身 + 两边递归。 - 最坏 O(n),但剪枝能把大量子树整棵跳过 —— + val > high → 只递归左子树;落在区间内 → 累加自身 + 两边递归。最坏 O(n),但剪枝能把大量子树整棵跳过 —— 这题最能体会「BST 的有序性同时也是一种省事的手段」。 ), @@ -178,8 +170,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 递归:node 为空就返回 new TreeNode(v);v 小挂左、大挂右, - 最后返回 node 本身,让父节点重新牵手。O(h)。关键认知: + 递归:node 为空就返回 new TreeNode(v);v 小挂左、大挂右,最后返回 node 本身,让父节点重新牵手。O(h)。关键认知: 插入永远发生在一个空的孩子位置,树的中间结构一个都不动 —— 这正是 BST 比有序数组插入便宜的原因。 @@ -215,10 +206,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 从根出发:p、q 都小于当前节点 → 往左;都大 → 往右;一大一小 - (或其中一个就等于当前节点)→ 当前节点就是答案。一个循环,O(h)。 - 对照普通二叉树的 LC 236:没有有序性就得后序遍历自底向上回传信息,O(n)。 - 有序性把「全树搜索」降成了「单路下降」,两题放一起答最能体现理解深度。 + 从根出发:p、q 都小于当前节点 → 往左;都大 → 往右;一大一小(或其中一个就等于当前节点)→ 当前节点就是答案。一个循环,O(h)。对照普通二叉树的 LC 236:没有有序性就得后序遍历自底向上回传信息,O(n)。有序性把「全树搜索」降成了「单路下降」,两题放一起答最能体现理解深度。 ), }, @@ -253,8 +241,7 @@ export const PROBLEMS: Problem[] = [ 递归定位后分三种情况:没有孩子 → 返回 null;只有一个孩子 → 返回那个孩子,让父节点直接接管;两个孩子 → 把中序后继(右子树最小值)的值抄到当前节点,再去右子树里删掉后继本体 - —— 后继必无左孩子,这次删除一定落入前两种简单情况,递归自然终止。 - O(h)。§04 有完整的三语言实现,这题必须能盲写。 + —— 后继必无左孩子,这次删除一定落入前两种简单情况,递归自然终止。O(h)。§04 有完整的三语言实现,这题必须能盲写。 ), }, @@ -286,9 +273,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 维护显式栈:初始化时把根的「左脊」(根以及一路向左的所有节点)入栈; - next() 弹出栈顶返回,若它有右孩子,就把右孩子的左脊也入栈。 - 每个节点恰好入栈、出栈各一次,next 均摊 O(1)、空间 O(h)。 - 这是「把递归改造成可暂停迭代」的经典范式,653 的双迭代器解法就建立在它之上。 + next() 弹出栈顶返回,若它有右孩子,就把右孩子的左脊也入栈。每个节点恰好入栈、出栈各一次,next 均摊 O(1)、空间 O(h)。这是「把递归改造成可暂停迭代」的经典范式,653 的双迭代器解法就建立在它之上。 ), }, @@ -321,10 +306,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - BST 的中序应严格升序;两个节点被交换会制造一处(原本相邻) - 或两处(原本不相邻)逆序。中序扫描:第一处逆序取前者为 first, - 最后一处逆序取后者为 second,交换两者的值即可。O(n) 时间、O(h) 栈空间。 - 追问 O(1) 空间就答 Morris 中序 —— + BST 的中序应严格升序;两个节点被交换会制造一处(原本相邻)或两处(原本不相邻)逆序。中序扫描:第一处逆序取前者为 first,最后一处逆序取后者为 second,交换两者的值即可。O(n) 时间、O(h) 栈空间。追问 O(1) 空间就答 Morris 中序 —— 借用每个节点的中序前驱空着的右指针当临时的「回程线索」,属于进阶话题,本课不展开。 ), diff --git a/lib/bst-quiz.tsx b/lib/bst-quiz.tsx index 319d15a..722a352 100644 --- a/lib/bst-quiz.tsx +++ b/lib/bst-quiz.tsx @@ -17,8 +17,7 @@ export const QUIZ: QuizItem[] = [ ), zh: ( <> - 一棵树:根 10,左孩子 5,右孩子 15;15 的左孩子是 6、右孩子是 20。 - 每对父子关系(5<10、15>10、6<15、20>15)都合规 —— 它是 BST 吗? + 一棵树:根 10,左孩子 5,右孩子 15;15 的左孩子是 6、右孩子是 20。每对父子关系(5<10、15>10、6<15、20>15)都合规 —— 它是 BST 吗? ), }, diff --git a/lib/graph-problems.tsx b/lib/graph-problems.tsx index 155209f..470055a 100644 --- a/lib/graph-problems.tsx +++ b/lib/graph-problems.tsx @@ -48,8 +48,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 记下起点原色 old,从起点 DFS/BFS - 向四个方向扩散:只递归「颜色 == old 且在界内」的格子,进门就改成新色。 - 常见错误:若新色 == old 会无限递归,要先判 old == newColor{" "} + 向四个方向扩散:只递归「颜色 == old 且在界内」的格子,进门就改成新色。常见错误:若新色 == old 会无限递归,要先判 old == newColor{" "} 直接返回。网格题的四方向模板{" "} dirs=[[-1,0],[1,0],[0,-1],[0,1]] 从这里练熟。 @@ -92,9 +91,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 对每个未访问的陆地启动 DFS,DFS 返回它淹没的格子数(1 + - 四个方向递归之和),越界或遇水返回 0。主循环用 max 记录最大返回值。 - 时间 O(行 × 列),每格访问一次。 - 「让 DFS 带返回值统计规模」是网格题常见的扩展。 + 四个方向递归之和),越界或遇水返回 0。主循环用 max 记录最大返回值。时间 O(行 × 列),每格访问一次。「让 DFS 带返回值统计规模」是网格题常见的扩展。 ), }, @@ -145,8 +142,7 @@ export const PROBLEMS: Problem[] = [ {" "} 出发 DFS/BFS,把连通的 O 全标成安全(比如临时记为{" "} #)。扫完后,剩下还是 O 的必然被包围 → 改成{" "} - X;标过 # 的还原成 O。 - 「从边界倒着染色」避开了对每个内部区域单独判断是否触边。 + X;标过 # 的还原成 O。「从边界倒着染色」避开了对每个内部区域单独判断是否触边。 ), }, @@ -190,12 +186,9 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 多源 BFS:先把所有初始烂橘子一次性入队(这是本题精髓), - 并记录新鲜橘子总数。然后一层层扩散, + 多源 BFS:先把所有初始烂橘子一次性入队(这是本题精髓),并记录新鲜橘子总数。然后一层层扩散, 每处理完一层 minute += 1 - (用「先记 size」的按层技巧,呼应二叉树层序); - 每腐蚀一个新鲜橘子就把计数减 1。最后若还有新鲜橘子返回 -1。 - 每一步的代价都是同样的一分钟,所以 BFS 的层数正好等于经过的时间 —— + (用「先记 size」的按层技巧,呼应二叉树层序);每腐蚀一个新鲜橘子就把计数减 1。最后若还有新鲜橘子返回 -1。每一步的代价都是同样的一分钟,所以 BFS 的层数正好等于经过的时间 —— 这就是它比 DFS 适合此题的原因。 ), @@ -242,8 +235,7 @@ export const PROBLEMS: Problem[] = [ 用哈希表 Map<原节点, 克隆节点> 当「访问记录 + 去重表」二合一。DFS/BFS 到某点:若 map 里已有克隆就直接返回(防环、防重复);否则新建克隆 - 先存进 map,再递归克隆每个邻居并接到克隆节点的邻居表上。 - 「先存再递归」正是环能终止的原因。图题里 visited + 先存进 map,再递归克隆每个邻居并接到克隆节点的邻居表上。「先存再递归」正是环能终止的原因。图题里 visited 常常就是一张顺便携带数据的哈希表。 ), @@ -287,11 +279,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - Kahn 入度法:建邻接表 + 入度数组,把入度为 0 的课先入队; - 每出队一门课就追加到答案序列,并把它后继课的入度各减 1,减到 0 的入队。 - 若最终答案长度 == 课程数就是合法拓扑序,否则说明剩下的课困在环里, - 返回空数组。DFS 写法同样可行:后序遍历的逆序就是一个拓扑序。 - 两种都是 O(V + E)。 + Kahn 入度法:建邻接表 + 入度数组,把入度为 0 的课先入队;每出队一门课就追加到答案序列,并把它后继课的入度各减 1,减到 0 的入队。若最终答案长度 == 课程数就是合法拓扑序,否则说明剩下的课困在环里,返回空数组。DFS 写法同样可行:后序遍历的逆序就是一个拓扑序。两种都是 O(V + E)。 ), }, @@ -315,8 +303,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 顺着「水往低处流」逐格判断太贵。反过来想:从海洋边界出发, - 水能倒着「爬」到哪些格子? + 顺着「水往低处流」逐格判断太贵。反过来想:从海洋边界出发,水能倒着「爬」到哪些格子? ), }, @@ -336,11 +323,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 逆向思维:分别从太平洋边界(上边 + 左边)和大西洋边界(下边 + 右边)出发, - 只走「高度 ≥ 当前格」的方向 —— 这正是「水往低处流」的反向。 - 各自标记能到达的格子,得到两个布尔矩阵, - 两个集合的交集就是答案。 - 两个关键转念:多个起点一起搜、把「流出去」反转成「能被谁到达」。 + 逆向思维:分别从太平洋边界(上边 + 左边)和大西洋边界(下边 + 右边)出发,只走「高度 ≥ 当前格」的方向 —— 这正是「水往低处流」的反向。各自标记能到达的格子,得到两个布尔矩阵, + 两个集合的交集就是答案。两个关键转念:多个起点一起搜、把「流出去」反转成「能被谁到达」。 ), }, @@ -367,8 +351,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 普通 Dijkstra 会被「最多中转 K 站」绊住: - 到某城最便宜的走法可能中转太多次。步数受限时,要按「轮」推进。 + 普通 Dijkstra 会被「最多中转 K 站」绊住:到某城最便宜的走法可能中转太多次。步数受限时,要按「轮」推进。 ), }, @@ -391,11 +374,8 @@ export const PROBLEMS: Problem[] = [ <> 最多中转 K 站 = 最多走 K + 1 条边,所以做{" "} K + 1 轮 Bellman-Ford 松弛。每一轮都基于 - 上一轮 dist 的快照去更新所有边(关键:用临时数组, - 否则一轮内的连续松弛会相互影响,使走过的边数超过限制)。 - 也可用带「已用步数」的 BFS 分层扩展。普通 Dijkstra - 在这里不成立:它可能通过一条已经太长的路径把某个城市便宜地定案。 - 这题正好点出「最短路算法要看约束选型」。 + 上一轮 dist 的快照去更新所有边(关键:用临时数组,否则一轮内的连续松弛会相互影响,使走过的边数超过限制)。也可用带「已用步数」的 BFS 分层扩展。普通 Dijkstra + 在这里不成立:它可能通过一条已经太长的路径把某个城市便宜地定案。这题正好点出「最短路算法要看约束选型」。 ), }, @@ -440,10 +420,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 隐式图 + BFS:顶点是单词,边是「相差一个字母」。 - 不预先建完整图(边太多),而是 BFS 出队一个词时,枚举每一位换 26 - 个字母,在词表(哈希集合)里找存在且未访问的邻居入队。 - 每条边代价相同,所以 BFS 给出的层数就是最少转换次数。进阶可用 + 隐式图 + BFS:顶点是单词,边是「相差一个字母」。不预先建完整图(边太多),而是 BFS 出队一个词时,枚举每一位换 26 + 个字母,在词表(哈希集合)里找存在且未访问的邻居入队。每条边代价相同,所以 BFS 给出的层数就是最少转换次数。进阶可用 双向 BFS:从首尾同时搜、在中间相遇,两边各自要搜的深度都减半。 ), diff --git a/lib/graph-quiz.tsx b/lib/graph-quiz.tsx index a9edf93..22d8ba5 100644 --- a/lib/graph-quiz.tsx +++ b/lib/graph-quiz.tsx @@ -259,8 +259,7 @@ export const QUIZ: QuizItem[] = [ ), zh: ( <> - 在一张边权全为 1(或无权)的图上,求从起点到各点的最短路径, - 最合适的算法是?(填算法名) + 在一张边权全为 1(或无权)的图上,求从起点到各点的最短路径,最合适的算法是?(填算法名) ), }, diff --git a/lib/hash-problems.tsx b/lib/hash-problems.tsx index 836e134..98a2afe 100644 --- a/lib/hash-problems.tsx +++ b/lib/hash-problems.tsx @@ -34,10 +34,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 遍历数组,每个元素先问 Set「见过它吗」:见过就返回 true; - 没见过就 add 进去继续。平均 O(n) 时间、O(n) 额外空间。 - 对比排序解法:O(n log n) 时间、不额外占空间。用空间换时间, - 是本章所有题目的共同底色。 + 遍历数组,每个元素先问 Set「见过它吗」:见过就返回 true;没见过就 add 进去继续。平均 O(n) 时间、O(n) 额外空间。对比排序解法:O(n log n) 时间、不额外占空间。用空间换时间,是本章所有题目的共同底色。 ), }, @@ -67,10 +64,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - Map 存「值 → 最近一次出现的下标」。走到 nums[i] 时,若表里有它, - 且 i − 上次下标 ≤ k,返回 true;否则把下标更新成 i。旧下标只会更远, - 以后永远用不上,可以直接覆盖。平均 O(n) 时间、O(n) 空间。 - 用「长度为 k 的滑动窗口 Set」也可以,思路等价。 + Map 存「值 → 最近一次出现的下标」。走到 nums[i] 时,若表里有它,且 i − 上次下标 ≤ k,返回 true;否则把下标更新成 i。旧下标只会更远,以后永远用不上,可以直接覆盖。平均 O(n) 时间、O(n) 空间。用「长度为 k 的滑动窗口 Set」也可以,思路等价。 ), }, @@ -102,9 +96,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 第一遍:统计 magazine 里 26 个字母各有几个。第二遍:遍历 ransomNote - 逐个扣减,任何一个扣成负数就是库存不足,返回 false。字符集固定且很小时, - 用长度 26 的数组代替 HashMap:下标就是字母本身,连哈希函数都不需要。 - 计数数组就是哈希函数最简单的那种哈希表。O(m + n) 时间、O(1) + 逐个扣减,任何一个扣成负数就是库存不足,返回 false。字符集固定且很小时,用长度 26 的数组代替 HashMap:下标就是字母本身,连哈希函数都不需要。计数数组就是哈希函数最简单的那种哈希表。O(m + n) 时间、O(1) 额外空间(26 不随输入增长)。 ), @@ -137,11 +129,9 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 建立双向映射:char → word 和 word → char 两张表。 - 任何一边已经配了别的伙伴,就返回 false。只存单向会漏判: + 建立双向映射:char → word 和 word → char 两张表。任何一边已经配了别的伙伴,就返回 false。只存单向会漏判: pattern = "abba"、s = "dog dog dog dog" 时, - char → word 只记下 a→dog、b→dog,看起来毫无矛盾; - 反向表才能发现 dog 已经被 a 占用。LC 205(同构字符串) + char → word 只记下 a→dog、b→dog,看起来毫无矛盾;反向表才能发现 dog 已经被 a 占用。LC 205(同构字符串) 是两边都换成字符的同型题。 ), @@ -173,10 +163,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 反复把数替换成「各位数字平方和」,过程要么到 1,要么进入一个永不停止的循环。 - 把每个中间值放进 Set,某个值第二次出现就说明入环,返回 false。 - 每次变换要处理这个数的每一位,是 O(log n) 的工作量;Set 让「是否重复」 - 的判断平均只花 O(1)。追问「不用额外空间行吗」:用链表章的快慢指针判环。 + 反复把数替换成「各位数字平方和」,过程要么到 1,要么进入一个永不停止的循环。把每个中间值放进 Set,某个值第二次出现就说明入环,返回 false。每次变换要处理这个数的每一位,是 O(log n) 的工作量;Set 让「是否重复」的判断平均只花 O(1)。追问「不用额外空间行吗」:用链表章的快慢指针判环。 ), }, @@ -207,11 +194,9 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - nums1 全部入 Set A;遍历 nums2,凡在 A 中的加入结果 Set(自动去重), - 最后转成数组。平均 O(m + n)。三种语言都内置了这类运算:Python{" "} + nums1 全部入 Set A;遍历 nums2,凡在 A 中的加入结果 Set(自动去重),最后转成数组。平均 O(m + n)。三种语言都内置了这类运算:Python{" "} set(a) & set(b)、JS filter +{" "} - has、Java retainAll —— 交集、并集这类集合运算, - 正是 Set 这个类型存在的理由。 + has、Java retainAll —— 交集、并集这类集合运算,正是 Set 这个类型存在的理由。 ), }, @@ -243,9 +228,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 把 A + B + C + D = 0 改写成 (A + B) = −(C + D)。第一步:双层循环枚举 - A、B,用 Map 记录每种和出现了几次,O(n²)。第二步:双层循环枚举 C、D, - 查 −(c + d) 在表里出现了几次,累加进答案。时间与空间都是 O(n²), - 从 n⁴ 降到 n²。「折半 + 哈希配对」就是 meet in the middle + A、B,用 Map 记录每种和出现了几次,O(n²)。第二步:双层循环枚举 C、D,查 −(c + d) 在表里出现了几次,累加进答案。时间与空间都是 O(n²),从 n⁴ 降到 n²。「折半 + 哈希配对」就是 meet in the middle 思想的入门款。 ), @@ -288,11 +271,8 @@ export const PROBLEMS: Problem[] = [ pre[j] = k ⟺ pre[j] = pre[i] − k。于是一边扫一边维护 Map「前缀和 → 出现次数」:每到一个位置,先把 map[pre − k] 累加进答案(有几个这样的 j 就有几个合法子数组),再把当前 pre 的计数 +1。 - Map 必须以 {"{0: 1}"} 起步:空前缀也是合法的 j, - 否则从下标 0 开始的子数组会全部漏掉。O(n) 时间、O(n) 空间。 - 元素可能为负,窗口和不单调,滑动窗口在这里失效 —— - 这正是前缀和 + 哈希登场的原因。它是「两数之和」在前缀和世界里的翻版, - 也是本题单最重要的一题。 + Map 必须以 {"{0: 1}"} 起步:空前缀也是合法的 j,否则从下标 0 开始的子数组会全部漏掉。O(n) 时间、O(n) 空间。元素可能为负,窗口和不单调,滑动窗口在这里失效 —— + 这正是前缀和 + 哈希登场的原因。它是「两数之和」在前缀和世界里的翻版,也是本题单最重要的一题。 ), }, @@ -325,11 +305,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 动态数组存值(随机取 O(1)),Map 存「值 → 它在数组里的下标」。 - 删除 x 时:查出下标 i,把数组末尾元素搬到 i、 - 更新它在 Map 里的下标,再弹掉末尾 —— 避开了数组中间删除的 O(n) 搬家。 - swap-with-last 是数组 O(1) 删除的标准手法,代价是不再保持顺序。 - 「哈希表 + 另一种结构」这套组合,后面的 LRU、LFU 缓存还会再用一次。 + 动态数组存值(随机取 O(1)),Map 存「值 → 它在数组里的下标」。删除 x 时:查出下标 i,把数组末尾元素搬到 i、更新它在 Map 里的下标,再弹掉末尾 —— 避开了数组中间删除的 O(n) 搬家。swap-with-last 是数组 O(1) 删除的标准手法,代价是不再保持顺序。「哈希表 + 另一种结构」这套组合,后面的 LRU、LFU 缓存还会再用一次。 ), }, @@ -363,10 +339,8 @@ export const PROBLEMS: Problem[] = [ <> 第一遍:同位置同数字 → bulls++;不匹配的位置,分别给 secret 和 guess 的数字计数(两个长度 10 的计数数组)。第二遍:对每个数字 0–9, - cows += min(cntS[d], cntG[d]) —— 两边库存能配上的部分都是奶牛。 - O(n) 时间、O(1) 额外空间。一遍写法:只用一个计数数组,secret - 的数字 +1、guess 的数字 −1,某个计数越过 0 走向反方向时, - 就说明抵掉了一头奶牛。 + cows += min(cntS[d], cntG[d]) —— 两边库存能配上的部分都是奶牛。O(n) 时间、O(1) 额外空间。一遍写法:只用一个计数数组,secret + 的数字 +1、guess 的数字 −1,某个计数越过 0 走向反方向时,就说明抵掉了一头奶牛。 ), }, diff --git a/lib/heap-problems.tsx b/lib/heap-problems.tsx index 4e9916c..28b6014 100644 --- a/lib/heap-problems.tsx +++ b/lib/heap-problems.tsx @@ -38,10 +38,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 构造时把初始数组压进一个小根堆,并把大小维持在 k;每次 add{" "} - 先入堆,超过 k 就弹掉堆顶。此时堆顶就是「迄今第 k 大」。 - 单次 add 是 O(log k),空间 O(k)。 - 这里不能靠排序:数据流没有「全部」—— 你永远不知道后面还来多少。 - 堆里住着「迄今最大的 k 个」,堆顶就是入围门槛。 + 先入堆,超过 k 就弹掉堆顶。此时堆顶就是「迄今第 k 大」。单次 add 是 O(log k),空间 O(k)。这里不能靠排序:数据流没有「全部」—— 你永远不知道后面还来多少。堆里住着「迄今最大的 k 个」,堆顶就是入围门槛。 ), }, @@ -75,8 +72,7 @@ export const PROBLEMS: Problem[] = [ 全部石头入大根堆。每回合弹两次得到 x ≥ y;若 x ≠ y,把差值 x − y 压回去,直到堆里剩下不超过一块。时间 O(n log n)。Java 用{" "} new PriorityQueue<>(Comparator.reverseOrder()); - Python 因为 heapq 到 3.13 为止只有小根堆,全程存负数。 - 这题正好把两种「大根堆写法」练熟。 + Python 因为 heapq 到 3.13 为止只有小根堆,全程存负数。这题正好把两种「大根堆写法」练熟。 ), }, @@ -108,11 +104,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 与 LC 215 镜像:要前 k 小,就用容量 k 的大根堆。 - 堆顶是当前候选里最远的点,新点只有比它更近才有资格进来。 - 时间 O(n log k),在 n 很大、k 很小时明显优于全排序的 O(n log n)。 - 比较距离时用平方即可,不必开根号:平方在非负数上单调递增,不改变大小关系。 - 常见追问是快速选择,平均 O(n)。 + 与 LC 215 镜像:要前 k 小,就用容量 k 的大根堆。堆顶是当前候选里最远的点,新点只有比它更近才有资格进来。时间 O(n log k),在 n 很大、k 很小时明显优于全排序的 O(n log n)。比较距离时用平方即可,不必开根号:平方在非负数上单调递增,不改变大小关系。常见追问是快速选择,平均 O(n)。 ), }, @@ -144,11 +136,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 先用哈希表计数,再维护一个容量 k 的小根堆。比较器按「频次升序; - 频次相同按单词字典序降序」。后半句看着反直觉,但正是它让 - 「频次最低、且在并列里字典序最靠后」的那个最该淘汰的单词落到堆顶。 - 最后逐个弹出并反转即可。时间 O(n log k)。 - 这题是练「比较器方向感」的最佳题目:永远让最该被踢的元素待在堆顶。 + 先用哈希表计数,再维护一个容量 k 的小根堆。比较器按「频次升序;频次相同按单词字典序降序」。后半句看着反直觉,但正是它让「频次最低、且在并列里字典序最靠后」的那个最该淘汰的单词落到堆顶。最后逐个弹出并反转即可。时间 O(n log k)。这题是练「比较器方向感」的最佳题目:永远让最该被踢的元素待在堆顶。 ), }, @@ -182,11 +170,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 把每行的第一个元素以 (值, 行, 列) 的形式压进小根堆;弹 k − 1 次, - 每弹一次就把同一行的下一个元素补进来,第 k 次的堆顶就是答案。 - 时间 O(k log n)。这是「合并 K 路」模板的直接复用。 - 面试中更进一步的解法是值域二分:猜一个 mid,用 O(n) 数出 ≤ mid 的个数再收缩区间, - 可做到 O(n log(max − min))。能讲清这两种解法,才算真正掌握。 + 把每行的第一个元素以 (值, 行, 列) 的形式压进小根堆;弹 k − 1 次,每弹一次就把同一行的下一个元素补进来,第 k 次的堆顶就是答案。时间 O(k log n)。这是「合并 K 路」模板的直接复用。面试中更进一步的解法是值域二分:猜一个 mid,用 O(n) 数出 ≤ mid 的个数再收缩区间,可做到 O(n log(max − min))。能讲清这两种解法,才算真正掌握。 ), }, @@ -219,11 +203,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 先计数,再按剩余次数入大根堆。每轮弹出剩得最多的字符接到结果上, - 但先不放回堆,以免连着用两次;等下一轮弹出别的字符后, - 再把上一轮那个(次数减一后若仍大于 0)放回去。 - 若某个字符出现次数超过 (n + 1) / 2 则无解 —— 鸽笼原理,间隔不够用。 - 时间 O(n log 26)。「反复取最值,而且取完还要更新计数」正是堆的主场。 + 先计数,再按剩余次数入大根堆。每轮弹出剩得最多的字符接到结果上,但先不放回堆,以免连着用两次;等下一轮弹出别的字符后,再把上一轮那个(次数减一后若仍大于 0)放回去。若某个字符出现次数超过 (n + 1) / 2 则无解 —— 鸽笼原理,间隔不够用。时间 O(n log 26)。「反复取最值,而且取完还要更新计数」正是堆的主场。 ), }, @@ -267,17 +247,11 @@ export const PROBLEMS: Problem[] = [ 对顶堆。大根堆 small{" "} 存较小的一半,堆顶就是左半的最大值;小根堆 large{" "} 存较大的一半,堆顶就是右半的最小值。两条不变量: - small 的所有元素 ≤ large 的所有元素; - 两堆大小相差不超过 1(约定 small 可以多一个)。 - addNum 固定三步:先把 x 压入 small; - 再把 small 的堆顶搬去 large - (这一步恢复第一条不变量,因为搬走的正是左半最大值); - 若 large 反而更多,再搬一个回 small + small 的所有元素 ≤ large 的所有元素;两堆大小相差不超过 1(约定 small 可以多一个)。 + addNum 固定三步:先把 x 压入 small;再把 small 的堆顶搬去 large + (这一步恢复第一条不变量,因为搬走的正是左半最大值);若 large 反而更多,再搬一个回 small (恢复第二条)。两次堆操作,O(log n)。 - findMedian 在总数为奇数时取 small 堆顶, - 偶数时取两个堆顶的平均,O(1)。 - 常见追问「99% 的数据落在 0~100」→ 用计数数组,两端各加一个溢出桶, - 扫 101 个桶即可。 + findMedian 在总数为奇数时取 small 堆顶,偶数时取两个堆顶的平均,O(1)。常见追问「99% 的数据落在 0~100」→ 用计数数组,两端各加一个溢出桶,扫 101 个桶即可。 ), }, @@ -310,13 +284,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 所有项目按启动资本入小根堆,然后做 k 轮: - 每轮先把「当前资本够得着」的项目全部搬进按利润排序的大根堆 - —— 资本只增不减,所以搬进去的项目不用再搬回来; - 再弹出利润最大的做掉,资本随之增加。 - 每个项目在两个堆里各进出至多一次,合计 O(n log n)。 - 这是「双堆接力」模板:一个堆存放还没解锁的候选。 - 它和 LC 295 的对顶堆是两种完全不同的双堆用法。 + 所有项目按启动资本入小根堆,然后做 k 轮:每轮先把「当前资本够得着」的项目全部搬进按利润排序的大根堆 + —— 资本只增不减,所以搬进去的项目不用再搬回来;再弹出利润最大的做掉,资本随之增加。每个项目在两个堆里各进出至多一次,合计 O(n log n)。这是「双堆接力」模板:一个堆存放还没解锁的候选。它和 LC 295 的对顶堆是两种完全不同的双堆用法。 ), }, diff --git a/lib/linked-list-problems.tsx b/lib/linked-list-problems.tsx index e59d15e..1edc7d6 100644 --- a/lib/linked-list-problems.tsx +++ b/lib/linked-list-problems.tsx @@ -36,8 +36,7 @@ export const PROBLEMS: Problem[] = [ <> 单指针一次遍历。若 cur.val == cur.next.val,就{" "} cur.next = cur.next.next 绕过重复节点,并且{" "} - cur 原地不动 —— 后面可能还连着重复;否则 cur 前进一格。 - 头节点永远不会被删,所以这题不需要 dummy。时间 O(n),空间 O(1)。 + cur 原地不动 —— 后面可能还连着重复;否则 cur 前进一格。头节点永远不会被删,所以这题不需要 dummy。时间 O(n),空间 O(1)。 ), }, @@ -71,8 +70,7 @@ export const PROBLEMS: Problem[] = [ 建一个 dummy,让它的 next 指向 head,cur 从 dummy 出发。若{" "} cur.next.val == val 就 cur.next = cur.next.next ,否则 cur 前进。有了 dummy,「删头」和「删中间」是同一行代码 —— - 就是 §04 那组对照示例。最后返回 dummy.next 而不是 head, - 因为原来的头可能已经被删掉了。 + 就是 §04 那组对照示例。最后返回 dummy.next 而不是 head,因为原来的头可能已经被删掉了。 ), }, @@ -105,10 +103,8 @@ export const PROBLEMS: Problem[] = [ 快慢指针。两者都从 head 出发,slow 每步 1 格、fast 每步 2 格,循环条件{" "} fast != null && fast.next != null。fast 走不动时, slow 正好停在中点。长度为偶数时,这种写法停在两个中点里的 - 第二个,正合本题要求。如果你要的是第一个中点(比如把链表切成两半), - 循环条件改成{" "} - fast.next != null && fast.next.next != null。 - 时间 O(n),空间 O(1)。 + 第二个,正合本题要求。如果你要的是第一个中点(比如把链表切成两半),循环条件改成{" "} + fast.next != null && fast.next.next != null。时间 O(n),空间 O(1)。 ), }, @@ -142,10 +138,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - pA 从 A 链头出发,pB 从 B 链头出发;谁走到尾,就跳到另一条链的头继续走。 - 于是两个指针走过的总长度都是 lenA + lenB,走完之后它们距离链尾一样远。 - 结果只有两种:在交点相遇,或者同时变成 null(不相交)。既不用数长度, - 也不用哈希表。时间 O(n + m),空间 O(1)。 + pA 从 A 链头出发,pB 从 B 链头出发;谁走到尾,就跳到另一条链的头继续走。于是两个指针走过的总长度都是 lenA + lenB,走完之后它们距离链尾一样远。结果只有两种:在交点相遇,或者同时变成 null(不相交)。既不用数长度,也不用哈希表。时间 O(n + m),空间 O(1)。 ), }, @@ -175,9 +168,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 三步组合:快慢指针找中点 → 反转后半段 → 两个指针分别从两段的头部同步比较。 - 时间 O(n),空间 O(1),比「把值拷进数组再左右对撞」省掉 O(n) 空间。 - 注意它改动了原链表,严谨的写法会在返回前把后半段再反转回去。 + 三步组合:快慢指针找中点 → 反转后半段 → 两个指针分别从两段的头部同步比较。时间 O(n),空间 O(1),比「把值拷进数组再左右对撞」省掉 O(n) 空间。注意它改动了原链表,严谨的写法会在返回前把后半段再反转回去。 ), }, @@ -212,10 +203,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 两个指针都从 dummy 出发:fast 先走 n + 1 步,然后两人同步前进,直到 fast 为 null。 - 间隔全程不变,所以此刻 slow 正停在待删节点的前驱上,一行{" "} - slow.next = slow.next.next 就完成删除。dummy 兜住了 - 「要删的正是头节点」这种情况。一次遍历,时间 O(n),空间 O(1)。 + 两个指针都从 dummy 出发:fast 先走 n + 1 步,然后两人同步前进,直到 fast 为 null。间隔全程不变,所以此刻 slow 正停在待删节点的前驱上,一行{" "} + slow.next = slow.next.next 就完成删除。dummy 兜住了「要删的正是头节点」这种情况。一次遍历,时间 O(n),空间 O(1)。 ), }, @@ -249,8 +238,7 @@ export const PROBLEMS: Problem[] = [ dummy 站到 head 前面,prev 每次盯住一对 (a, b)。三次写入按顺序是{" "} prev.next = b、a.next = b.next、 b.next = a,然后 prev 跳到 a。要点是先读 b.next{" "} - 再覆盖它 —— 和「先接后断」是同一条规矩。递归版更短,但要 O(n) 栈空间; - 迭代版才是 O(1)。 + 再覆盖它 —— 和「先接后断」是同一条规矩。递归版更短,但要 O(n) 栈空间;迭代版才是 O(1)。 ), }, @@ -283,10 +271,8 @@ export const PROBLEMS: Problem[] = [ zh: ( <> Floyd 判圈的第二阶段:快慢相遇后,把一个指针放回 head,两个指针改为 - 每步一格同速前进,再次相遇处就是环的入口。推导:设头到入口为 a、 - 入口到相遇点为 b、环的剩余部分为 c,由「fast 路程 = 2 × slow 路程」可得 - a = c + k × 环长(k 为非负整数)。面试常要求当场写出这条等式, - 所以先把 §06 精讲 B 的相遇原理弄透。 + 每步一格同速前进,再次相遇处就是环的入口。推导:设头到入口为 a、入口到相遇点为 b、环的剩余部分为 c,由「fast 路程 = 2 × slow 路程」可得 + a = c + k × 环长(k 为非负整数)。面试常要求当场写出这条等式,所以先把 §06 精讲 B 的相遇原理弄透。 ), }, @@ -318,11 +304,9 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 用 dummy + tail 边算边建结果链。每一步 sum = a + b + carry, - 某条链走完了就按 0 计;挂上 sum % 10,并令{" "} + 用 dummy + tail 边算边建结果链。每一步 sum = a + b + carry,某条链走完了就按 0 计;挂上 sum % 10,并令{" "} carry = sum / 10(整数除法)。循环条件是「l1、l2 或 carry - 还有货」。漏挂最后一次进位是这题最常见的错误:5 + 5 必须产生两个节点。 - 时间 O(max(n, m))。 + 还有货」。漏挂最后一次进位是这题最常见的错误:5 + 5 必须产生两个节点。时间 O(max(n, m))。 ), }, @@ -354,11 +338,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 先用 dummy 让 left = 1 不再是特例,然后走到 pre(位置 left 的前一个节点)。 - 接着重复 right − left 次:把 cur.next 摘下来,插到 pre 的正后方。 - 每挪一次就有一个节点被顶到更前面,一趟下来区间自然反转。 - 这比「切段 + 反转 + 缝回」少写一半指针。每一步都建议画图。 - 时间 O(n),空间 O(1)。 + 先用 dummy 让 left = 1 不再是特例,然后走到 pre(位置 left 的前一个节点)。接着重复 right − left 次:把 cur.next 摘下来,插到 pre 的正后方。每挪一次就有一个节点被顶到更前面,一趟下来区间自然反转。这比「切段 + 反转 + 缝回」少写一半指针。每一步都建议画图。时间 O(n),空间 O(1)。 ), }, @@ -392,9 +372,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> dummy 起手,每轮三件事:① 探查剩余节点是否够 k 个(不够就停,保持原序); - ② 用三指针反转这 k 个;③ 缝合 —— 上一段的尾接本段的新头,本段的尾接下一段的头。 - 用 groupPrev / groupNext 两个锚点变量能挡掉大半混乱。它 Hard 在工程化拆解, - 而不是新算法。时间 O(n),空间 O(1)。 + ② 用三指针反转这 k 个;③ 缝合 —— 上一段的尾接本段的新头,本段的尾接下一段的头。用 groupPrev / groupNext 两个锚点变量能挡掉大半混乱。它 Hard 在工程化拆解,而不是新算法。时间 O(n),空间 O(1)。 ), }, diff --git a/lib/queue-problems.tsx b/lib/queue-problems.tsx index ff9ec94..9c3210c 100644 --- a/lib/queue-problems.tsx +++ b/lib/queue-problems.tsx @@ -36,9 +36,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 新时间戳从队尾入队;然后把小于 t − 3000 的时间戳从队头逐个出队; - 队列长度就是答案。时间戳单调递增,所以过期的一定最老、一定聚在队头。 - 每个请求进出队各一次,单次调用均摊 O(1)。这是「时间滑动窗口」的最小模型。 + 新时间戳从队尾入队;然后把小于 t − 3000 的时间戳从队头逐个出队;队列长度就是答案。时间戳单调递增,所以过期的一定最老、一定聚在队头。每个请求进出队各一次,单次调用均摊 O(1)。这是「时间滑动窗口」的最小模型。 ), }, @@ -68,8 +66,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - push 时先把新元素入队,再把它前面的 n − 1 个元素依次出队、重新入队: - 队列旋转一圈,新元素恰好转到队头 → pop 就是普通出队。push O(n)、pop + push 时先把新元素入队,再把它前面的 n − 1 个元素依次出队、重新入队:队列旋转一圈,新元素恰好转到队头 → pop 就是普通出队。push O(n)、pop O(1)。它与本章精讲 A(LC 232)互为镜像,一起做最能看清两种顺序的差别。 ), @@ -102,8 +99,7 @@ export const PROBLEMS: Problem[] = [ <> 定长数组 + front / rear 两个下标,前进一律 (i + 1) % cap{" "} 绕回开头。满 / 空判定二选一:留一格空(开 k + 1 格, - (rear+1)%cap==front 即满),或维护 size 计数器。所有操作 O(1), - 没有任何元素需要移动。 + (rear+1)%cap==front 即满),或维护 size 计数器。所有操作 O(1),没有任何元素需要移动。 ), }, @@ -171,10 +167,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 贪心模拟:按 pushed 依次入栈;每次入栈后,只要栈顶等于 popped - 的当前元素就一直弹并推进 popped 指针。结束时栈空 ⇔ 序列合法。 - 为什么「能弹就弹」是对的?能弹却不弹,后续入栈会把它压得更深, - 此后再也没有机会在正确的时刻弹出。时间 O(n)、空间 O(n), - 也是上一章栈的复习题。 + 的当前元素就一直弹并推进 popped 指针。结束时栈空 ⇔ 序列合法。为什么「能弹就弹」是对的?能弹却不弹,后续入栈会把它压得更深,此后再也没有机会在正确的时刻弹出。时间 O(n)、空间 O(n),也是上一章栈的复习题。 ), }, @@ -205,10 +198,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 两个队列分别存 R、D 议员的下标:每轮取两队队头比较, - 下标小者先行动 → 存活,并以「下标 + n」重新入队(表示下一轮再来); - 下标大者被禁言,直接出队消失。直到一方清空。 - 「下一个行动者」的顺序完全由队列维持,不需要额外记录。O(n)。 + 两个队列分别存 R、D 议员的下标:每轮取两队队头比较,下标小者先行动 → 存活,并以「下标 + n」重新入队(表示下一轮再来);下标大者被禁言,直接出队消失。直到一方清空。「下一个行动者」的顺序完全由队列维持,不需要额外记录。O(n)。 ), }, @@ -242,8 +232,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 滑动窗口 + 两个单调队列:递减队列随时给出窗口 max,递增队列给出窗口 - min。右端扩张后,只要 max − min > limit 就收缩左端,同时把已经 - 离开窗口的下标从两个队头弹掉。它就是 LC 239 + min。右端扩张后,只要 max − min > limit 就收缩左端,同时把已经离开窗口的下标从两个队头弹掉。它就是 LC 239 的直接升级:同一个窗口,同时维护两套单调性。O(n)。 ), @@ -283,8 +272,7 @@ export const PROBLEMS: Problem[] = [ 对前缀和 P 维护递增单调队列。遍历 r 时:①只要队头满足 P[r] − P[队头] ≥ K,就记录长度并弹出队头 —— 这个左端点已经配到最短的搭档,再往后只会更长;②把队尾所有 P[队尾] ≥ - P[r] 的下标弹掉 —— P[r] 既更小又更靠右,它们不可能再成为更好的左端点。 - 两条弹出规则正好用到 deque 的两端,这就是它必须是双端队列的原因。O(n)。 + P[r] 的下标弹掉 —— P[r] 既更小又更靠右,它们不可能再成为更好的左端点。两条弹出规则正好用到 deque 的两端,这就是它必须是双端队列的原因。O(n)。 ), }, diff --git a/lib/stack-problems.tsx b/lib/stack-problems.tsx index 48faf2f..949ed71 100644 --- a/lib/stack-problems.tsx +++ b/lib/stack-problems.tsx @@ -33,10 +33,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 逐字符处理:当前字符与栈顶相同就弹栈(这一对被消除),否则入栈; - 扫完后栈里剩下的就是答案。弹栈后下面那个元素自动成为新栈顶, - 可以直接和后面的字符继续配对 —— 连锁消除不需要任何额外代码。 - 时间 O(n),空间 O(n)。 + 逐字符处理:当前字符与栈顶相同就弹栈(这一对被消除),否则入栈;扫完后栈里剩下的就是答案。弹栈后下面那个元素自动成为新栈顶,可以直接和后面的字符继续配对 —— 连锁消除不需要任何额外代码。时间 O(n),空间 O(n)。 ), }, @@ -67,10 +64,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - in 栈只收 push,out 栈负责 pop / peek; - 只有 out 空了才把 in 整体倒过去。 - 两次反转恰好恢复先来后到。每个元素一生最多被搬 4 次 - (进 in、出 in、进 out、出{" "} + in 栈只收 push,out 栈负责 pop / peek;只有 out 空了才把 in 整体倒过去。两次反转恰好恢复先来后到。每个元素一生最多被搬 4 次(进 in、出 in、进 out、出{" "} out),所以单次操作均摊 O(1)。队列章有逐帧动画和完整推导。 ), @@ -100,9 +94,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 单队列做法:push 时先把新元素入队,再把它前面的 n−1 个元素依次出队、 - 重新入队 —— 队列被旋转一整圈,新元素恰好转到队头。于是 pop 就是一次出队。 - push O(n)、pop O(1),和 LC 232 互为镜像,放在一起做最有感觉。 + 单队列做法:push 时先把新元素入队,再把它前面的 n−1 个元素依次出队、重新入队 —— 队列被旋转一整圈,新元素恰好转到队头。于是 pop 就是一次出队。push O(n)、pop O(1),和 LC 232 互为镜像,放在一起做最有感觉。 ), }, @@ -132,9 +124,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 用栈存有效得分:数字直接入栈;+ 把栈顶两项之和入栈; - D 把栈顶 ×2 入栈;C 弹掉栈顶。最后求和。 - 纯模拟题,练的是「要最近的记录 → 用栈」这个条件反射。 - 时间 O(n),空间 O(n)。 + D 把栈顶 ×2 入栈;C 弹掉栈顶。最后求和。纯模拟题,练的是「要最近的记录 → 用栈」这个条件反射。时间 O(n),空间 O(n)。 ), }, @@ -168,9 +158,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 数字入栈;遇到运算符弹出两个数,算完把结果压回去。注意弹出顺序: - 先弹出的是右操作数,减法和除法会因此出错;除法要向零取整。 - 后缀表达式不需要括号、不需要优先级,这正是编译器和计算器用栈求值的原因。 - 时间 O(n),空间 O(n)。 + 先弹出的是右操作数,减法和除法会因此出错;除法要向零取整。后缀表达式不需要括号、不需要优先级,这正是编译器和计算器用栈求值的原因。时间 O(n),空间 O(n)。 ), }, @@ -201,11 +189,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 遇到 [ 时把「当前已拼好的字符串 + 当前倍数」打包压栈, - 然后清空重新开始;遇到 ] 弹栈, - cur = prev + k × cur。栈里每一层存的是一份未完成的工作, - 和调用栈保存的东西是同一类。本题用递归写也行,两种写法可以逐行互译。 - 时间 O(n)。 + 遇到 [ 时把「当前已拼好的字符串 + 当前倍数」打包压栈,然后清空重新开始;遇到 ] 弹栈, + cur = prev + k × cur。栈里每一层存的是一份未完成的工作,和调用栈保存的东西是同一类。本题用递归写也行,两种写法可以逐行互译。时间 O(n)。 ), }, @@ -234,8 +219,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 对 nums2 跑一遍单调栈:新元素比栈顶大就弹栈, - 并在哈希表里记下「被弹出的值 → 弹它的值」;最后 nums1{" "} + 对 nums2 跑一遍单调栈:新元素比栈顶大就弹栈,并在哈希表里记下「被弹出的值 → 弹它的值」;最后 nums1{" "} 逐个查表。时间 O(n + m)。它和 LC 739 是同一套机制的简化版,建议先做它。 ), @@ -268,8 +252,7 @@ export const PROBLEMS: Problem[] = [ <> 循环数组的标准技巧:下标 i 从 0 跑到 2n−1,访问时用{" "} i % n。第一圈正常「弹栈结算 + 入栈」,第二圈 - 只弹不进 —— 这些下标第一圈已经入过栈,再入一次就重复了。 - 不用真的复制数组。时间 O(n)。 + 只弹不进 —— 这些下标第一圈已经入过栈,再入一次就重复了。不用真的复制数组。时间 O(n)。 ), }, @@ -303,10 +286,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 维护一个递增的下标栈:当前柱子比栈顶矮时,弹出栈顶并结算 - 「以它为高」的矩形 —— 右边界是当前下标,左边界是弹出后的新栈顶, - 宽度 = i − 新栈顶 − 1。首尾各加一根高度为 0 的哨兵柱: - 开头那根免去判空,结尾那根强制清算所有剩余柱子。时间 O(n)。 + 维护一个递增的下标栈:当前柱子比栈顶矮时,弹出栈顶并结算「以它为高」的矩形 —— 右边界是当前下标,左边界是弹出后的新栈顶,宽度 = i − 新栈顶 − 1。首尾各加一根高度为 0 的哨兵柱:开头那根免去判空,结尾那根强制清算所有剩余柱子。时间 O(n)。 ), }, @@ -338,11 +318,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 维护一个递减的下标栈:当前柱子比栈顶高时,栈顶就是凹槽的底,弹出它; - 此时左墙 = 新栈顶,右墙 = 当前柱子,这一层水量 ={" "} - (min(左墙, 右墙) − 底) × (右墙下标 − 左墙下标 − 1)。 - 和数组章的对撞指针解法对照:同一道题,那边按列竖着算,这边按层横着算。 - 两种都能讲清楚,才算真的吃透。时间 O(n)。 + 维护一个递减的下标栈:当前柱子比栈顶高时,栈顶就是凹槽的底,弹出它;此时左墙 = 新栈顶,右墙 = 当前柱子,这一层水量 ={" "} + (min(左墙, 右墙) − 底) × (右墙下标 − 左墙下标 − 1)。和数组章的对撞指针解法对照:同一道题,那边按列竖着算,这边按层横着算。两种都能讲清楚,才算真的吃透。时间 O(n)。 ), }, diff --git a/lib/string-problems.tsx b/lib/string-problems.tsx index 87e24dd..e75514a 100644 --- a/lib/string-problems.tsx +++ b/lib/string-problems.tsx @@ -32,10 +32,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 对撞指针:交换 s[left] 和 s[right],然后两个指针同时向中间走,相遇即止。 - O(n) 时间、O(1) 额外空间。题目特意给 char[]/list - 而不是字符串,是因为 Java、Python、JavaScript 的字符串都不可变, - 「原地反转」只能发生在可变的字符数组上。 + 对撞指针:交换 s[left] 和 s[right],然后两个指针同时向中间走,相遇即止。O(n) 时间、O(1) 额外空间。题目特意给 char[]/list + 而不是字符串,是因为 Java、Python、JavaScript 的字符串都不可变,「原地反转」只能发生在可变的字符数组上。 ), }, @@ -101,8 +99,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 同时维护 s→t 和 t→s 两张映射表,逐位检查:若某位上任一方向与已记录的映射冲突, - 返回 false。只建单向映射会放过 "badc" 和 "baba" + 同时维护 s→t 和 t→s 两张映射表,逐位检查:若某位上任一方向与已记录的映射冲突,返回 false。只建单向映射会放过 "badc" 和 "baba" —— s 的两个不同字符映到了 t 的同一个字符。一次遍历,O(n)。 ), @@ -134,8 +131,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 纵向扫描:比到第 i 列时,只要有一个串长度不足或字符不同就停,答案就是前 i - 个字符。最坏 O(S)(S 为所有字符总数),但通常在第一个分歧列就提前结束。 - 「以第一个串为标尺逐个横向裁剪」的写法复杂度相同。 + 个字符。最坏 O(S)(S 为所有字符总数),但通常在第一个分歧列就提前结束。「以第一个串为标尺逐个横向裁剪」的写法复杂度相同。 ), }, @@ -166,8 +162,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 一行流:按空白 split → 过滤空串 → 倒序 → 用一个空格 join。想做到 O(1) - 额外空间(只有能原地改字符数组的语言才可行)则三步走:先整体 reverse, - 再对每个单词局部 reverse,最后原地压缩多余空格 —— 和 LC 189 + 额外空间(只有能原地改字符数组的语言才可行)则三步走:先整体 reverse,再对每个单词局部 reverse,最后原地压缩多余空格 —— 和 LC 189 轮转数组是同一个翻转技巧。 ), @@ -203,9 +198,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 定长滑动窗口 + 长度 26 的计数数组:窗口右移时,进窗的字符计数 ++、 - 出窗的字符计数 --,再比较窗口计数与 p 的计数。额外维护一个「已匹配的字母种数」 - 可以把这次比较压到 O(1)。整体 O(n)。「子串长度固定」是定长滑窗的强信号 —— + 定长滑动窗口 + 长度 26 的计数数组:窗口右移时,进窗的字符计数 ++、出窗的字符计数 --,再比较窗口计数与 p 的计数。额外维护一个「已匹配的字母种数」可以把这次比较压到 O(1)。整体 O(n)。「子串长度固定」是定长滑窗的强信号 —— 它比通用滑窗少一个收缩循环。 ), @@ -240,9 +233,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 固定流程四步走:① 跳过前导空格;② 读一个可选的 +/ - -;③ 逐位读数字,遇非数字立刻停;④ 每次累加前先判溢出 - (ans > (MAX - digit) / 10 就该截断到 32 位边界)。 - Python 的 int 没有固定宽度,可以最后再 clamp; + -;③ 逐位读数字,遇非数字立刻停;④ 每次累加前先判溢出(ans > (MAX - digit) / 10 就该截断到 32 位边界)。Python 的 int 没有固定宽度,可以最后再 clamp; Java/JS 必须边算边防。这题考的是把需求翻译成不重不漏的分支 —— 值得亲手写三遍。 @@ -280,8 +271,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> KMP:先对 pattern 求前缀函数,lps[i] = 子串{" "} - pattern[0..i] 的最长「真前缀 = 真后缀」长度。匹配时主串指针永不回退, - 失配只把 j 跳到 lps[j-1] 继续比。预处理 O(m) + + pattern[0..i] 的最长「真前缀 = 真后缀」长度。匹配时主串指针永不回退,失配只把 j 跳到 lps[j-1] 继续比。预处理 O(m) + 匹配 O(n)。本章 §04 把 lps 的来历讲透了 —— 背模板之前,先能回答「为什么跳到 lps[j-1] 不会漏解」。 @@ -315,8 +305,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 开 numRows 个收集器(StringBuilder 或 list),用 row{" "} - 指针和方向变量 dir = ±1 走一遍输入,碰到第 0 行或最后一行就反向。 - 每个字符恰好被收集一次,最后按行拼接,O(n)。数学解法(按周期{" "} + 指针和方向变量 dir = ±1 走一遍输入,碰到第 0 行或最后一行就反向。每个字符恰好被收集一次,最后按行拼接,O(n)。数学解法(按周期{" "} 2·numRows - 2 直接算下标)可作为追问时的进阶解法。 ), @@ -354,8 +343,7 @@ export const PROBLEMS: Problem[] = [ 滑窗 + 两个计数器:need 记录 t 中每种字符还欠多少, have 记录已满足的字符种数。r 右扩补欠账,一旦{" "} have 等于 t 的字符种类总数,窗口就合法,这时收缩 l - 找更短答案,直到窗口不再合法为止。每个字符最多进出窗口各一次,O(n)。 - 滑窗三问(维护什么 / 何时扩 / 何时缩)在这题达到最完整的形态。 + 找更短答案,直到窗口不再合法为止。每个字符最多进出窗口各一次,O(n)。滑窗三问(维护什么 / 何时扩 / 何时缩)在这题达到最完整的形态。 ), }, diff --git a/lib/trie-problems.tsx b/lib/trie-problems.tsx index 10017a1..bbd28ff 100644 --- a/lib/trie-problems.tsx +++ b/lib/trie-problems.tsx @@ -40,9 +40,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - insert:沿字符走,缺哪条边就新建节点,末节点 isEnd = true。search: - 同样走到底,还要求末节点 isEnd = true 才算命中。startsWith:走得通即可, - 不看 isEnd。三个方法都是 O(L),L = 传入字符串的长度 —— + insert:沿字符走,缺哪条边就新建节点,末节点 isEnd = true。search:同样走到底,还要求末节点 isEnd = true 才算命中。startsWith:走得通即可,不看 isEnd。三个方法都是 O(L),L = 传入字符串的长度 —— 词典里已经存了多少词,不出现在这个代价里。所有后续 Trie 题都在这三块骨架上加东西。 @@ -81,10 +79,8 @@ export const PROBLEMS: Problem[] = [ zh: ( <> addWord 与 LC 208 相同。search 改成递归 dfs(word, i, node):普通字符只往对应 - child 递归;遇到 '.' 就遍历当前节点的所有 child 分别递归, - 任意一条返回 true 就立刻返回。走到词尾看 isEnd。最坏情况(全是 '.')会扇出到 - O(26^L),但搜索访问的节点数同时也不会超过整棵树的节点数,而且缺边会立刻中断一条分支。 - 这是「Trie + 回溯」的最小案例。 + child 递归;遇到 '.' 就遍历当前节点的所有 child 分别递归,任意一条返回 true 就立刻返回。走到词尾看 isEnd。最坏情况(全是 '.')会扇出到 + O(26^L),但搜索访问的节点数同时也不会超过整棵树的节点数,而且缺边会立刻中断一条分支。这是「Trie + 回溯」的最小案例。 ), }, @@ -115,8 +111,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 用词根建 Trie。遍历句子里每个单词,从 root 逐字符下沉:一旦当前节点 isEnd = - true,说明有词根匹配这段前缀,替换并停止;若中途断路或走完仍没遇到 isEnd, - 保留原词。每个单词 O(自身长度)。这题把「用 Trie 判前缀」用得最直白。 + true,说明有词根匹配这段前缀,替换并停止;若中途断路或走完仍没遇到 isEnd,保留原词。每个单词 O(自身长度)。这题把「用 Trie 判前缀」用得最直白。 ), }, @@ -147,8 +142,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 在键结束的那个节点上多存一个 val。sum(prefix):先 O(L) 走到前缀节点, - 再 DFS 这棵子树累加所有 val。还有更快的写法:insert 时算出 delta = + 在键结束的那个节点上多存一个 val。sum(prefix):先 O(L) 走到前缀节点,再 DFS 这棵子树累加所有 val。还有更快的写法:insert 时算出 delta = 新值 − 该 key 的旧值,把 delta 加到路径上每个节点维护的「前缀累加值」上, sum 就变成读一个数、O(L)。值得记住的套路是「把聚合信息挂在节点上」。 @@ -181,10 +175,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 建 Trie 后 DFS,只往 isEnd = true 的子节点走 —— 这条规则正好等价于 - 「每个前缀也是单词」。记录能到达的最长单词;长度相同取字典序最小, - 按 a→z 顺序遍历子节点、且只在严格更长时才替换答案,就自然满足。 - 本质是在 Trie 上找「每一步都合法」的最长链。 + 建 Trie 后 DFS,只往 isEnd = true 的子节点走 —— 这条规则正好等价于「每个前缀也是单词」。记录能到达的最长单词;长度相同取字典序最小,按 a→z 顺序遍历子节点、且只在严格更长时才替换答案,就自然满足。本质是在 Trie 上找「每一步都合法」的最长链。 ), }, @@ -216,10 +207,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 建 Trie,并在每个节点上存「该前缀下字典序最小的 3 个词」;插入时维护这个列表, - 超过 3 个就丢掉最大的。用户逐字符输入时每次下沉一个节点,直接读节点上的列表; - 一旦断路,后续答案全为空。排序 + 二分也能做,但 Trie 版把「前缀 → 候选」 - 变成一次读取,工程里的补全就是这么搭的。 + 建 Trie,并在每个节点上存「该前缀下字典序最小的 3 个词」;插入时维护这个列表,超过 3 个就丢掉最大的。用户逐字符输入时每次下沉一个节点,直接读节点上的列表;一旦断路,后续答案全为空。排序 + 二分也能做,但 Trie 版把「前缀 → 候选」变成一次读取,工程里的补全就是这么搭的。 ), }, @@ -254,9 +242,7 @@ export const PROBLEMS: Problem[] = [ <> 把 words 建成 Trie,词尾节点上存整个单词。从每个格子出发 DFS, 在网格上走一步,就在 Trie 上下沉一步:当前字母在 Trie 里没有对应 - child 就立刻返回 —— 没有任何词这样开头,整条分支可以直接丢掉。 - 正是这一步砍掉了大部分搜索。走到存着单词的节点就收集它,并把该字段清空以免重复收集。 - 共享前缀的词共用一条路径,所以一次网格遍历就把所有词一起测完了。 + child 就立刻返回 —— 没有任何词这样开头,整条分支可以直接丢掉。正是这一步砍掉了大部分搜索。走到存着单词的节点就收集它,并把该字段清空以免重复收集。共享前缀的词共用一条路径,所以一次网格遍历就把所有词一起测完了。 ), }, @@ -293,11 +279,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 建 0/1 Trie:每个数从最高位(小于 2^31 的数,第 30 位就够)读到第 0 位, - 按该位取 0 分支或 1 分支插入。再让每个数走一遍, - 每一层都优先拐向与自己相反的比特:该分支存在,这一位异或就得 1; - 而高位的价值永远大于其后所有低位之和,所以这样贪心是安全的。取全局最大值。 - 代价 O(n × 位数),取代了 O(n²) 的两两配对。这是 Trie 从「存字符」推广到「存比特」的经典一步。 + 建 0/1 Trie:每个数从最高位(小于 2^31 的数,第 30 位就够)读到第 0 位,按该位取 0 分支或 1 分支插入。再让每个数走一遍, + 每一层都优先拐向与自己相反的比特:该分支存在,这一位异或就得 1;而高位的价值永远大于其后所有低位之和,所以这样贪心是安全的。取全局最大值。代价 O(n × 位数),取代了 O(n²) 的两两配对。这是 Trie 从「存字符」推广到「存比特」的经典一步。 ), }, diff --git a/lib/trie-quiz.tsx b/lib/trie-quiz.tsx index 048be5e..72e2a25 100644 --- a/lib/trie-quiz.tsx +++ b/lib/trie-quiz.tsx @@ -161,8 +161,7 @@ export const QUIZ: QuizItem[] = [ ), zh: ( <> - children 用「定长 26 槽数组」还是「哈希表 Map」, - 以下说法正确的有?(多选) + children 用「定长 26 槽数组」还是「哈希表 Map」,以下说法正确的有?(多选) ), }, diff --git a/lib/union-find-problems.tsx b/lib/union-find-problems.tsx index 021997a..1e6d18d 100644 --- a/lib/union-find-problems.tsx +++ b/lib/union-find-problems.tsx @@ -44,10 +44,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 把每条边 union 起来,最后返回{" "} - find(source) === find(destination)。 - 这是并查集最基本的用法 —— 不关心路径长什么样、有多长,只关心两点是否同属一个集合。 - 建议把它当默写模板的第一题:写完 UnionFind 类,主逻辑只有两行。 - 两个优化都开时,总代价 O((V + E)·α(V))。 + find(source) === find(destination)。这是并查集最基本的用法 —— 不关心路径长什么样、有多长,只关心两点是否同属一个集合。建议把它当默写模板的第一题:写完 UnionFind 类,主逻辑只有两行。两个优化都开时,总代价 O((V + E)·α(V))。 ), }, @@ -122,10 +119,7 @@ export const PROBLEMS: Problem[] = [ zh: ( <> 并查集解法:先把所有数存进哈希表(值 → 下标),遍历时若 x+1 也在表里,就 - union(x, x+1) 所在的集合,同时为每个根维护集合大小 size,答案是最大的 size。 - 与哈希章的 O(n) 解法(只从 x−1 不存在的起点向右数)相比,并查集写起来更长, - 但需要的洞察更少 ——「相邻即连边,问最大连通块」。一题两解, - 面试时能对比这两种思路,回答会更完整。 + union(x, x+1) 所在的集合,同时为每个根维护集合大小 size,答案是最大的 size。与哈希章的 O(n) 解法(只从 x−1 不存在的起点向右数)相比,并查集写起来更长,但需要的洞察更少 ——「相邻即连边,问最大连通块」。一题两解,面试时能对比这两种思路,回答会更完整。 ), }, @@ -157,11 +151,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 经典的「先映射再并查集」:用哈希表把每个邮箱映射到一个整数编号(或映射到 - 首次出现的账户下标),同一账户内的所有邮箱互相 union —— - 其实每个都和第一个 union 就够了。最后按根分组、组内排序、拼上用户名。 - 这题演示了处理非整数 key 的标准前置步骤:哈希表负责翻译,并查集负责合并。 - 排序主导,O(n·k·log(n·k))。 + 经典的「先映射再并查集」:用哈希表把每个邮箱映射到一个整数编号(或映射到首次出现的账户下标),同一账户内的所有邮箱互相 union —— + 其实每个都和第一个 union 就够了。最后按根分组、组内排序、拼上用户名。这题演示了处理非整数 key 的标准前置步骤:哈希表负责翻译,并查集负责合并。排序主导,O(n·k·log(n·k))。 ), }, @@ -197,11 +188,8 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - union 所有边,并为每个根维护集合大小 size。设各连通块大小为 s₁…sₖ, - 按顺序遍历一遍连通块并累计「已经数过的节点数」,每块贡献 sᵢ × - (此前累计的节点数) 个点对,从而避免两两枚举。这题是「连通块 + 计数」 - 组合的代表:并查集天生擅长回答「有几块、每块多大」。O(n + E·α(n))。 - 答案要用 64 位整数,计数会超出 32 位范围。 + union 所有边,并为每个根维护集合大小 size。设各连通块大小为 s₁…sₖ,按顺序遍历一遍连通块并累计「已经数过的节点数」,每块贡献 sᵢ × + (此前累计的节点数) 个点对,从而避免两两枚举。这题是「连通块 + 计数」组合的代表:并查集天生擅长回答「有几块、每块多大」。O(n + E·α(n))。答案要用 64 位整数,计数会超出 32 位范围。 ), }, @@ -242,15 +230,9 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 关键洞察:一个连通块里的石头,总能移到只剩 1 颗。取这个连通块的一棵生成树 - (例如 DFS 树,同行或同列的两颗石头之间有边),从叶子开始倒序移除: - 每颗被移除的石头都与它的父节点同行或同列,最后只剩根。 - (随意移走一颗「与别人同行或同列」的石头,可能把连通块拆开: + 关键洞察:一个连通块里的石头,总能移到只剩 1 颗。取这个连通块的一棵生成树(例如 DFS 树,同行或同列的两颗石头之间有边),从叶子开始倒序移除:每颗被移除的石头都与它的父节点同行或同列,最后只剩根。(随意移走一颗「与别人同行或同列」的石头,可能把连通块拆开: (0,0)、(0,1)、(1,1) 三颗石头,先移走 (0,1),剩下两颗就互不共线了。) - 所以答案 = 石头总数 − 连通块数。 - 实现技巧:不必两两比较 O(n²),把「行号 r」和「列号 c + 10001」 - 也当成节点,每颗石头 union(它的行, 它的列),让行列充当中介。 - 这题考的不是模板,是把问题翻译成连通块语言的建模能力。 + 所以答案 = 石头总数 − 连通块数。实现技巧:不必两两比较 O(n²),把「行号 r」和「列号 c + 10001」也当成节点,每颗石头 union(它的行, 它的列),让行列充当中介。这题考的不是模板,是把问题翻译成连通块语言的建模能力。 ), }, @@ -286,13 +268,7 @@ export const PROBLEMS: Problem[] = [ ), zh: ( <> - 两两判断字符串是否相似:相同,或恰好两个位置不同。 - 这样判断就够了,因为所有串互为字母异位词:恰好两个位置不同时,交换这两位必然相等。 - (异位词之间也可能有 3 处或更多处不同,例如 tars 与 star,这样的两个串不相似。) - 相似就 union, - 答案是连通块数。单次判断 O(L),两两枚举 O(n²),总计 O(n²·L)。 - 注意:A 与 B 相似、B 与 C 相似,并不能推出 A 与 C 相似, - 但三者属于同一组 —— 并查集维护的正是这种 + 两两判断字符串是否相似:相同,或恰好两个位置不同。这样判断就够了,因为所有串互为字母异位词:恰好两个位置不同时,交换这两位必然相等。(异位词之间也可能有 3 处或更多处不同,例如 tars 与 star,这样的两个串不相似。)相似就 union,答案是连通块数。单次判断 O(L),两两枚举 O(n²),总计 O(n²·L)。注意:A 与 B 相似、B 与 C 相似,并不能推出 A 与 C 相似,但三者属于同一组 —— 并查集维护的正是这种 「关系本身不传递、分组却要传递」的传递闭包。 ), @@ -331,11 +307,8 @@ export const PROBLEMS: Problem[] = [ <> 有向树里加一条坏边,只有三种情形:① 某节点入度为 2(两个父节点)且无环 —— 删两条入边中较晚出现的那条;② 入度 2 且有环 —— - 删两条候选里位于环上的那条,它可能较早出现,也可能较晚出现, - 所以要靠下面的并查集检验来区分;③ 无入度 2 但有环 —— - 删掉合并时检测到成环的那条。做法是先扫一遍找出入度为 2 的两条候选边, - 再用并查集跳过第二条候选跑一遍:能成树就删它,否则删第一条或成环边。 - 684 只要模板,685 考的是把模板嵌进分类讨论的能力。 + 删两条候选里位于环上的那条,它可能较早出现,也可能较晚出现,所以要靠下面的并查集检验来区分;③ 无入度 2 但有环 —— + 删掉合并时检测到成环的那条。做法是先扫一遍找出入度为 2 的两条候选边,再用并查集跳过第二条候选跑一遍:能成树就删它,否则删第一条或成环边。684 只要模板,685 考的是把模板嵌进分类讨论的能力。 ), }, diff --git a/test/unit/zh-copy-spacing.test.ts b/test/unit/zh-copy-spacing.test.ts new file mode 100644 index 0000000..3926419 --- /dev/null +++ b/test/unit/zh-copy-spacing.test.ts @@ -0,0 +1,127 @@ +// @vitest-environment node +// JSX trims each line of a text block and joins the lines with one space, so a +// line break inside Chinese copy renders as a stray space ("算。 建议"); a space +// written after full-width punctuation ("。 暴力:") shows up the same way. +// The site's convention keeps a space between Chinese and Latin letters or +// digits ("第 3 章"), after an expression such as O(1), around "——" and around +// math operators, and nowhere else. This scans every TSX file for the rest. + +import { readdirSync, readFileSync } from "node:fs"; +import { join } from "node:path"; +import ts from "typescript"; +import { describe, expect, it } from "vitest"; + +const HAN = /[㐀-鿿豈-﫿]/u; +const FW = /[　-〿＀-￯]/u; // CJK and full-width punctuation +const ZH = /[㐀-鿿豈-﫿　-〿＀-￯]/u; +const PUNCT = /[、-〃〈-】〔-〟！-／：-？［-｀｛-･]/u; +const K = ts.SyntaxKind; + +/** An ellipsis that closes Chinese text, not one inside a spaced math sequence. */ +function closesChinese(raw: string, i: number) { + let j = i; + while (j > 0 && raw[j - 1] === "…") j--; + return j > 0 && ZH.test(raw[j - 1]); +} + +/** Whether the line break between raw[i] and the next text should not be a space. */ +function breakIsStray(raw: string, i: number, a: string, b: string) { + if (FW.test(a) && b !== "—") return true; + if (a === "…" && closesChinese(raw, i) && b !== "—") return true; + if (FW.test(b) && a !== "—") return true; + if (HAN.test(a) && (HAN.test(b) || b === "(" || b === "“")) return true; + if (/[,:;?!]/.test(a) && HAN.test(b)) return true; + if (a === ")" && HAN.test(b)) { + const open = raw.lastIndexOf("(", i); + return open > 0 && ZH.test(raw[open - 1]); + } + return false; +} + +/** What JSX renders for a text node. */ +function rendered(raw: string) { + if (!raw.includes("\n")) return raw; + return raw + .split("\n") + .map((l, i, all) => (i === 0 ? l.trimEnd() : i === all.length - 1 ? l.trimStart() : l.trim())) + .filter((l) => l.length) + .join(" "); +} + +function edge(node: ts.Node, sf: ts.SourceFile, last: boolean): string | null | undefined { + if (node.kind === K.JsxText) { + const t = rendered(node.getFullText(sf)); + return t.length ? t[last ? t.length - 1 : 0] : null; + } + if (ts.isJsxExpression(node)) { + const e = node.expression; + if (e && (ts.isStringLiteral(e) || ts.isNoSubstitutionTemplateLiteral(e))) + return e.text.length ? e.text[last ? e.text.length - 1 : 0] : null; + return undefined; + } + if (ts.isJsxElement(node) || ts.isJsxFragment(node)) { + const kids = node.children.filter((c) => !(c.kind === K.JsxText && rendered(c.getFullText(sf)) === "")); + return kids.length ? edge(last ? kids[kids.length - 1] : kids[0], sf, last) : null; + } + return undefined; +} + +function strays(file: string): string[] { + const text = readFileSync(file, "utf8"); + const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX); + const found: string[] = []; + const at = (pos: number, what: string) => + found.push(`${file}:${sf.getLineAndCharacterOfPosition(pos).line + 1} ${what}`); + + const scanText = (start: number, raw: string) => { + for (const m of raw.matchAll(/(\S)([ \t]*\n[ \t\n]*)(\S)/g)) { + if (breakIsStray(raw, m.index!, m[1], m[3])) at(start + m.index!, `line break ${m[1]}⏎${m[3]}`); + } + for (const m of raw.matchAll(/(\S)( +)(\S)/g)) { + const a = m[1], b = m[3]; + const stray = (PUNCT.test(a) || (a === "…" && closesChinese(raw, m.index!))) && ZH.test(b) && b !== "—"; + if (stray) at(start + m.index!, `space ${a} ${b}`); + } + }; + + const visit = (node: ts.Node) => { + if (node.kind === K.JsxText) scanText(node.pos, node.getFullText(sf)); + else if (ts.isStringLiteral(node) && node.parent?.kind === K.JsxAttribute) + scanText(node.getStart(sf), node.getText(sf)); + if (ts.isJsxElement(node) || ts.isJsxFragment(node)) { + const kids = node.children.filter((c) => !(c.kind === K.JsxText && rendered(c.getFullText(sf)) === "")); + kids.forEach((c, i) => { + const prev = kids[i - 1]; + const next = kids[i + 1]; + if (!prev) return; + const a = edge(prev, sf, true); + if (!a || !PUNCT.test(a)) return; + if (ts.isJsxExpression(c) && c.expression && ts.isStringLiteral(c.expression) && /^ +$/.test(c.expression.text) && next) { + const b = edge(next, sf, false); + if (b && ZH.test(b)) at(c.getStart(sf), `{" "} after ${a}`); + } + if (ts.isJsxElement(c) && c.children[0]?.kind === K.JsxText) { + const m = /^( +)(\S)/.exec(c.children[0].getFullText(sf)); + if (m && ZH.test(m[2])) at(c.children[0].pos, `space opening <${c.openingElement.tagName.getText(sf)}> after ${a}`); + } + }); + } + ts.forEachChild(node, visit); + }; + visit(sf); + return found; +} + +function tsxFiles(dir: string): string[] { + return readdirSync(dir, { withFileTypes: true }).flatMap((e) => + e.isDirectory() ? tsxFiles(join(dir, e.name)) : e.name.endsWith(".tsx") ? [join(dir, e.name)] : [], + ); +} + +describe("Chinese copy", () => { + it("has no line break or space that renders as a stray space", () => { + const files = [...tsxFiles("app"), ...tsxFiles("lib")]; + expect(files.length).toBeGreaterThan(40); + expect(files.flatMap(strays)).toEqual([]); + }); +});