QMD-Derived Chapter Logic

Source: formal chapters/*.qmd only. Drafts, production guidelines, and previous audit reports are intentionally not used in this extraction.

01-introduction.qmd

• Slide count: 58
• Code blocks: 18
• Formula blocks: 12
• Table rows: 14
• Animation/demo references: 15
• Exercise/thinking slides: 6

Slide Flow

1. 为什么学习数据结构
2. 本章路线图 [complexity / runtime]
3. 学习目标 [runtime]
4. 从真实场景到结构 [animation]
5. 这些知识会在哪里用到 [animation / industry]
6. 场景一：游戏搜索
7. 场景二：图书目录
8. 场景三：交通路口
9. 数据是什么
10. 数据结构的三个层面 [animation]
11. 线性结构与非线性结构
12. 结构分类：线性、树和图 [animation]
13. 三个视角必须分开
14. 逻辑结构、物理结构与操作
15. 插入操作：逻辑与物理实现 [animation]
16. 数据类型
17. ADT：把使用和实现分开 [animation]
18. ADT 示例：自然数 [code]
19. 面向对象与 ADT
20. 语言复习：类、对象和访问控制 [code / code-walk]
21. 语言复习：对象创建与方法调用 [code / code-walk]
22. 算法的定义
23. 算法性质：含义与反例 [animation]
24. 算法和程序的区别
25. 选择排序：第一段算法过程
26. 选择排序：扫描、记录与交换 [animation]
27. 为什么要分析算法 [complexity]
28. 数学工具箱 [complexity]
29. 递归的两条规则
30. 函数调用会发生什么
31. 函数调用栈：代码与栈帧 [animation / code / code-walk]
32. 阶乘代码 [code / code-walk]
33. 阶乘递归：代码与栈帧 [animation / code / code-walk]
34. Fibonacci：调用树与重复子问题 [animation]
35. Fibonacci 代码 [code / code-walk]
36. Hanoi 塔：递归分解 [animation]
37. 泛型为什么重要 [code / code-walk]
38. 泛型与比较接口 [code / code-walk]
39. C++ 模板：从具体类型到类型参数 [code / code-walk]
40. 全课程代码会反复出现的 C++ 语法 [industry]
41. C++ 语法：STL 与工程表达 [industry]
42. C++ 值语义与对象生命周期 [code / code-walk]
43. 异常处理
44. C++ 错误处理：异常与 optional [code / code-walk]
45. 输入输出与代码组织
46. 顺序文件读取 [code / code-walk / runtime]
47. 包、命名空间和异常类
48. 本章小结 [complexity / runtime]
49. 习题 1：二进制中 1 的个数 [exercise]
50. 习题 1：递归追踪 [animation / exercise]
51. 习题 1：代码 [code / code-walk / complexity / exercise]
52. 习题 2：递归求数组最大值和平均值 [code / code-walk / complexity / exercise]
53. 习题 3：链表长度与回文 [code / code-walk / exercise]
54. 习题 4：组合、全排列和 Hanoi [exercise]
55. 组合：选择或不选择 [animation]
56. 全排列：固定一个位置 [animation]
57. Hanoi：移动次数递推
58. 进入下一章

Inferred Teaching Segments

• Slides 1-1: 为什么学习数据结构
• Slides 2-2: 本章路线图
• Slides 3-16: 学习目标
• Slides 17-17: ADT：把使用和实现分开
• Slides 18-18: ADT 示例：自然数
• Slides 19-21: 面向对象与 ADT
• Slides 22-30: 算法的定义
• Slides 31-31: 函数调用栈：代码与栈帧
• Slides 32-32: 阶乘代码
• Slides 33-34: 阶乘递归：代码与栈帧
• Slides 35-39: Fibonacci 代码
• Slides 40-40: 全课程代码会反复出现的 C++ 语法
• Slides 41-44: C++ 语法：STL 与工程表达
• Slides 45-47: 输入输出与代码组织
• Slides 48-48: 本章小结
• Slides 49-49: 习题 1：二进制中 1 的个数
• Slides 50-50: 习题 1：递归追踪
• Slides 51-51: 习题 1：代码
• Slides 52-52: 习题 2：递归求数组最大值和平均值
• Slides 53-53: 习题 3：链表长度与回文
• Slides 54-57: 习题 4：组合、全排列和 Hanoi
• Slides 58-58: 进入下一章

Evidence Buckets

• Code-walk slides: 语言复习：类、对象和访问控制, 语言复习：对象创建与方法调用, 函数调用栈：代码与栈帧, 阶乘代码, 阶乘递归：代码与栈帧, Fibonacci 代码, 泛型为什么重要, 泛型与比较接口, C++ 模板：从具体类型到类型参数, C++ 值语义与对象生命周期, C++ 错误处理：异常与 optional, 顺序文件读取, 习题 1：代码, 习题 2：递归求数组最大值和平均值, 习题 3：链表长度与回文
• Complexity slides: 本章路线图, 为什么要分析算法, 数学工具箱, 本章小结, 习题 1：代码, 习题 2：递归求数组最大值和平均值
• Runtime/architecture slides: 本章路线图, 学习目标, 顺序文件读取, 本章小结
• Industry/open-source slides: 这些知识会在哪里用到, 全课程代码会反复出现的 C++ 语法, C++ 语法：STL 与工程表达
• Exercise slides: 习题 1：二进制中 1 的个数, 习题 1：递归追踪, 习题 1：代码, 习题 2：递归求数组最大值和平均值, 习题 3：链表长度与回文, 习题 4：组合、全排列和 Hanoi

Animation References

• 从真实场景到结构: introScenarioMap
• 这些知识会在哪里用到: courseDependencyMap
• 数据结构的三个层面: dataStructureTriple
• 结构分类：线性、树和图: structureTaxonomy
• 插入操作：逻辑与物理实现: logicalVsPhysical
• ADT：把使用和实现分开: adtBoundary
• 算法性质：含义与反例: algorithmProperties
• 选择排序：扫描、记录与交换: selectionSortIntro
• 函数调用栈：代码与栈帧: callStackExecution
• 阶乘递归：代码与栈帧: factorialStackLinked
• Fibonacci：调用树与重复子问题: fibCallTree
• Hanoi 塔：递归分解: hanoiDemo
• 习题 1：递归追踪: countOnesTrace
• 组合：选择或不选择: combinationTree
• 全排列：固定一个位置: permutationTree

02-algorithm-analysis.qmd

• Slide count: 47
• Code blocks: 24
• Formula blocks: 66
• Table rows: 8
• Animation/demo references: 12
• Exercise/thinking slides: 8

Slide Flow

1. 为什么分析算法 [complexity / runtime]
2. 本章路线图 [complexity]
3. 学习目标 [complexity]
4. 性能分析与性能测量 [complexity / runtime]
5. 工程连接：开源库为什么重视复杂度 [complexity / runtime / industry]
6. 时间与空间 [complexity / runtime]
7. 空间复杂度的组成 [complexity]
8. 空间例子：顺序查找 [code / code-walk / complexity]
9. 空间例子：递归求和 [code / code-walk / complexity]
10. 时间复杂度：基本操作计数 [complexity]
11. 例子：求最大元素位置 [code / code-walk / complexity]
12. 循环计数：三角形面积 [animation]
13. 选择排序：代码 [code / code-walk]
14. 选择排序：操作次数 [complexity]
15. 冒泡排序：一次冒泡 [code / code-walk]
16. Rank Sort：用排名排序 [code / code-walk]
17. Rank Sort：重排 [code / code-walk / complexity]
18. 最好、最坏与平均
19. 顺序查找：最好、最坏、平均 [code / code-walk]
20. 插入排序：代码 [code / code-walk]
21. 插入排序：最好与最坏 [complexity]
22. Step Counts：给每行计步 [code / code-walk / complexity]
23. 渐进符号 [complexity]
24. Big-O：上界 [complexity]
25. Big-Ω 与 Big-Θ [complexity]
26. 常见增长等级 [animation]
27. 二分查找：代码与区间同步 [animation / code / code-walk / complexity]
28. 最大子段和问题
29. 最大子段和：三种思路 [animation]
30. 算法 1：三层枚举 [code / code-walk / complexity]
31. 算法 2：固定起点向右累加 [code / code-walk / complexity]
32. 算法 3：分治 [complexity]
33. 分治代码：核心结构 [code / code-walk]
34. 分治代码：合并 [code / code-walk]
35. 欧几里得算法 [animation]
36. 欧几里得代码 [code / code-walk / complexity]
37. 多维度分析表 [complexity]
38. 分析算法的固定流程 [complexity]
39. 习题 1：selectkth [code / code-walk / exercise]
40. 习题 1：答案 [animation / complexity / exercise]
41. 习题 2：两个对数循环 [animation / code / code-walk / complexity / exercise]
42. 习题 3：三层循环一 [animation / code / code-walk / complexity / exercise]
43. 习题 3：三层循环二 [animation / code / code-walk / complexity / exercise]
44. 习题 4：矩阵乘法片段 [animation / code / code-walk / complexity / exercise]
45. 习题 4：嵌套求和片段 [animation / code / code-walk / complexity / exercise]
46. 习题 4：while 片段 [animation / code / code-walk / exercise]
47. 本章小结 [complexity]

Inferred Teaching Segments

• Slides 1-1: 为什么分析算法
• Slides 2-2: 本章路线图
• Slides 3-4: 学习目标
• Slides 5-6: 工程连接：开源库为什么重视复杂度
• Slides 7-9: 空间复杂度的组成
• Slides 10-12: 时间复杂度：基本操作计数
• Slides 13-19: 选择排序：代码
• Slides 20-26: 插入排序：代码
• Slides 27-32: 二分查找：代码与区间同步
• Slides 33-33: 分治代码：核心结构
• Slides 34-35: 分治代码：合并
• Slides 36-36: 欧几里得代码
• Slides 37-38: 多维度分析表
• Slides 39-39: 习题 1：selectkth
• Slides 40-40: 习题 1：答案
• Slides 41-41: 习题 2：两个对数循环
• Slides 42-42: 习题 3：三层循环一
• Slides 43-43: 习题 3：三层循环二
• Slides 44-44: 习题 4：矩阵乘法片段
• Slides 45-45: 习题 4：嵌套求和片段
• Slides 46-46: 习题 4：while 片段
• Slides 47-47: 本章小结

Evidence Buckets

• Code-walk slides: 空间例子：顺序查找, 空间例子：递归求和, 例子：求最大元素位置, 选择排序：代码, 冒泡排序：一次冒泡, Rank Sort：用排名排序, Rank Sort：重排, 顺序查找：最好、最坏、平均, 插入排序：代码, Step Counts：给每行计步, 二分查找：代码与区间同步, 算法 1：三层枚举, 算法 2：固定起点向右累加, 分治代码：核心结构, 分治代码：合并, 欧几里得代码, 习题 1：selectkth, 习题 2：两个对数循环, 习题 3：三层循环一, 习题 3：三层循环二, 习题 4：矩阵乘法片段, 习题 4：嵌套求和片段, 习题 4：while 片段
• Complexity slides: 为什么分析算法, 本章路线图, 学习目标, 性能分析与性能测量, 工程连接：开源库为什么重视复杂度, 时间与空间, 空间复杂度的组成, 空间例子：顺序查找, 空间例子：递归求和, 时间复杂度：基本操作计数, 例子：求最大元素位置, 选择排序：操作次数, Rank Sort：重排, 插入排序：最好与最坏, Step Counts：给每行计步, 渐进符号, Big-O：上界, Big-Ω 与 Big-Θ, 二分查找：代码与区间同步, 算法 1：三层枚举, 算法 2：固定起点向右累加, 算法 3：分治, 欧几里得代码, 多维度分析表, 分析算法的固定流程, 习题 1：答案, 习题 2：两个对数循环, 习题 3：三层循环一, 习题 3：三层循环二, 习题 4：矩阵乘法片段, 习题 4：嵌套求和片段, 本章小结
• Runtime/architecture slides: 为什么分析算法, 性能分析与性能测量, 工程连接：开源库为什么重视复杂度, 时间与空间
• Industry/open-source slides: 工程连接：开源库为什么重视复杂度
• Exercise slides: 习题 1：selectkth, 习题 1：答案, 习题 2：两个对数循环, 习题 3：三层循环一, 习题 3：三层循环二, 习题 4：矩阵乘法片段, 习题 4：嵌套求和片段, 习题 4：while 片段

Animation References

• 循环计数：三角形面积: nestedLoopCount
• 常见增长等级: growthRates
• 二分查找：代码与区间同步: binarySearchViz
• 最大子段和：三种思路: maxSubarrayViz
• 欧几里得算法: euclidViz
• 习题 1：答案: selectKthCountViz
• 习题 2：两个对数循环: loopGrowthExerciseViz
• 习题 3：三层循环一: tripleLoopOneExerciseViz
• 习题 3：三层循环二: tripleLoopTwoExerciseViz
• 习题 4：矩阵乘法片段: matrixMultiplyCountViz
• 习题 4：嵌套求和片段: nestedSumExerciseViz
• 习题 4：while 片段: whileLoopExerciseViz

03-list.qmd

• Slide count: 47
• Code blocks: 17
• Formula blocks: 28
• Table rows: 39
• Animation/demo references: 15
• Exercise/thinking slides: 5

Slide Flow

1. 开场：从连续序列到可修改序列 [runtime]
2. 学习目标 [runtime]
3. 路线图 [code / complexity]
4. 线性表 ADT [animation]
5. 线性表的数学定义
6. 典型实例
7. 工程连接：线性表在哪里出现 [runtime / industry]
8. ADT 操作集合
9. 顺序表：数组表示 [animation]
10. 顺序表的定位公式 [complexity]
11. 顺序查找的平均比较次数
12. 顺序表插入与删除 [animation]
13. 删除移动次数 [complexity]
14. 插入移动次数 [complexity]
15. 顺序表的优点与限制 [complexity / runtime]
16. C++ 顺序表接口 [code / code-walk]
17. 单链表节点 [code / code-walk]
18. 单链表的基本图像 [code]
19. 单链表插入 [animation]
20. 插入代码：已知前驱节点 [code / code-walk]
21. 单链表删除 [animation]
22. 删除代码：已知前驱节点 [code / code-walk / complexity]
23. 头结点
24. 带头结点的链表类骨架 [code / code-walk]
25. 查找与前驱查找 [code / code-walk]
26. 删除指定值 [code / code-walk / complexity]
27. 双向链表与循环链表 [animation]
28. 双向链表删除 [code / code-walk]
29. 循环链表：Josephus 问题 [animation]
30. Josephus 算法 [code / code-walk]
31. 多项式 ADT
32. 多项式链表表示 [code / code-walk]
33. 多项式相加 [animation]
34. 多项式相加代码 [code / code-walk]
35. 多项式相加复杂度 [complexity]
36. 习题：倒数第 k 个结点 [animation / exercise]
37. 倒数第 k 个结点代码 [code / code-walk / complexity]
38. 游标链表 [animation]
39. 游标链表的分配与释放 [code / code-walk]
40. 链表应用：桶排序 [animation]
41. 顺序表与链表的多维比较 [complexity / runtime]
42. 选择结构的判断方法 [complexity / runtime]
43. 本节小结 [runtime]
44. 练习 1：顺序表删除移动次数 [animation / exercise]
45. 练习 2：单链表删除 [animation / code / exercise]
46. 练习 3：多项式相加 [animation / exercise]
47. 练习 4：反转单链表 [animation / code / complexity / exercise]

Inferred Teaching Segments

• Slides 1-1: 开场：从连续序列到可修改序列
• Slides 2-2: 学习目标
• Slides 3-3: 路线图
• Slides 4-4: 线性表 ADT
• Slides 5-6: 线性表的数学定义
• Slides 7-7: 工程连接：线性表在哪里出现
• Slides 8-17: ADT 操作集合
• Slides 18-19: 单链表的基本图像
• Slides 20-21: 插入代码：已知前驱节点
• Slides 22-30: 删除代码：已知前驱节点
• Slides 31-33: 多项式 ADT
• Slides 34-34: 多项式相加代码
• Slides 35-35: 多项式相加复杂度
• Slides 36-36: 习题：倒数第 k 个结点
• Slides 37-40: 倒数第 k 个结点代码
• Slides 41-42: 顺序表与链表的多维比较
• Slides 43-43: 本节小结
• Slides 44-44: 练习 1：顺序表删除移动次数
• Slides 45-45: 练习 2：单链表删除
• Slides 46-46: 练习 3：多项式相加
• Slides 47-47: 练习 4：反转单链表

Evidence Buckets

• Code-walk slides: C++ 顺序表接口, 单链表节点, 插入代码：已知前驱节点, 删除代码：已知前驱节点, 带头结点的链表类骨架, 查找与前驱查找, 删除指定值, 双向链表删除, Josephus 算法, 多项式链表表示, 多项式相加代码, 倒数第 k 个结点代码, 游标链表的分配与释放
• Complexity slides: 路线图, 顺序表的定位公式, 删除移动次数, 插入移动次数, 顺序表的优点与限制, 删除代码：已知前驱节点, 删除指定值, 多项式相加复杂度, 倒数第 k 个结点代码, 顺序表与链表的多维比较, 选择结构的判断方法, 练习 4：反转单链表
• Runtime/architecture slides: 开场：从连续序列到可修改序列, 学习目标, 工程连接：线性表在哪里出现, 顺序表的优点与限制, 顺序表与链表的多维比较, 选择结构的判断方法, 本节小结
• Industry/open-source slides: 工程连接：线性表在哪里出现
• Exercise slides: 习题：倒数第 k 个结点, 练习 1：顺序表删除移动次数, 练习 2：单链表删除, 练习 3：多项式相加, 练习 4：反转单链表

Animation References

• 线性表 ADT: listAdtContract
• 顺序表：数组表示: arraySearch
• 顺序表插入与删除: arrayInsertDelete
• 单链表插入: x6Pointer
• 单链表删除: singlyDelete
• 双向链表与循环链表: doubleCircularList
• 循环链表：Josephus 问题: josephusCircle
• 多项式相加: polynomialAddList
• 习题：倒数第 k 个结点: kthFromEnd
• 游标链表: cursorListViz
• 链表应用：桶排序: bucketListSort
• 练习 1：顺序表删除移动次数: arrayDeleteMoveExerciseViz
• 练习 2：单链表删除: singlyDeleteExerciseViz
• 练习 3：多项式相加: polynomialAddExerciseViz
• 练习 4：反转单链表: reverseListExerciseViz

03-stack-queue.qmd

• Slide count: 36
• Code blocks: 11
• Formula blocks: 22
• Table rows: 44
• Animation/demo references: 12
• Exercise/thinking slides: 4

Slide Flow

1. 受限线性表 [industry]
2. 学习目标 [complexity]
3. 路线图 [code]
4. 运行时性能：为什么端点操作重要 [complexity / runtime]
5. 栈模型 [animation]
6. 栈 ADT
7. 链式栈 [code]
8. 链式栈代码 [code / code-walk]
9. 数组栈
10. 数组栈代码 [code / code-walk]
11. 两个栈共享一个数组 [animation]
12. 栈应用一：括号匹配 [animation]
13. 括号匹配代码 [code / code-walk / complexity]
14. 表达式处理的两步
15. 后缀表达式求值 [animation]
16. 后缀表达式求值代码 [code / code-walk]
17. 中缀转后缀 [animation]
18. 中缀转后缀规则
19. 队列模型
20. 队列 ADT
21. 普通数组队列的问题 [complexity]
22. 循环队列 [animation]
23. 循环队列代码 [code / code-walk]
24. 只保存 rear 和 length
25. 链式队列 [code]
26. 链式队列代码 [code / code-walk]
27. 队列应用一：杨辉三角 [animation]
28. 队列应用二：网格布线 [animation]
29. 网格布线算法 [code / code-walk]
30. 网格布线复杂度 [complexity]
31. 栈与队列对比
32. 练习 1：打印缓冲区 [animation / exercise]
33. 练习 2：栈容量 [animation / exercise]
34. 练习 3：循环队列 [animation / exercise]
35. 练习 4：循环左移 [animation / exercise]
36. 循环左移代码 [code / code-walk / complexity]

Inferred Teaching Segments

• Slides 1-1: 受限线性表
• Slides 2-2: 学习目标
• Slides 3-5: 路线图
• Slides 6-7: 栈 ADT
• Slides 8-9: 链式栈代码
• Slides 10-12: 数组栈代码
• Slides 13-15: 括号匹配代码
• Slides 16-19: 后缀表达式求值代码
• Slides 20-22: 队列 ADT
• Slides 23-25: 循环队列代码
• Slides 26-29: 链式队列代码
• Slides 30-31: 网格布线复杂度
• Slides 32-32: 练习 1：打印缓冲区
• Slides 33-33: 练习 2：栈容量
• Slides 34-34: 练习 3：循环队列
• Slides 35-35: 练习 4：循环左移
• Slides 36-36: 循环左移代码

Evidence Buckets

• Code-walk slides: 链式栈代码, 数组栈代码, 括号匹配代码, 后缀表达式求值代码, 循环队列代码, 链式队列代码, 网格布线算法, 循环左移代码
• Complexity slides: 学习目标, 运行时性能：为什么端点操作重要, 括号匹配代码, 普通数组队列的问题, 网格布线复杂度, 循环左移代码
• Runtime/architecture slides: 运行时性能：为什么端点操作重要
• Industry/open-source slides: 受限线性表
• Exercise slides: 练习 1：打印缓冲区, 练习 2：栈容量, 练习 3：循环队列, 练习 4：循环左移

Animation References

• 栈模型: stackModelViz
• 两个栈共享一个数组: twoStacksArray
• 栈应用一：括号匹配: parenMatchingViz
• 后缀表达式求值: postfixEvalViz
• 中缀转后缀: infixPostfixViz
• 循环队列: circularQueueViz
• 队列应用一：杨辉三角: pascalQueueViz
• 队列应用二：网格布线: wireRoutingViz
• 练习 1：打印缓冲区: printBufferExerciseViz
• 练习 2：栈容量: stackCapacityExerciseViz
• 练习 3：循环队列: circularQueueExerciseViz
• 练习 4：循环左移: rotateLeftExerciseViz

04-specific-trees.qmd

• Slide count: 35
• Code blocks: 12
• Formula blocks: 24
• Table rows: 35
• Animation/demo references: 13
• Exercise/thinking slides: 5

Slide Flow

1. 开场：查找树的主线 [complexity / runtime / industry]
2. 学习目标 [complexity]
3. 路线图 [code]
4. 二叉搜索树定义
5. BST 示例 [code]
6. 查找操作 [animation / code / code-walk / complexity]
7. findMin 与 findMax [code / code-walk]
8. BST 插入 [code / code-walk]
9. BST 删除三种情况 [animation]
10. 删除代码 [code / code-walk]
11. BST 退化 [complexity]
12. Indexed BST
13. 第 k 小查询 [animation / code / code-walk / complexity]
14. AVL 树定义
15. AVL 插入与旋转 [animation]
16. AVL 插入流程
17. 四种 AVL 失衡
18. 右单旋代码 [code / code-walk]
19. 双旋代码 [code / code-walk]
20. AVL 高度界 [complexity]
21. m-way Search Tree
22. m 路搜索树示意 [animation / code]
23. B-tree 正确定义
24. B-tree 查找 [runtime]
25. B-tree 插入 [animation]
26. B-tree 删除 [animation]
27. B+ tree 定义
28. B-tree 与 B+ tree 对比 [animation / industry]
29. 为什么数据库常用 B+ tree [runtime / industry]
30. 多维分析 [complexity / runtime]
31. 练习 1：插入 BST [animation / code / exercise]
32. 练习 2：检测 BST [animation / code / code-walk / exercise]
33. 练习 3：路径三集合判断 [animation / exercise]
34. 练习 4：AVL 最少结点数 [animation / complexity / exercise]
35. 练习 5：B-tree 与 B+ tree [animation / exercise]

Inferred Teaching Segments

• Slides 1-1: 开场：查找树的主线
• Slides 2-2: 学习目标
• Slides 3-3: 路线图
• Slides 4-9: 二叉搜索树定义
• Slides 10-13: 删除代码
• Slides 14-17: AVL 树定义
• Slides 18-18: 右单旋代码
• Slides 19-22: 双旋代码
• Slides 23-26: B-tree 正确定义
• Slides 27-29: B+ tree 定义
• Slides 30-30: 多维分析
• Slides 31-31: 练习 1：插入 BST
• Slides 32-32: 练习 2：检测 BST
• Slides 33-33: 练习 3：路径三集合判断
• Slides 34-34: 练习 4：AVL 最少结点数
• Slides 35-35: 练习 5：B-tree 与 B+ tree

Evidence Buckets

• Code-walk slides: 查找操作, findMin 与 findMax, BST 插入, 删除代码, 第 k 小查询, 右单旋代码, 双旋代码, 练习 2：检测 BST
• Complexity slides: 开场：查找树的主线, 学习目标, 查找操作, BST 退化, 第 k 小查询, AVL 高度界, 多维分析, 练习 4：AVL 最少结点数
• Runtime/architecture slides: 开场：查找树的主线, B-tree 查找, 为什么数据库常用 B+ tree, 多维分析
• Industry/open-source slides: 开场：查找树的主线, B-tree 与 B+ tree 对比, 为什么数据库常用 B+ tree
• Exercise slides: 练习 1：插入 BST, 练习 2：检测 BST, 练习 3：路径三集合判断, 练习 4：AVL 最少结点数, 练习 5：B-tree 与 B+ tree

Animation References

• 查找操作: bstFindViz
• BST 删除三种情况: bstDeleteCasesViz
• 第 k 小查询: indexedBstSelectViz
• AVL 插入与旋转: avlRotation
• m 路搜索树示意: mwaySearchViz
• B-tree 插入: btreeInsertSplitViz
• B-tree 删除: btreeDeleteRebalanceViz
• B-tree 与 B+ tree 对比: btreeBplusCompareViz
• 练习 1：插入 BST: bstInsertExerciseViz
• 练习 2：检测 BST: bstValidateExerciseViz
• 练习 3：路径三集合判断: bstPathSetsExerciseViz
• 练习 4：AVL 最少结点数: avlMinNodesExerciseViz
• 练习 5：B-tree 与 B+ tree: btreeBplusExerciseViz

04-tree.qmd

• Slide count: 50
• Code blocks: 20
• Formula blocks: 48
• Table rows: 39
• Animation/demo references: 13
• Exercise/thinking slides: 6

Slide Flow

1. 从线性结构到层级结构 [industry]
2. 学习目标
3. 路线图 [code]
4. 普通树定义
5. 树的术语 [animation]
6. 线性结构与树结构
7. 二叉树定义
8. 二叉树与普通树的区别
9. 表达式二叉树 [code]
10. 二叉树性质 [animation]
11. 二叉树边数性质
12. 第 i 层结点上界
13. 叶结点与二度结点
14. 满二叉树与完全二叉树
15. 完全二叉树数组公式
16. 二叉树存储一：数组表示 [animation]
17. 二叉树存储二：链式表示 [code / code-walk]
18. 二叉树存储三：游标表示
19. 运行时性能：树的表示会影响机器代价 [complexity / runtime / industry]
20. BinaryTree 类接口 [code / code-walk]
21. MakeTree [code / code-walk]
22. BreakTree [code / code-walk]
23. 二叉树遍历 [animation]
24. 递归先序遍历 [code / code-walk]
25. 递归中序遍历 [code / code-walk]
26. 递归后序遍历 [code / code-walk]
27. 层序遍历 [code / code-walk]
28. 非递归中序遍历 [code / code-walk]
29. 树高 [code / code-walk]
30. 由先序和中序构造二叉树 [animation]
31. 构造算法 [code / code-walk]
32. 哪些序列能唯一构造
33. 普通树的长子兄弟表示 [code / code-walk]
34. 树转二叉树 [code]
35. 森林转二叉树
36. 普通树遍历
37. 线索二叉树动机
38. 中序线索树 [animation / code / code-walk]
39. 中序线索遍历 [code / code-walk]
40. Huffman 树 [animation]
41. 带权外路径长度
42. Huffman 算法 [code / code-walk]
43. Huffman 编码
44. 多维分析 [complexity]
45. 练习 1：叶结点公式 [animation / exercise]
46. 练习 2：完全二叉树最大结点数 [animation / exercise]
47. 练习 3：树的叶结点数 [animation / exercise]
48. 练习 4：递归统计叶结点 [animation / code / complexity / exercise]
49. 练习 5：交换左右子树 [animation / code / exercise]
50. 练习 6：Huffman 性质判断 [animation / exercise]

Inferred Teaching Segments

• Slides 1-1: 从线性结构到层级结构
• Slides 2-2: 学习目标
• Slides 3-3: 路线图
• Slides 4-6: 普通树定义
• Slides 7-43: 二叉树定义
• Slides 44-44: 多维分析
• Slides 45-45: 练习 1：叶结点公式
• Slides 46-46: 练习 2：完全二叉树最大结点数
• Slides 47-47: 练习 3：树的叶结点数
• Slides 48-48: 练习 4：递归统计叶结点
• Slides 49-49: 练习 5：交换左右子树
• Slides 50-50: 练习 6：Huffman 性质判断

Evidence Buckets

• Code-walk slides: 二叉树存储二：链式表示, BinaryTree 类接口, MakeTree, BreakTree, 递归先序遍历, 递归中序遍历, 递归后序遍历, 层序遍历, 非递归中序遍历, 树高, 构造算法, 普通树的长子兄弟表示, 中序线索树, 中序线索遍历, Huffman 算法
• Complexity slides: 运行时性能：树的表示会影响机器代价, 多维分析, 练习 4：递归统计叶结点
• Runtime/architecture slides: 运行时性能：树的表示会影响机器代价
• Industry/open-source slides: 从线性结构到层级结构, 运行时性能：树的表示会影响机器代价
• Exercise slides: 练习 1：叶结点公式, 练习 2：完全二叉树最大结点数, 练习 3：树的叶结点数, 练习 4：递归统计叶结点, 练习 5：交换左右子树, 练习 6：Huffman 性质判断

Animation References

• 树的术语: treeTerminologyViz
• 二叉树性质: binaryTreePropertyViz
• 二叉树存储一：数组表示: binaryStorageCompareViz
• 二叉树遍历: traversalOrdersViz
• 由先序和中序构造二叉树: preInBuildViz
• 中序线索树: threadedTreeViz
• Huffman 树: huffmanBuildViz
• 练习 1：叶结点公式: leafFormulaExerciseViz
• 练习 2：完全二叉树最大结点数: completeTreeMaxExerciseViz
• 练习 3：树的叶结点数: generalTreeLeavesExerciseViz
• 练习 4：递归统计叶结点: countLeavesExerciseViz
• 练习 5：交换左右子树: mirrorTreeExerciseViz
• 练习 6：Huffman 性质判断: huffmanPropertyExerciseViz

05-hashing.qmd

• Slide count: 72
• Code blocks: 17
• Formula blocks: 68
• Table rows: 36
• Animation/demo references: 26
• Exercise/thinking slides: 17

Slide Flow

1. 这一章为什么重要 [runtime / industry]
2. 本章路线图
3. 学习目标
4. 从查找问题开始 [animation]
5. 散列表的基本图像 [animation]
6. 演示：取余散列 [animation]
7. 碰撞不可避免：概率视角 [animation]
8. 装载因子
9. 散列函数一：取余法
10. 为什么常选质数 [animation]
11. 散列函数二：平方取中法
12. 散列函数三：乘法散列
13. 字符串散列：简单求和的问题 [code / code-walk]
14. 字符串散列：多项式滚动 [code / code-walk]
15. 散列函数的多维分析
16. 碰撞处理总览
17. 线性探测 [animation]
18. 线性探测的平均查找长度 [complexity]
19. 聚集问题 [animation]
20. 线性探测：11 桶插入动画 [animation]
21. 线性探测：ASL 计算 [complexity]
22. 字符串散列：只看首字母的风险
23. 删除不能简单清空 [animation]
24. 工程主线：本章使用同一套 C++ 代码 [code / runtime]
25. 代码 1：状态与表项定义 [code / code-walk / runtime]
26. 代码 2：类接口 [code / code-walk]
27. 代码 3：散列函数 [code / code-walk]
28. 代码 4：寻找槽位 [code / code-walk]
29. 代码 5：插入 [code / code-walk]
30. 代码 6：查找 [code / code-walk]
31. 代码 7：删除 [code / code-walk]
32. 二次探测 [animation]
33. 二次探测的分析 [runtime]
34. 双散列
35. 双散列演示 [animation]
36. 双散列的约束
37. 再散列 [animation]
38. 代码 8：再散列 [code / code-walk / complexity]
39. 拉链法 [animation]
40. 拉链法：C++ 结构 [code / code-walk]
41. 多维比较 [runtime]
42. 前沿连接：大规模系统中的散列 [code / industry]
43. 前沿连接：安全与可靠性 [complexity]
44. 小结
45. 代码 9：main 函数 [code / code-walk]
46. 代码 10：CMakeLists.txt [code / code-walk]
47. 代码之后：统一分析框架 [complexity / runtime]
48. 开放寻址：三种探测策略比较 [runtime]
49. 成功查找与失败查找
50. 装载因子、再散列与摊还成本 [complexity]
51. 散列函数质量：不仅是“均匀”
52. 拉链法的多维分析 [runtime]
53. 工程选型：什么时候用哪一种 [runtime]
54. 可运行代码 [code / code-walk]
55. 习题 1 [exercise]
56. 习题 1 答案 [animation / exercise]
57. 习题 1 答案：二次探测 [animation / exercise]
58. 习题 1 答案：拉链与双散列 [animation / exercise]
59. 习题 1 答案：双散列 [animation / exercise]
60. 习题 2 [complexity / exercise]
61. 习题 2 答案 [animation / complexity / exercise]
62. 习题 2 答案：拉链法 [animation / exercise]
63. 习题 3 [exercise]
64. 习题 3 答案：拉链法 [animation / exercise]
65. 习题 3 答案：线性探测 [animation / exercise]
66. 习题 3 答案：二次探测 [animation / exercise]
67. 习题 3 答案：双散列 [animation / exercise]
68. 习题 4 [exercise]
69. 习题 4 答案：线性开放寻址 [animation / exercise]
70. 习题 4 答案：成功查找 ASL [animation / complexity / exercise]
71. 习题 4 答案：拉链法 [animation / exercise]
72. 延伸阅读 [industry]

Inferred Teaching Segments

• Slides 1-1: 这一章为什么重要
• Slides 2-2: 本章路线图
• Slides 3-3: 学习目标
• Slides 4-4: 从查找问题开始
• Slides 5-14: 散列表的基本图像
• Slides 15-23: 散列函数的多维分析
• Slides 24-24: 工程主线：本章使用同一套 C++ 代码
• Slides 25-25: 代码 1：状态与表项定义
• Slides 26-26: 代码 2：类接口
• Slides 27-27: 代码 3：散列函数
• Slides 28-28: 代码 4：寻找槽位
• Slides 29-29: 代码 5：插入
• Slides 30-30: 代码 6：查找
• Slides 31-37: 代码 7：删除
• Slides 38-40: 代码 8：再散列
• Slides 41-41: 多维比较
• Slides 42-42: 前沿连接：大规模系统中的散列
• Slides 43-43: 前沿连接：安全与可靠性
• Slides 44-44: 小结
• Slides 45-45: 代码 9：main 函数
• Slides 46-46: 代码 10：CMakeLists.txt
• Slides 47-51: 代码之后：统一分析框架
• Slides 52-52: 拉链法的多维分析
• Slides 53-53: 工程选型：什么时候用哪一种
• Slides 54-54: 可运行代码
• Slides 55-55: 习题 1
• Slides 56-56: 习题 1 答案
• Slides 57-57: 习题 1 答案：二次探测
• Slides 58-58: 习题 1 答案：拉链与双散列
• Slides 59-59: 习题 1 答案：双散列
• Slides 60-60: 习题 2
• Slides 61-61: 习题 2 答案
• Slides 62-62: 习题 2 答案：拉链法
• Slides 63-63: 习题 3
• Slides 64-64: 习题 3 答案：拉链法
• Slides 65-65: 习题 3 答案：线性探测
• Slides 66-66: 习题 3 答案：二次探测
• Slides 67-67: 习题 3 答案：双散列
• Slides 68-68: 习题 4
• Slides 69-69: 习题 4 答案：线性开放寻址
• Slides 70-70: 习题 4 答案：成功查找 ASL
• Slides 71-72: 习题 4 答案：拉链法

Evidence Buckets

• Code-walk slides: 字符串散列：简单求和的问题, 字符串散列：多项式滚动, 代码 1：状态与表项定义, 代码 2：类接口, 代码 3：散列函数, 代码 4：寻找槽位, 代码 5：插入, 代码 6：查找, 代码 7：删除, 代码 8：再散列, 拉链法：C++ 结构, 代码 9：main 函数, 代码 10：CMakeLists.txt, 可运行代码
• Complexity slides: 线性探测的平均查找长度, 线性探测：ASL 计算, 代码 8：再散列, 前沿连接：安全与可靠性, 代码之后：统一分析框架, 装载因子、再散列与摊还成本, 习题 2, 习题 2 答案, 习题 4 答案：成功查找 ASL
• Runtime/architecture slides: 这一章为什么重要, 工程主线：本章使用同一套 C++ 代码, 代码 1：状态与表项定义, 二次探测的分析, 多维比较, 代码之后：统一分析框架, 开放寻址：三种探测策略比较, 拉链法的多维分析, 工程选型：什么时候用哪一种
• Industry/open-source slides: 这一章为什么重要, 前沿连接：大规模系统中的散列, 延伸阅读
• Exercise slides: 习题 1, 习题 1 答案, 习题 1 答案：二次探测, 习题 1 答案：拉链与双散列, 习题 1 答案：双散列, 习题 2, 习题 2 答案, 习题 2 答案：拉链法, 习题 3, 习题 3 答案：拉链法, 习题 3 答案：线性探测, 习题 3 答案：二次探测, 习题 3 答案：双散列, 习题 4, 习题 4 答案：线性开放寻址, 习题 4 答案：成功查找 ASL, 习题 4 答案：拉链法

Animation References

• 从查找问题开始: hash-demo:search-start
• 散列表的基本图像: hash-demo:hash-basic-process
• 演示：取余散列: hash-demo:mod-hash
• 碰撞不可避免：概率视角: hash-demo:balls
• 为什么常选质数: hash-demo:prime-mod-compare
• 线性探测: hash-demo:linear-probing
• 聚集问题: hash-demo:cluster-linear
• 线性探测：11 桶插入动画: hash-demo:linear-probing
• 删除不能简单清空: hash-demo:delete-linear
• 二次探测: hash-demo:quadratic-probing
• 双散列演示: hash-demo:double-hashing
• 再散列: hash-demo:rehash
• 拉链法: hash-demo:chaining
• 习题 1 答案: hash-demo:linear-probing
• 习题 1 答案：二次探测: hash-demo:quadratic-probing
• 习题 1 答案：拉链与双散列: hash-demo:chaining
• 习题 1 答案：双散列: hash-demo:double-hashing
• 习题 2 答案: hash-demo:linear-probing
• 习题 2 答案：拉链法: hash-demo:chaining
• 习题 3 答案：拉链法: hash-demo:chaining
• 习题 3 答案：线性探测: hash-demo:linear-probing
• 习题 3 答案：二次探测: hash-demo:quadratic-probing
• 习题 3 答案：双散列: hash-demo:double-hashing
• 习题 4 答案：线性开放寻址: hash-demo:linear-probing
• 习题 4 答案：成功查找 ASL: hashAslExerciseViz
• 习题 4 答案：拉链法: hash-demo:chaining

06-priority-queue.qmd

• Slide count: 28
• Code blocks: 8
• Formula blocks: 16
• Table rows: 27
• Animation/demo references: 12
• Exercise/thinking slides: 3

Slide Flow

1. 为什么需要优先队列 [runtime / industry]
2. 学习目标 [complexity]
3. 路线图 [code]
4. Priority Queue ADT
5. 线性表实现 [complexity]
6. 堆定义
7. 最大堆示例 [code]
8. 数组表示 [animation]
9. 上滤与下滤 [animation]
10. 最大堆类骨架 [code / code-walk]
11. 插入：上滤代码 [animation / code / code-walk]
12. 删除堆顶：下滤代码 [animation / code / code-walk]
13. 单次操作复杂度 [complexity]
14. 建堆方法一：逐个插入 [complexity]
15. 建堆方法二：Floyd 建堆 [animation]
16. Floyd 建堆代码 [code / code-walk]
17. Floyd 建堆复杂度 [complexity]
18. 堆排序 [animation]
19. 堆排序流程 [complexity]
20. 为什么堆排序不稳定
21. 第 K 大元素 [animation]
22. 第 K 大元素算法 [animation / complexity]
23. Top-K 代码 [code / code-walk]
24. 应用：事件模拟 [animation / complexity]
25. 多维分析 [complexity]
26. 练习 1：最小堆插入 3 [animation / exercise]
27. 练习 2：判断是否为堆 [animation / code / code-walk / exercise]
28. 练习 3：堆排序复杂度 [animation / complexity / exercise]

Inferred Teaching Segments

• Slides 1-1: 为什么需要优先队列
• Slides 2-2: 学习目标
• Slides 3-3: 路线图
• Slides 4-5: Priority Queue ADT
• Slides 6-10: 堆定义
• Slides 11-11: 插入：上滤代码
• Slides 12-12: 删除堆顶：下滤代码
• Slides 13-15: 单次操作复杂度
• Slides 16-16: Floyd 建堆代码
• Slides 17-22: Floyd 建堆复杂度
• Slides 23-24: Top-K 代码
• Slides 25-25: 多维分析
• Slides 26-26: 练习 1：最小堆插入 3
• Slides 27-27: 练习 2：判断是否为堆
• Slides 28-28: 练习 3：堆排序复杂度

Evidence Buckets

• Code-walk slides: 最大堆类骨架, 插入：上滤代码, 删除堆顶：下滤代码, Floyd 建堆代码, Top-K 代码, 练习 2：判断是否为堆
• Complexity slides: 学习目标, 线性表实现, 单次操作复杂度, 建堆方法一：逐个插入, Floyd 建堆复杂度, 堆排序流程, 第 K 大元素算法, 应用：事件模拟, 多维分析, 练习 3：堆排序复杂度
• Runtime/architecture slides: 为什么需要优先队列
• Industry/open-source slides: 为什么需要优先队列
• Exercise slides: 练习 1：最小堆插入 3, 练习 2：判断是否为堆, 练习 3：堆排序复杂度

Animation References

• 数组表示: heapArrayMappingViz
• 上滤与下滤: heapOperationViz
• 插入：上滤代码: heapInsertDetailedViz
• 删除堆顶：下滤代码: heapDeleteDetailedViz
• 建堆方法二：Floyd 建堆: heapBuildViz
• 堆排序: heapSortViz
• 第 K 大元素: topKViz
• 第 K 大元素算法: topKCompareViz
• 应用：事件模拟: priorityEventSimViz
• 练习 1：最小堆插入 3: heapInsertExerciseViz
• 练习 2：判断是否为堆: heapCheckExerciseViz
• 练习 3：堆排序复杂度: heapSortComplexityExerciseViz

07-disjoint-set.qmd

• Slide count: 24
• Code blocks: 8
• Formula blocks: 18
• Table rows: 6
• Animation/demo references: 12
• Exercise/thinking slides: 3

Slide Flow

1. 动态维护等价类 [industry]
2. 学习目标 [complexity]
3. 路线图 [code]
4. 等价关系
5. 等价类示例 [animation]
6. Online 操作 [code / code-walk]
7. 森林表示 [animation]
8. parent 数组
9. parent 数组追踪 [animation]
10. 简单实现 [code / code-walk / complexity]
11. 最坏情况 [animation / complexity]
12. 按大小合并 [animation / code / code-walk]
13. 按秩合并 [code / code-walk]
14. 路径压缩 [animation / code / code-walk]
15. 完整 C++ 实现 [code / code-walk]
16. 复杂度 [complexity]
17. 运行时性能：parent 数组为什么快 [complexity / runtime]
18. 复杂度策略对照 [animation / complexity]
19. 应用一：动态连通性 [animation / code / code-walk]
20. 应用二：Kruskal 算法 [animation]
21. 多维分析 [complexity]
22. 练习 1：等价类合并 [animation / exercise]
23. 练习 2：路径压缩结果 [animation / exercise]
24. 练习 3：Kruskal 中为什么需要并查集 [animation / exercise]

Inferred Teaching Segments

• Slides 1-1: 动态维护等价类
• Slides 2-2: 学习目标
• Slides 3-15: 路线图
• Slides 16-17: 复杂度
• Slides 18-20: 复杂度策略对照
• Slides 21-21: 多维分析
• Slides 22-22: 练习 1：等价类合并
• Slides 23-23: 练习 2：路径压缩结果
• Slides 24-24: 练习 3：Kruskal 中为什么需要并查集

Evidence Buckets

• Code-walk slides: Online 操作, 简单实现, 按大小合并, 按秩合并, 路径压缩, 完整 C++ 实现, 应用一：动态连通性
• Complexity slides: 学习目标, 简单实现, 最坏情况, 复杂度, 运行时性能：parent 数组为什么快, 复杂度策略对照, 多维分析
• Runtime/architecture slides: 运行时性能：parent 数组为什么快
• Industry/open-source slides: 动态维护等价类
• Exercise slides: 练习 1：等价类合并, 练习 2：路径压缩结果, 练习 3：Kruskal 中为什么需要并查集

Animation References

• 等价类示例: dsuEquivalenceViz
• 森林表示: disjointSetViz
• parent 数组追踪: dsuParentTraceViz
• 最坏情况: dsuWorstCaseViz
• 按大小合并: dsuWeightedUnionViz
• 路径压缩: dsuPathCompressionViz
• 复杂度策略对照: dsuAmortizedCompareViz
• 应用一：动态连通性: dsuConnectivityViz
• 应用二：Kruskal 算法: dsuKruskalViz
• 练习 1：等价类合并: dsuEquivalenceExerciseViz
• 练习 2：路径压缩结果: dsuPathExerciseViz
• 练习 3：Kruskal 中为什么需要并查集: dsuKruskalExerciseViz

08-graph.qmd

• Slide count: 50
• Code blocks: 13
• Formula blocks: 40
• Table rows: 25
• Animation/demo references: 15
• Exercise/thinking slides: 4

Slide Flow

1. 图表示关系网络 [runtime / industry]
2. 学习目标
3. 路线图 [code]
4. 图的定义
5. 无向图与有向图 [code]
6. 完全图
7. 顶点的度
8. 路径、简单路径和环
9. 连通性
10. 网络
11. Graph ADT [code / code-walk]
12. 邻接矩阵 [animation]
13. 邻接矩阵分析 [complexity]
14. 邻接表 [code]
15. 邻接表分析 [complexity]
16. 逆邻接表、十字链表和邻接多重表
17. DFS 思想 [animation]
18. DFS 代码 [code / code-walk / complexity]
19. BFS 思想 [animation]
20. BFS 代码 [code / code-walk]
21. 非连通图的连通分量 [code / code-walk]
22. 生成树
23. 最小生成树
24. Kruskal 算法 [animation]
25. Kruskal 代码 [code / code-walk]
26. Kruskal 分析 [complexity]
27. Prim 算法 [animation]
28. Prim 思想
29. Prim 数组 [complexity]
30. 最小生成树不唯一
31. 单源最短路径
32. Dijkstra 算法 [animation]
33. Dijkstra 松弛过程 [animation]
34. Dijkstra 代码 [code / code-walk]
35. Dijkstra 为什么要求非负权
36. Bellman-Ford [animation / code / code-walk / complexity]
37. Floyd 算法 [animation]
38. Floyd 转移 [code / code-walk / complexity]
39. AOV 网与拓扑排序
40. 拓扑排序算法 [animation]
41. 拓扑排序代码 [code / code-walk]
42. AOE 网与关键路径 [animation]
43. 关键路径定义
44. 关键路径计算
45. 算法复杂度小结 [complexity]
46. 运行时性能：不仅看 Big-O [complexity / runtime]
47. 练习 1：无向连通图性质 [animation / exercise]
48. 练习 2：错误的最短路贪心 [animation / code / exercise]
49. 练习 3：拓扑排序 [animation / exercise]
50. 练习 4：Kruskal 与 Prim [animation / exercise]

Inferred Teaching Segments

• Slides 1-1: 图表示关系网络
• Slides 2-2: 学习目标
• Slides 3-3: 路线图
• Slides 4-10: 图的定义
• Slides 11-17: Graph ADT
• Slides 18-19: DFS 代码
• Slides 20-24: BFS 代码
• Slides 25-33: Kruskal 代码
• Slides 34-40: Dijkstra 代码
• Slides 41-42: 拓扑排序代码
• Slides 43-44: 关键路径定义
• Slides 45-46: 算法复杂度小结
• Slides 47-47: 练习 1：无向连通图性质
• Slides 48-48: 练习 2：错误的最短路贪心
• Slides 49-49: 练习 3：拓扑排序
• Slides 50-50: 练习 4：Kruskal 与 Prim

Evidence Buckets

• Code-walk slides: Graph ADT, DFS 代码, BFS 代码, 非连通图的连通分量, Kruskal 代码, Dijkstra 代码, Bellman-Ford, Floyd 转移, 拓扑排序代码
• Complexity slides: 邻接矩阵分析, 邻接表分析, DFS 代码, Kruskal 分析, Prim 数组, Bellman-Ford, Floyd 转移, 算法复杂度小结, 运行时性能：不仅看 Big-O
• Runtime/architecture slides: 图表示关系网络, 运行时性能：不仅看 Big-O
• Industry/open-source slides: 图表示关系网络
• Exercise slides: 练习 1：无向连通图性质, 练习 2：错误的最短路贪心, 练习 3：拓扑排序, 练习 4：Kruskal 与 Prim

Animation References

• 邻接矩阵: adjacencyMatrix
• DFS 思想: dfsTraversalViz
• BFS 思想: graphBfs
• Kruskal 算法: kruskalViz
• Prim 算法: primViz
• Dijkstra 算法: dijkstraDemo
• Dijkstra 松弛过程: dijkstraRelaxViz
• Bellman-Ford: bellmanFordViz
• Floyd 算法: floydViz
• 拓扑排序算法: topologicalSortViz
• AOE 网与关键路径: criticalPathViz
• 练习 1：无向连通图性质: connectedGraphExerciseViz
• 练习 2：错误的最短路贪心: badShortestGreedyExerciseViz
• 练习 3：拓扑排序: topologicalExerciseViz
• 练习 4：Kruskal 与 Prim: mstCompareExerciseViz

09-sorting.qmd

• Slide count: 44
• Code blocks: 12
• Formula blocks: 54
• Table rows: 29
• Animation/demo references: 13
• Exercise/thinking slides: 4

Slide Flow

1. 排序问题
2. 学习目标
3. 排序评价维度 [complexity]
4. 稳定性
5. 内排序与外排序 [runtime]
6. 工程连接：排序库如何选择算法 [complexity / runtime / industry]
7. 路线图 [code]
8. 数据表抽象 [code / code-walk]
9. 直接插入排序思想 [animation]
10. 直接插入排序代码 [code / code-walk]
11. 直接插入排序分析 [complexity]
12. 平均情况 [complexity]
13. 折半插入排序 [code / code-walk]
14. 折半插入排序分析 [complexity]
15. 希尔排序 [animation]
16. 希尔排序思想
17. 希尔排序代码 [code / code-walk]
18. 冒泡排序 [animation]
19. 冒泡排序代码 [code / code-walk]
20. 快速排序思想 [animation]
21. 快速排序递归结构 [complexity]
22. 快速排序 partition [code / code-walk]
23. 快速排序代码 [code / code-walk]
24. 快速排序分析 [complexity]
25. 直接选择排序 [animation]
26. 直接选择排序代码 [code / code-walk / complexity]
27. 锦标赛排序 [animation / complexity]
28. 堆排序 [complexity]
29. 堆排序代码 [code / code-walk]
30. 归并排序思想 [animation]
31. 归并排序递归结构 [complexity]
32. 合并两个有序区间 [code / code-walk]
33. 递归归并排序 [code / code-walk / complexity]
34. 迭代归并排序
35. 链表归并排序 [animation]
36. 基数排序 [animation]
37. 基数排序思想 [complexity]
38. 比较排序的下界 [complexity]
39. 排序算法总表 [complexity]
40. 如何选择排序算法 [runtime]
41. 练习 1：插入排序 [animation / exercise]
42. 练习 2：第二趟排序结果判断 [animation / exercise]
43. 练习 3：归并排序 [animation / exercise]
44. 练习 4：堆排序稳定性 [animation / exercise]

Inferred Teaching Segments

• Slides 1-1: 排序问题
• Slides 2-5: 学习目标
• Slides 6-6: 工程连接：排序库如何选择算法
• Slides 7-9: 路线图
• Slides 10-16: 直接插入排序代码
• Slides 17-18: 希尔排序代码
• Slides 19-22: 冒泡排序代码
• Slides 23-25: 快速排序代码
• Slides 26-28: 直接选择排序代码
• Slides 29-40: 堆排序代码
• Slides 41-41: 练习 1：插入排序
• Slides 42-42: 练习 2：第二趟排序结果判断
• Slides 43-43: 练习 3：归并排序
• Slides 44-44: 练习 4：堆排序稳定性

Evidence Buckets

• Code-walk slides: 数据表抽象, 直接插入排序代码, 折半插入排序, 希尔排序代码, 冒泡排序代码, 快速排序 partition, 快速排序代码, 直接选择排序代码, 堆排序代码, 合并两个有序区间, 递归归并排序
• Complexity slides: 排序评价维度, 工程连接：排序库如何选择算法, 直接插入排序分析, 平均情况, 折半插入排序分析, 快速排序递归结构, 快速排序分析, 直接选择排序代码, 锦标赛排序, 堆排序, 归并排序递归结构, 递归归并排序, 基数排序思想, 比较排序的下界, 排序算法总表
• Runtime/architecture slides: 内排序与外排序, 工程连接：排序库如何选择算法, 如何选择排序算法
• Industry/open-source slides: 工程连接：排序库如何选择算法
• Exercise slides: 练习 1：插入排序, 练习 2：第二趟排序结果判断, 练习 3：归并排序, 练习 4：堆排序稳定性

Animation References

• 直接插入排序思想: insertionSortViz
• 希尔排序: shellSortViz
• 冒泡排序: bubbleSortViz
• 快速排序思想: quickPartitionViz
• 直接选择排序: selectionSortViz
• 锦标赛排序: tournamentSortViz
• 归并排序思想: mergeSortViz
• 链表归并排序: linkedMergeViz
• 基数排序: radixSortViz
• 练习 1：插入排序: insertionSortExerciseViz
• 练习 2：第二趟排序结果判断: secondPassSortExerciseViz
• 练习 3：归并排序: mergeSortExerciseViz
• 练习 4：堆排序稳定性: heapStabilityExerciseViz