build

docs/chapter_appendix/contribution.md

@@ -0,0 +1,53 @@
+---
+comments: true
+---
+
+# 16.2   一起参与创作
+
+由于作者能力有限，书中难免存在一些遗漏和错误，请您谅解。如果您发现了笔误、失效链接、内容缺失、文字歧义、解释不清晰或行文结构不合理等问题，请协助我们进行修正，以给读者提供更优质的学习资源。
+
+所有[撰稿人](https://github.com/krahets/hello-algo/graphs/contributors)的 GitHub ID 将被展示在本书的仓库主页上，以感谢他们对开源社区的无私奉献。
+
+!!! success "开源的魅力"
+
+    纸质书籍的两次印刷的间隔时间往往需要数年，内容更新非常不方便。
+    
+    然而在本开源书中，内容更迭的时间被缩短至数日甚至几个小时。
+
+### 1.   内容微调
+
+如图 16-1 所示，每个页面的右上角都有“编辑图标”。您可以按照以下步骤修改文本或代码。
+
+1. 点击“编辑图标”，如果遇到“需要 Fork 此仓库”的提示，请同意该操作。
+2. 修改 Markdown 源文件内容，检查内容的正确性，并尽量保持排版格式的统一。
+3. 在页面底部填写修改说明，然后点击“Propose file change”按钮。页面跳转后，点击“Create pull request”按钮即可发起拉取请求。
+
+![页面编辑按键](contribution.assets/edit_markdown.png)
+
+<p align="center"> 图 16-1 &nbsp; 页面编辑按键 </p>
+
+图片无法直接修改，需要通过新建 [Issue](https://github.com/krahets/hello-algo/issues) 或评论留言来描述问题，我们会尽快重新绘制并替换图片。
+
+### 2. &nbsp; 内容创作
+
+如果您有兴趣参与此开源项目，包括将代码翻译成其他编程语言、扩展文章内容等，那么需要实施以下 Pull Request 工作流程。
+
+1. 登录 GitHub ，将[本仓库](https://github.com/krahets/hello-algo) Fork 到个人账号下。
+2. 进入您的 Fork 仓库网页，使用 `git clone` 命令将仓库克隆至本地。
+3. 在本地进行内容创作，并进行完整测试，验证代码的正确性。
+4. 将本地所做更改 Commit ，然后 Push 至远程仓库。
+5. 刷新仓库网页，点击“Create pull request”按钮即可发起拉取请求。
+
+### 3. &nbsp; Docker 部署
+
+在 `hello-algo` 根目录下，执行以下 Docker 脚本，即可在 `http://localhost:8000` 访问本项目。
+
+```shell
+docker-compose up -d
+```
+
+使用以下命令即可删除部署。
+
+```shell
+docker-compose down
+```

docs/chapter_appendix/index.md

@@ -0,0 +1,17 @@
+---
+comments: true
+icon: material/help-circle-outline
+---
+
+# 第 16 章   附录
+
+<div class="center-table" markdown>
+
+![附录](../assets/covers/chapter_appendix.jpg){ width="600" }
+
+</div>
+
+## 本章内容
+
+- [16.1 &nbsp; 编程环境安装](https://www.hello-algo.com/chapter_appendix/installation/)
+- [16.2 &nbsp; 一起参与创作](https://www.hello-algo.com/chapter_appendix/contribution/)

docs/chapter_appendix/installation.md

@@ -0,0 +1,59 @@
+---
+comments: true
+---
+
+# 16.1   编程环境安装
+
+### 1.   VSCode
+
+本书推荐使用开源轻量的 VSCode 作为本地 IDE ，下载并安装 [VSCode](https://code.visualstudio.com/) 。
+
+### 2.   Java 环境
+
+1. 下载并安装 [OpenJDK](https://jdk.java.net/18/)（版本需满足 > JDK 9）。
+2. 在 VSCode 的插件市场中搜索 `java` ，安装 Extension Pack for Java 。
+
+### 3.   C/C++ 环境
+
+1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)（[配置教程](https://blog.csdn.net/qq_33698226/article/details/129031241)），MacOS 自带 Clang 无须安装。
+2. 在 VSCode 的插件市场中搜索 `c++` ，安装 C/C++ Extension Pack 。
+3. （可选）打开 Settings 页面，搜索 `Clang_format_fallback Style` 代码格式化选项，设置为 `{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }` 。
+
+### 4.   Python 环境
+
+1. 下载并安装 [Miniconda3](https://docs.conda.io/en/latest/miniconda.html) 。
+2. 在 VSCode 的插件市场中搜索 `python` ，安装 Python Extension Pack 。
+3. （可选）在命令行输入 `pip install black` ，安装代码格式化工具。
+
+### 5.   Go 环境
+
+1. 下载并安装 [go](https://go.dev/dl/) 。
+2. 在 VSCode 的插件市场中搜索 `go` ，安装 Go 。
+3. 快捷键 `Ctrl + Shift + P` 呼出命令栏，输入 go ，选择 `Go: Install/Update Tools` ，全部勾选并安装即可。
+
+### 6.   JavaScript 环境
+
+1. 下载并安装 [node.js](https://nodejs.org/en/) 。
+2. 在 VSCode 的插件市场中搜索 `javascript` ，安装 JavaScript (ES6) code snippets 。
+3. （可选）在 VSCode 的插件市场中搜索 `Prettier` ，安装代码格式化工具。
+
+### 7.   C# 环境
+
+1. 下载并安装 [.Net 6.0](https://dotnet.microsoft.com/en-us/download) 。
+2. 在 VSCode 的插件市场中搜索 `C# Dev Kit` ，安装 C# Dev Kit （[配置教程](https://code.visualstudio.com/docs/csharp/get-started)）。
+3. 也可使用 Visual Studio（[安装教程](https://learn.microsoft.com/zh-cn/visualstudio/install/install-visual-studio?view=vs-2022)）。
+
+### 8.   Swift 环境
+
+1. 下载并安装 [Swift](https://www.swift.org/download/) 。
+2. 在 VSCode 的插件市场中搜索 `swift` ，安装 [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang) 。
+
+### 9.   Dart 环境
+
+1. 下载并安装 [Dart](https://dart.dev/get-dart) 。
+2. 在 VSCode 的插件市场中搜索 `dart` ，安装 [Dart](https://marketplace.visualstudio.com/items?itemName=Dart-Code.dart-code) 。
+
+### 10.   Rust 环境
+
+1. 下载并安装 [Rust](https://www.rust-lang.org/tools/install) 。
+2. 在 VSCode 的插件市场中搜索 `rust` ，安装 [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer) 。

docs/chapter_array_and_linkedlist/index.md

@@ -0,0 +1,25 @@
+---
+comments: true
+icon: material/view-list-outline
+---
+
+# 第 4 章   数组与链表
+
+<div class="center-table" markdown>
+
+![数组与链表](../assets/covers/chapter_array_and_linkedlist.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    数据结构的世界如同一堵厚实的砖墙。
+
+    数组的砖块整齐排列，逐个紧贴。链表的砖块分散各处，连接的藤蔓自由地穿梭于砖缝之间。
+
+## 本章内容
+
+- [4.1 &nbsp; 数组](https://www.hello-algo.com/chapter_array_and_linkedlist/array/)
+- [4.2 &nbsp; 链表](https://www.hello-algo.com/chapter_array_and_linkedlist/linked_list/)
+- [4.3 &nbsp; 列表](https://www.hello-algo.com/chapter_array_and_linkedlist/list/)
+- [4.4 &nbsp; 小结](https://www.hello-algo.com/chapter_array_and_linkedlist/summary/)

docs/chapter_array_and_linkedlist/summary.md

@@ -0,0 +1,72 @@
+---
+comments: true
+---
+
+# 4.4   小结
+
+### 1.   重点回顾
+
+- 数组和链表是两种基本的数据结构，分别代表数据在计算机内存中的两种存储方式：连续空间存储和分散空间存储。两者的特点呈现出互补的特性。
+- 数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变。
+- 链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、循环链表、双向链表。
+- 动态数组，又称列表，是基于数组实现的一种数据结构。它保留了数组的优势，同时可以灵活调整长度。列表的出现极大地提高了数组的易用性，但可能导致部分内存空间浪费。
+
+### 2.   Q & A
+
+!!! question "数组存储在栈上和存储在堆上，对时间效率和空间效率是否有影响？"
+
+    存储在栈上和堆上的数组都被存储在连续内存空间内，数据操作效率是基本一致的。然而，栈和堆具有各自的特点，从而导致以下不同点。
+
+    1. 分配和释放效率：栈是一块较小的内存，分配由编译器自动完成；而堆内存相对更大，可以在代码中动态分配，更容易碎片化。因此，堆上的分配和释放操作通常比栈上的慢。
+    2. 大小限制：栈内存相对较小，堆的大小一般受限于可用内存。因此堆更加适合存储大型数组。
+    3. 灵活性：栈上的数组的大小需要在编译时确定，而堆上的数组的大小可以在运行时动态确定。
+
+!!! question "为什么数组要求相同类型的元素，而在链表中却没有强调同类型呢？"
+
+    链表由结点组成，结点之间通过引用（指针）连接，各个结点可以存储不同类型的数据，例如 int、double、string、object 等。
+
+    相对地，数组元素则必须是相同类型的，这样才能通过计算偏移量来获取对应元素位置。例如，如果数组同时包含 int 和 long 两种类型，单个元素分别占用 4 bytes 和 8 bytes ，那么此时就不能用以下公式计算偏移量了，因为数组中包含了两种长度的元素。
+
+    ```shell
+    # 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
+    ```
+
+!!! question "删除节点后，是否需要把 `P.next` 设为 $\text{None}$ 呢？"
+
+    不修改 `P.next` 也可以。从该链表的角度看，从头结点遍历到尾结点已经遇不到 `P` 了。这意味着结点 `P` 已经从链表中删除了，此时结点 `P` 指向哪里都不会对这条链表产生影响了。
+
+    从垃圾回收的角度看，对于 Java、Python、Go 等拥有自动垃圾回收的语言来说，节点 `P` 是否被回收取决于是否有仍存在指向它的引用，而不是 `P.next` 的值。在 C 和 C++ 等语言中，我们需要手动释放节点内存。
+
+!!! question "在链表中插入和删除操作的时间复杂度是 $O(1)$ 。但是增删之前都需要 $O(n)$ 查找元素，那为什么时间复杂度不是 $O(n)$ 呢？"
+
+    如果是先查找元素、再删除元素，确实是 $O(n)$ 。然而，链表的 $O(1)$ 增删的优势可以在其他应用上得到体现。例如，双向队列适合使用链表实现，我们维护一个指针变量始终指向头结点、尾结点，每次插入与删除操作都是 $O(1)$ 。
+
+!!! question "图片“链表定义与存储方式”中，浅蓝色的存储结点指针是占用一块内存地址吗？还是和结点值各占一半呢？"
+
+    文中的示意图只是定性表示，定量表示需要根据具体情况进行分析。
+
+    - 不同类型的结点值占用的空间是不同的，比如 int、long、double 和实例对象等。
+    - 指针变量占用的内存空间大小根据所使用的操作系统及编译环境而定，大多为 8 字节或 4 字节。
+
+!!! question "在列表末尾添加元素是否时时刻刻都为 $O(1)$ ？"
+
+    如果添加元素时超出列表长度，则需要先扩容列表再添加。系统会申请一块新的内存，并将原列表的所有元素搬运过去，这时候时间复杂度就会是 $O(n)$ 。
+
+!!! question "“列表的出现大大提升了数组的实用性，但副作用是会造成部分内存空间浪费”，这里的空间浪费是指额外增加的变量如容量、长度、扩容倍数所占的内存吗？"
+
+    这里的空间浪费主要有两方面含义：一方面，列表都会设定一个初始长度，我们不一定需要用这么多。另一方面，为了防止频繁扩容，扩容一般都会乘以一个系数，比如 $\times 1.5$ 。这样一来，也会出现很多空位，我们通常不能完全填满它们。
+
+!!! question "在 Python 中初始化 `n = [1, 2, 3]` 后，这 3 个元素的地址是相连的，但是初始化 `m = [2, 1, 3]` 会发现它们每个元素的 id 并不是连续的，而是分别跟 `n` 中的相同。这些元素地址不连续，那么 `m` 还是数组吗？"
+
+    假如把列表元素换成链表节点 `n = [n1, n2, n3, n4, n5]` ，通常情况下这五个节点对象也是被分散存储在内存各处的。然而，给定一个列表索引，我们仍然可以在 $O(1)$ 时间内获取到节点内存地址，从而访问到对应的节点。这是因为数组中存储的是节点的引用，而非节点本身。
+
+    与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无须连续的。
+
+!!! question "C++ STL 里面的 std::list 已经实现了双向链表，但好像一些算法的书上都不怎么直接用这个，是不是有什么局限性呢?"
+
+    一方面，我们往往更青睐使用数组实现算法，而只有在必要时才使用链表，主要有两个原因。
+    
+    - 空间开销：由于每个元素需要两个额外的指针（一个用于前一个元素，一个用于后一个元素），所以 `std::list` 通常比 `std::vector` 更占用空间。
+    - 缓存不友好：由于数据不是连续存放的，`std::list` 对缓存的利用率较低。一般情况下，`std::vector` 的性能会更好。
+
+    另一方面，必要使用链表的情况主要是二叉树和图。栈和队列往往会使用编程语言提供的 `stack` 和 `queue` ，而非链表。

docs/chapter_backtracking/index.md

@@ -0,0 +1,26 @@
+---
+comments: true
+icon: material/map-marker-path
+---
+
+# 第 13 章   回溯
+
+<div class="center-table" markdown>
+
+![回溯](../assets/covers/chapter_backtracking.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    我们如同迷宫中的探索者，在前进的道路上可能会遇到困难。
+    
+    回溯的力量让我们能够重新开始，不断尝试，最终找到通往光明的出口。
+
+## 本章内容
+
+- [13.1 &nbsp; 回溯算法](https://www.hello-algo.com/chapter_backtracking/backtracking_algorithm/)
+- [13.2 &nbsp; 全排列问题](https://www.hello-algo.com/chapter_backtracking/permutations_problem/)
+- [13.3 &nbsp; 子集和问题](https://www.hello-algo.com/chapter_backtracking/subset_sum_problem/)
+- [13.4 &nbsp; N 皇后问题](https://www.hello-algo.com/chapter_backtracking/n_queens_problem/)
+- [13.5 &nbsp; 小结](https://www.hello-algo.com/chapter_backtracking/summary/)

docs/chapter_backtracking/n_queens_problem.md

@@ -0,0 +1,619 @@
+---
+comments: true
+---
+
+# 13.4   N 皇后问题
+
+!!! question
+
+    根据国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给定 $n$ 个皇后和一个 $n \times n$ 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。
+
+如图 13-15 所示，当 $n = 4$ 时，共可以找到两个解。从回溯算法的角度看，$n \times n$ 大小的棋盘共有 $n^2$ 个格子，给出了所有的选择 `choices` 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 `state` 。
+
+![4 皇后问题的解](n_queens_problem.assets/solution_4_queens.png)
+
+<p align="center"> 图 13-15 &nbsp; 4 皇后问题的解 </p>
+
+图 13-16 展示了本题的三个约束条件：**多个皇后不能在同一行、同一列、同一对角线**。值得注意的是，对角线分为主对角线 `\` 和次对角线 `/` 两种。
+
+![n 皇后问题的约束条件](n_queens_problem.assets/n_queens_constraints.png)
+
+<p align="center"> 图 13-16 &nbsp; n 皇后问题的约束条件 </p>
+
+### 1. &nbsp; 逐行放置策略
+
+皇后的数量和棋盘的行数都为 $n$ ，因此我们容易得到一个推论：**棋盘每行都允许且只允许放置一个皇后**。
+
+也就是说，我们可以采取逐行放置策略：从第一行开始，在每行放置一个皇后，直至最后一行结束。
+
+如图 13-17 所示，为 $4$ 皇后问题的逐行放置过程。受画幅限制，图 13-17 仅展开了第一行的其中一个搜索分支，并且将不满足列约束和对角线约束的方案都进行了剪枝。
+
+![逐行放置策略](n_queens_problem.assets/n_queens_placing.png)
+
+<p align="center"> 图 13-17 &nbsp; 逐行放置策略 </p>
+
+本质上看，**逐行放置策略起到了剪枝的作用**，它避免了同一行出现多个皇后的所有搜索分支。
+
+### 2. &nbsp; 列与对角线剪枝
+
+为了满足列约束，我们可以利用一个长度为 $n$ 的布尔型数组 `cols` 记录每一列是否有皇后。在每次决定放置前，我们通过 `cols` 将已有皇后的列进行剪枝，并在回溯中动态更新 `cols` 的状态。
+
+那么，如何处理对角线约束呢？设棋盘中某个格子的行列索引为 $(row, col)$ ，选定矩阵中的某条主对角线，我们发现该对角线上所有格子的行索引减列索引都相等，**即对角线上所有格子的 $row - col$ 为恒定值**。
+
+也就是说，如果两个格子满足 $row_1 - col_1 = row_2 - col_2$ ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助图 13-18 所示的数组 `diag1` ，记录每条主对角线上是否有皇后。
+
+同理，**次对角线上的所有格子的 $row + col$ 是恒定值**。我们同样也可以借助数组 `diag2` 来处理次对角线约束。
+
+![处理列约束和对角线约束](n_queens_problem.assets/n_queens_cols_diagonals.png)
+
+<p align="center"> 图 13-18 &nbsp; 处理列约束和对角线约束 </p>
+
+### 3. &nbsp; 代码实现
+
+请注意，$n$ 维方阵中 $row - col$ 的范围是 $[-n + 1, n - 1]$ ，$row + col$ 的范围是 $[0, 2n - 2]$ ，所以主对角线和次对角线的数量都为 $2n - 1$ ，即数组 `diag1` 和 `diag2` 的长度都为 $2n - 1$ 。
+
+=== "Python"
+
+    ```python title="n_queens.py"
+    def backtrack(
+        row: int,
+        n: int,
+        state: list[list[str]],
+        res: list[list[list[str]]],
+        cols: list[bool],
+        diags1: list[bool],
+        diags2: list[bool],
+    ):
+        """回溯算法：N 皇后"""
+        # 当放置完所有行时，记录解
+        if row == n:
+            res.append([list(row) for row in state])
+            return
+        # 遍历所有列
+        for col in range(n):
+            # 计算该格子对应的主对角线和副对角线
+            diag1 = row - col + n - 1
+            diag2 = row + col
+            # 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if not cols[col] and not diags1[diag1] and not diags2[diag2]:
+                # 尝试：将皇后放置在该格子
+                state[row][col] = "Q"
+                cols[col] = diags1[diag1] = diags2[diag2] = True
+                # 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2)
+                # 回退：将该格子恢复为空位
+                state[row][col] = "#"
+                cols[col] = diags1[diag1] = diags2[diag2] = False
+
+    def n_queens(n: int) -> list[list[list[str]]]:
+        """求解 N 皇后"""
+        # 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        state = [["#" for _ in range(n)] for _ in range(n)]
+        cols = [False] * n  # 记录列是否有皇后
+        diags1 = [False] * (2 * n - 1)  # 记录主对角线是否有皇后
+        diags2 = [False] * (2 * n - 1)  # 记录副对角线是否有皇后
+        res = []
+        backtrack(0, n, state, res, cols, diags1, diags2)
+
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="n_queens.cpp"
+    /* 回溯算法：N 皇后 */
+    void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
+                   vector<bool> &diags1, vector<bool> &diags2) {
+        // 当放置完所有行时，记录解
+        if (row == n) {
+            res.push_back(state);
+            return;
+        }
+        // 遍历所有列
+        for (int col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            int diag1 = row - col + n - 1;
+            int diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = "Q";
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state[row][col] = "#";
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
+
+    /* 求解 N 皇后 */
+    vector<vector<vector<string>>> nQueens(int n) {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        vector<vector<string>> state(n, vector<string>(n, "#"));
+        vector<bool> cols(n, false);           // 记录列是否有皇后
+        vector<bool> diags1(2 * n - 1, false); // 记录主对角线是否有皇后
+        vector<bool> diags2(2 * n - 1, false); // 记录副对角线是否有皇后
+        vector<vector<vector<string>>> res;
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="n_queens.java"
+    /* 回溯算法：N 皇后 */
+    void backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,
+            boolean[] cols, boolean[] diags1, boolean[] diags2) {
+        // 当放置完所有行时，记录解
+        if (row == n) {
+            List<List<String>> copyState = new ArrayList<>();
+            for (List<String> sRow : state) {
+                copyState.add(new ArrayList<>(sRow));
+            }
+            res.add(copyState);
+            return;
+        }
+        // 遍历所有列
+        for (int col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            int diag1 = row - col + n - 1;
+            int diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state.get(row).set(col, "Q");
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state.get(row).set(col, "#");
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
+
+    /* 求解 N 皇后 */
+    List<List<List<String>>> nQueens(int n) {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        List<List<String>> state = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            List<String> row = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                row.add("#");
+            }
+            state.add(row);
+        }
+        boolean[] cols = new boolean[n]; // 记录列是否有皇后
+        boolean[] diags1 = new boolean[2 * n - 1]; // 记录主对角线是否有皇后
+        boolean[] diags2 = new boolean[2 * n - 1]; // 记录副对角线是否有皇后
+        List<List<List<String>>> res = new ArrayList<>();
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="n_queens.cs"
+    /* 回溯算法：N 皇后 */
+    void Backtrack(int row, int n, List<List<string>> state, List<List<List<string>>> res,
+            bool[] cols, bool[] diags1, bool[] diags2) {
+        // 当放置完所有行时，记录解
+        if (row == n) {
+            List<List<string>> copyState = new();
+            foreach (List<string> sRow in state) {
+                copyState.Add(new List<string>(sRow));
+            }
+            res.Add(copyState);
+            return;
+        }
+        // 遍历所有列
+        for (int col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            int diag1 = row - col + n - 1;
+            int diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = "Q";
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                Backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state[row][col] = "#";
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
+
+    /* 求解 N 皇后 */
+    List<List<List<string>>> NQueens(int n) {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        List<List<string>> state = new();
+        for (int i = 0; i < n; i++) {
+            List<string> row = new();
+            for (int j = 0; j < n; j++) {
+                row.Add("#");
+            }
+            state.Add(row);
+        }
+        bool[] cols = new bool[n]; // 记录列是否有皇后
+        bool[] diags1 = new bool[2 * n - 1]; // 记录主对角线是否有皇后
+        bool[] diags2 = new bool[2 * n - 1]; // 记录副对角线是否有皇后
+        List<List<List<string>>> res = new();
+
+        Backtrack(0, n, state, res, cols, diags1, diags2);
+
+        return res;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="n_queens.go"
+    /* 回溯算法：N 皇后 */
+    func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
+        // 当放置完所有行时，记录解
+        if row == n {
+            newState := make([][]string, len(*state))
+            for i, _ := range newState {
+                newState[i] = make([]string, len((*state)[0]))
+                copy(newState[i], (*state)[i])
+
+            }
+            *res = append(*res, newState)
+        }
+        // 遍历所有列
+        for col := 0; col < n; col++ {
+            // 计算该格子对应的主对角线和副对角线
+            diag1 := row - col + n - 1
+            diag2 := row + col
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {
+                // 尝试：将皇后放置在该格子
+                (*state)[row][col] = "Q"
+                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true
+                // 放置下一行
+                backtrack(row+1, n, state, res, cols, diags1, diags2)
+                // 回退：将该格子恢复为空位
+                (*state)[row][col] = "#"
+                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false
+            }
+        }
+    }
+
+    /* 回溯算法：N 皇后 */
+    func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
+        // 当放置完所有行时，记录解
+        if row == n {
+            newState := make([][]string, len(*state))
+            for i, _ := range newState {
+                newState[i] = make([]string, len((*state)[0]))
+                copy(newState[i], (*state)[i])
+
+            }
+            *res = append(*res, newState)
+        }
+        // 遍历所有列
+        for col := 0; col < n; col++ {
+            // 计算该格子对应的主对角线和副对角线
+            diag1 := row - col + n - 1
+            diag2 := row + col
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {
+                // 尝试：将皇后放置在该格子
+                (*state)[row][col] = "Q"
+                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true
+                // 放置下一行
+                backtrack(row+1, n, state, res, cols, diags1, diags2)
+                // 回退：将该格子恢复为空位
+                (*state)[row][col] = "#"
+                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false
+            }
+        }
+    }
+
+    func nQueens(n int) [][][]string {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        state := make([][]string, n)
+        for i := 0; i < n; i++ {
+            row := make([]string, n)
+            for i := 0; i < n; i++ {
+                row[i] = "#"
+            }
+            state[i] = row
+        }
+        // 记录列是否有皇后
+        cols := make([]bool, n)
+        diags1 := make([]bool, 2*n-1)
+        diags2 := make([]bool, 2*n-1)
+        res := make([][][]string, 0)
+        backtrack(0, n, &state, &res, &cols, &diags1, &diags2)
+        return res
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="n_queens.swift"
+    /* 回溯算法：N 皇后 */
+    func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {
+        // 当放置完所有行时，记录解
+        if row == n {
+            res.append(state)
+            return
+        }
+        // 遍历所有列
+        for col in 0 ..< n {
+            // 计算该格子对应的主对角线和副对角线
+            let diag1 = row - col + n - 1
+            let diag2 = row + col
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if !cols[col] && !diags1[diag1] && !diags2[diag2] {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = "Q"
+                cols[col] = true
+                diags1[diag1] = true
+                diags2[diag2] = true
+                // 放置下一行
+                backtrack(row: row + 1, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+                // 回退：将该格子恢复为空位
+                state[row][col] = "#"
+                cols[col] = false
+                diags1[diag1] = false
+                diags2[diag2] = false
+            }
+        }
+    }
+
+    /* 求解 N 皇后 */
+    func nQueens(n: Int) -> [[[String]]] {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        var state = Array(repeating: Array(repeating: "#", count: n), count: n)
+        var cols = Array(repeating: false, count: n) // 记录列是否有皇后
+        var diags1 = Array(repeating: false, count: 2 * n - 1) // 记录主对角线是否有皇后
+        var diags2 = Array(repeating: false, count: 2 * n - 1) // 记录副对角线是否有皇后
+        var res: [[[String]]] = []
+
+        backtrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+
+        return res
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="n_queens.js"
+    /* 回溯算法：N 皇后 */
+    function backtrack(row, n, state, res, cols, diags1, diags2) {
+        // 当放置完所有行时，记录解
+        if (row === n) {
+            res.push(state.map((row) => row.slice()));
+            return;
+        }
+        // 遍历所有列
+        for (let col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            const diag1 = row - col + n - 1;
+            const diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = 'Q';
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state[row][col] = '#';
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
+
+    /* 求解 N 皇后 */
+    function nQueens(n) {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        const state = Array.from({ length: n }, () => Array(n).fill('#'));
+        const cols = Array(n).fill(false); // 记录列是否有皇后
+        const diags1 = Array(2 * n - 1).fill(false); // 记录主对角线是否有皇后
+        const diags2 = Array(2 * n - 1).fill(false); // 记录副对角线是否有皇后
+        const res = [];
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="n_queens.ts"
+    /* 回溯算法：N 皇后 */
+    function backtrack(
+        row: number,
+        n: number,
+        state: string[][],
+        res: string[][][],
+        cols: boolean[],
+        diags1: boolean[],
+        diags2: boolean[]
+    ): void {
+        // 当放置完所有行时，记录解
+        if (row === n) {
+            res.push(state.map((row) => row.slice()));
+            return;
+        }
+        // 遍历所有列
+        for (let col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            const diag1 = row - col + n - 1;
+            const diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = 'Q';
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state[row][col] = '#';
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
+
+    /* 求解 N 皇后 */
+    function nQueens(n: number): string[][][] {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        const state = Array.from({ length: n }, () => Array(n).fill('#'));
+        const cols = Array(n).fill(false); // 记录列是否有皇后
+        const diags1 = Array(2 * n - 1).fill(false); // 记录主对角线是否有皇后
+        const diags2 = Array(2 * n - 1).fill(false); // 记录副对角线是否有皇后
+        const res: string[][][] = [];
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="n_queens.dart"
+    /* 回溯算法：N 皇后 */
+    void backtrack(
+      int row,
+      int n,
+      List<List<String>> state,
+      List<List<List<String>>> res,
+      List<bool> cols,
+      List<bool> diags1,
+      List<bool> diags2,
+    ) {
+      // 当放置完所有行时，记录解
+      if (row == n) {
+        List<List<String>> copyState = [];
+        for (List<String> sRow in state) {
+          copyState.add(List.from(sRow));
+        }
+        res.add(copyState);
+        return;
+      }
+      // 遍历所有列
+      for (int col = 0; col < n; col++) {
+        // 计算该格子对应的主对角线和副对角线
+        int diag1 = row - col + n - 1;
+        int diag2 = row + col;
+        // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+        if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+          // 尝试：将皇后放置在该格子
+          state[row][col] = "Q";
+          cols[col] = true;
+          diags1[diag1] = true;
+          diags2[diag2] = true;
+          // 放置下一行
+          backtrack(row + 1, n, state, res, cols, diags1, diags2);
+          // 回退：将该格子恢复为空位
+          state[row][col] = "#";
+          cols[col] = false;
+          diags1[diag1] = false;
+          diags2[diag2] = false;
+        }
+      }
+    }
+
+    /* 求解 N 皇后 */
+    List<List<List<String>>> nQueens(int n) {
+      // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+      List<List<String>> state = List.generate(n, (index) => List.filled(n, "#"));
+      List<bool> cols = List.filled(n, false); // 记录列是否有皇后
+      List<bool> diags1 = List.filled(2 * n - 1, false); // 记录主对角线是否有皇后
+      List<bool> diags2 = List.filled(2 * n - 1, false); // 记录副对角线是否有皇后
+      List<List<List<String>>> res = [];
+
+      backtrack(0, n, state, res, cols, diags1, diags2);
+
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="n_queens.rs"
+    /* 回溯算法：N 皇后 */
+    fn backtrack(row: usize, n: usize, state: &mut Vec<Vec<String>>, res: &mut Vec<Vec<Vec<String>>>,
+        cols: &mut [bool], diags1: &mut [bool], diags2: &mut [bool]) {
+        // 当放置完所有行时，记录解
+        if row == n {
+            let mut copy_state: Vec<Vec<String>> = Vec::new();
+            for s_row in state.clone() {
+                copy_state.push(s_row);
+            }
+            res.push(copy_state);
+            return;
+        }
+        // 遍历所有列
+        for col in 0..n {
+            // 计算该格子对应的主对角线和副对角线
+            let diag1 = row + n - 1 - col;
+            let diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if !cols[col] && !diags1[diag1] && !diags2[diag2] {
+                // 尝试：将皇后放置在该格子
+                state.get_mut(row).unwrap()[col] = "Q".into();
+                (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state.get_mut(row).unwrap()[col] = "#".into();
+                (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);
+            }
+        }
+    }
+
+    /* 求解 N 皇后 */
+    fn n_queens(n: usize) -> Vec<Vec<Vec<String>>> {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        let mut state: Vec<Vec<String>> = Vec::new();
+        for _ in 0..n {
+            let mut row: Vec<String> = Vec::new();
+            for _ in 0..n {
+                row.push("#".into());
+            }
+            state.push(row);
+        }
+        let mut cols = vec![false; n]; // 记录列是否有皇后
+        let mut diags1 = vec![false; 2 * n - 1]; // 记录主对角线是否有皇后
+        let mut diags2 = vec![false; 2 * n - 1]; // 记录副对角线是否有皇后
+        let mut res: Vec<Vec<Vec<String>>> = Vec::new();
+
+        backtrack(0, n, &mut state, &mut res, &mut cols, &mut diags1, &mut diags2);
+
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="n_queens.c"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+=== "Zig"
+
+    ```zig title="n_queens.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+逐行放置 $n$ 次，考虑列约束，则从第一行到最后一行分别有 $n$、$n-1$、$\dots$、$2$、$1$ 个选择，**因此时间复杂度为 $O(n!)$** 。实际上，根据对角线约束的剪枝也能够大幅地缩小搜索空间，因而搜索效率往往优于以上时间复杂度。
+
+数组 `state` 使用 $O(n^2)$ 空间，数组 `cols`、`diags1` 和 `diags2` 皆使用 $O(n)$ 空间。最大递归深度为 $n$ ，使用 $O(n)$ 栈帧空间。因此，**空间复杂度为 $O(n^2)$** 。

docs/chapter_backtracking/permutations_problem.md

@@ -0,0 +1,919 @@
+---
+comments: true
+---
+
+# 13.2   全排列问题
+
+全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合（如一个数组或字符串）的情况下，找出这个集合中元素的所有可能的排列。
+
+表 13-2 列举了几个示例数据，包括输入数组和对应的所有排列。
+
+<p align="center"> 表 13-2 &nbsp; 数组与链表的效率对比 </p>
+
+<div class="center-table" markdown>
+
+| 输入数组    | 所有排列                                                           |
+| :---------- | :----------------------------------------------------------------- |
+| $[1]$       | $[1]$                                                              |
+| $[1, 2]$    | $[1, 2], [2, 1]$                                                   |
+| $[1, 2, 3]$ | $[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]$ |
+
+</div>
+
+## 13.2.1 &nbsp; 无相等元素的情况
+
+!!! question
+
+    输入一个整数数组，数组中不包含重复元素，返回所有可能的排列。
+
+从回溯算法的角度看，**我们可以把生成排列的过程想象成一系列选择的结果**。假设输入数组为 $[1, 2, 3]$ ，如果我们先选择 $1$、再选择 $3$、最后选择 $2$ ，则获得排列 $[1, 3, 2]$ 。回退表示撤销一个选择，之后继续尝试其他选择。
+
+从回溯代码的角度看，候选集合 `choices` 是输入数组中的所有元素，状态 `state` 是直至目前已被选择的元素。请注意，每个元素只允许被选择一次，**因此 `state` 中的所有元素都应该是唯一的**。
+
+如图 13-5 所示，我们可以将搜索过程展开成一个递归树，树中的每个节点代表当前状态 `state` 。从根节点开始，经过三轮选择后到达叶节点，每个叶节点都对应一个排列。
+
+![全排列的递归树](permutations_problem.assets/permutations_i.png)
+
+<p align="center"> 图 13-5 &nbsp; 全排列的递归树 </p>
+
+### 1. &nbsp; 重复选择剪枝
+
+为了实现每个元素只被选择一次，我们考虑引入一个布尔型数组 `selected` ，其中 `selected[i]` 表示 `choices[i]` 是否已被选择，并基于它实现以下剪枝操作。
+
+- 在做出选择 `choice[i]` 后，我们就将 `selected[i]` 赋值为 $\text{True}$ ，代表它已被选择。
+- 遍历选择列表 `choices` 时，跳过所有已被选择过的节点，即剪枝。
+
+如图 13-6 所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1 和元素 3 的分支。
+
+![全排列剪枝示例](permutations_problem.assets/permutations_i_pruning.png)
+
+<p align="center"> 图 13-6 &nbsp; 全排列剪枝示例 </p>
+
+观察图 13-6 发现，该剪枝操作将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$ 。
+
+### 2. &nbsp; 代码实现
+
+想清楚以上信息之后，我们就可以在框架代码中做“完形填空”了。为了缩短代码行数，我们不单独实现框架代码中的各个函数，而是将他们展开在 `backtrack()` 函数中。
+
+=== "Python"
+
+    ```python title="permutations_i.py"
+    def backtrack(
+        state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
+    ):
+        """回溯算法：全排列 I"""
+        # 当状态长度等于元素数量时，记录解
+        if len(state) == len(choices):
+            res.append(list(state))
+            return
+        # 遍历所有选择
+        for i, choice in enumerate(choices):
+            # 剪枝：不允许重复选择元素
+            if not selected[i]:
+                # 尝试：做出选择，更新状态
+                selected[i] = True
+                state.append(choice)
+                # 进行下一轮选择
+                backtrack(state, choices, selected, res)
+                # 回退：撤销选择，恢复到之前的状态
+                selected[i] = False
+                state.pop()
+
+    def permutations_i(nums: list[int]) -> list[list[int]]:
+        """全排列 I"""
+        res = []
+        backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="permutations_i.cpp"
+    /* 回溯算法：全排列 I */
+    void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.size() == choices.size()) {
+            res.push_back(state);
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices.size(); i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.push_back(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop_back();
+            }
+        }
+    }
+
+    /* 全排列 I */
+    vector<vector<int>> permutationsI(vector<int> nums) {
+        vector<int> state;
+        vector<bool> selected(nums.size(), false);
+        vector<vector<int>> res;
+        backtrack(state, nums, selected, res);
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="permutations_i.java"
+    /* 回溯算法：全排列 I */
+    void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.size() == choices.length) {
+            res.add(new ArrayList<Integer>(state));
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices.length; i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.add(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.remove(state.size() - 1);
+            }
+        }
+    }
+
+    /* 全排列 I */
+    List<List<Integer>> permutationsI(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="permutations_i.cs"
+    /* 回溯算法：全排列 I */
+    void Backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.Count == choices.Length) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices.Length; i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.Add(choice);
+                // 进行下一轮选择
+                Backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.RemoveAt(state.Count - 1);
+            }
+        }
+    }
+
+    /* 全排列 I */
+    List<List<int>> PermutationsI(int[] nums) {
+        List<List<int>> res = new();
+        Backtrack(new List<int>(), nums, new bool[nums.Length], res);
+        return res;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="permutations_i.go"
+    /* 回溯算法：全排列 I */
+    func backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {
+        // 当状态长度等于元素数量时，记录解
+        if len(*state) == len(*choices) {
+            newState := append([]int{}, *state...)
+            *res = append(*res, newState)
+        }
+        // 遍历所有选择
+        for i := 0; i < len(*choices); i++ {
+            choice := (*choices)[i]
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !(*selected)[i] {
+                // 尝试：做出选择，更新状态
+                (*selected)[i] = true
+                *state = append(*state, choice)
+                // 进行下一轮选择
+                backtrackI(state, choices, selected, res)
+                // 回退：撤销选择，恢复到之前的状态
+                (*selected)[i] = false
+                *state = (*state)[:len(*state)-1]
+            }
+        }
+    }
+
+    /* 全排列 I */
+    func permutationsI(nums []int) [][]int {
+        res := make([][]int, 0)
+        state := make([]int, 0)
+        selected := make([]bool, len(nums))
+        backtrackI(&state, &nums, &selected, &res)
+        return res
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="permutations_i.swift"
+    /* 回溯算法：全排列 I */
+    func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+        // 当状态长度等于元素数量时，记录解
+        if state.count == choices.count {
+            res.append(state)
+            return
+        }
+        // 遍历所有选择
+        for (i, choice) in choices.enumerated() {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !selected[i] {
+                // 尝试：做出选择，更新状态
+                selected[i] = true
+                state.append(choice)
+                // 进行下一轮选择
+                backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false
+                state.removeLast()
+            }
+        }
+    }
+
+    /* 全排列 I */
+    func permutationsI(nums: [Int]) -> [[Int]] {
+        var state: [Int] = []
+        var selected = Array(repeating: false, count: nums.count)
+        var res: [[Int]] = []
+        backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+        return res
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="permutations_i.js"
+    /* 回溯算法：全排列 I */
+    function backtrack(state, choices, selected, res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.length === choices.length) {
+            res.push([...state]);
+            return;
+        }
+        // 遍历所有选择
+        choices.forEach((choice, i) => {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop();
+            }
+        });
+    }
+
+    /* 全排列 I */
+    function permutationsI(nums) {
+        const res = [];
+        backtrack([], nums, Array(nums.length).fill(false), res);
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="permutations_i.ts"
+    /* 回溯算法：全排列 I */
+    function backtrack(
+        state: number[],
+        choices: number[],
+        selected: boolean[],
+        res: number[][]
+    ): void {
+        // 当状态长度等于元素数量时，记录解
+        if (state.length === choices.length) {
+            res.push([...state]);
+            return;
+        }
+        // 遍历所有选择
+        choices.forEach((choice, i) => {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop();
+            }
+        });
+    }
+
+    /* 全排列 I */
+    function permutationsI(nums: number[]): number[][] {
+        const res: number[][] = [];
+        backtrack([], nums, Array(nums.length).fill(false), res);
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="permutations_i.dart"
+    /* 回溯算法：全排列 I */
+    void backtrack(
+      List<int> state,
+      List<int> choices,
+      List<bool> selected,
+      List<List<int>> res,
+    ) {
+      // 当状态长度等于元素数量时，记录解
+      if (state.length == choices.length) {
+        res.add(List.from(state));
+        return;
+      }
+      // 遍历所有选择
+      for (int i = 0; i < choices.length; i++) {
+        int choice = choices[i];
+        // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+        if (!selected[i]) {
+          // 尝试：做出选择，更新状态
+          selected[i] = true;
+          state.add(choice);
+          // 进行下一轮选择
+          backtrack(state, choices, selected, res);
+          // 回退：撤销选择，恢复到之前的状态
+          selected[i] = false;
+          state.removeLast();
+        }
+      }
+    }
+
+    /* 全排列 I */
+    List<List<int>> permutationsI(List<int> nums) {
+      List<List<int>> res = [];
+      backtrack([], nums, List.filled(nums.length, false), res);
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="permutations_i.rs"
+    /* 回溯算法：全排列 I */
+    fn backtrack(mut state: Vec<i32>, choices: &[i32], selected: &mut [bool], res: &mut Vec<Vec<i32>>) {
+        // 当状态长度等于元素数量时，记录解
+        if state.len() == choices.len() {
+            res.push(state);
+            return;
+        }
+        // 遍历所有选择
+        for i in 0..choices.len() {
+            let choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !selected[i] {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state.clone(), choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.remove(state.len() - 1);
+            }
+        }
+    }
+
+    /* 全排列 I */
+    fn permutations_i(nums: &mut [i32]) -> Vec<Vec<i32>> {
+        let mut res = Vec::new(); // 状态（子集）
+        backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="permutations_i.c"
+    /* 回溯算法：全排列 I */
+    void backtrack(vector *state, vector *choices, vector *selected, vector *res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state->size == choices->size) {
+            vector *newState = newVector();
+            for (int i = 0; i < state->size; i++) {
+                vectorPushback(newState, state->data[i], sizeof(int));
+            }
+            vectorPushback(res, newState, sizeof(vector));
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices->size; i++) {
+            int *choice = malloc(sizeof(int));
+            *choice = *((int *)(choices->data[i]));
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            bool select = *((bool *)(selected->data[i]));
+            if (!select) {
+                // 尝试：做出选择，更新状态
+                *((bool *)selected->data[i]) = true;
+                vectorPushback(state, choice, sizeof(int));
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                *((bool *)selected->data[i]) = false;
+                vectorPopback(state);
+            }
+        }
+    }
+
+    /* 全排列 I */
+    vector *permutationsI(vector *nums) {
+        vector *iState = newVector();
+
+        int select[3] = {false, false, false};
+        vector *bSelected = newVector();
+        for (int i = 0; i < nums->size; i++) {
+            vectorPushback(bSelected, &select[i], sizeof(int));
+        }
+
+        vector *res = newVector();
+
+        // 前序遍历
+        backtrack(iState, nums, bSelected, res);
+        return res;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="permutations_i.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+## 13.2.2 &nbsp; 考虑相等元素的情况
+
+!!! question
+
+    输入一个整数数组，**数组中可能包含重复元素**，返回所有不重复的排列。
+
+假设输入数组为 $[1, 1, 2]$ 。为了方便区分两个重复元素 $1$ ，我们将第二个 $1$ 记为 $\hat{1}$ 。
+
+如图 13-7 所示，上述方法生成的排列有一半都是重复的。
+
+![重复排列](permutations_problem.assets/permutations_ii.png)
+
+<p align="center"> 图 13-7 &nbsp; 重复排列 </p>
+
+那么如何去除重复的排列呢？最直接地，考虑借助一个哈希表，直接对排列结果进行去重。然而这样做不够优雅，**因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝**，这样可以进一步提升算法效率。
+
+### 1. &nbsp; 相等元素剪枝
+
+观察图 13-8 ，在第一轮中，选择 $1$ 或选择 $\hat{1}$ 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 $\hat{1}$ 剪枝掉。
+
+同理，在第一轮选择 $2$ 之后，第二轮选择中的 $1$ 和 $\hat{1}$ 也会产生重复分支，因此也应将第二轮的 $\hat{1}$ 剪枝。
+
+本质上看，**我们的目标是在某一轮选择中，保证多个相等的元素仅被选择一次**。
+
+![重复排列剪枝](permutations_problem.assets/permutations_ii_pruning.png)
+
+<p align="center"> 图 13-8 &nbsp; 重复排列剪枝 </p>
+
+### 2. &nbsp; 代码实现
+
+在上一题的代码的基础上，我们考虑在每一轮选择中开启一个哈希表 `duplicated` ，用于记录该轮中已经尝试过的元素，并将重复元素剪枝。
+
+=== "Python"
+
+    ```python title="permutations_ii.py"
+    def backtrack(
+        state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
+    ):
+        """回溯算法：全排列 II"""
+        # 当状态长度等于元素数量时，记录解
+        if len(state) == len(choices):
+            res.append(list(state))
+            return
+        # 遍历所有选择
+        duplicated = set[int]()
+        for i, choice in enumerate(choices):
+            # 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if not selected[i] and choice not in duplicated:
+                # 尝试：做出选择，更新状态
+                duplicated.add(choice)  # 记录选择过的元素值
+                selected[i] = True
+                state.append(choice)
+                # 进行下一轮选择
+                backtrack(state, choices, selected, res)
+                # 回退：撤销选择，恢复到之前的状态
+                selected[i] = False
+                state.pop()
+
+    def permutations_ii(nums: list[int]) -> list[list[int]]:
+        """全排列 II"""
+        res = []
+        backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="permutations_ii.cpp"
+    /* 回溯算法：全排列 II */
+    void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.size() == choices.size()) {
+            res.push_back(state);
+            return;
+        }
+        // 遍历所有选择
+        unordered_set<int> duplicated;
+        for (int i = 0; i < choices.size(); i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && duplicated.find(choice) == duplicated.end()) {
+                // 尝试：做出选择，更新状态
+                duplicated.emplace(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.push_back(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop_back();
+            }
+        }
+    }
+
+    /* 全排列 II */
+    vector<vector<int>> permutationsII(vector<int> nums) {
+        vector<int> state;
+        vector<bool> selected(nums.size(), false);
+        vector<vector<int>> res;
+        backtrack(state, nums, selected, res);
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="permutations_ii.java"
+    /* 回溯算法：全排列 II */
+    void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.size() == choices.length) {
+            res.add(new ArrayList<Integer>(state));
+            return;
+        }
+        // 遍历所有选择
+        Set<Integer> duplicated = new HashSet<Integer>();
+        for (int i = 0; i < choices.length; i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && !duplicated.contains(choice)) {
+                // 尝试：做出选择，更新状态
+                duplicated.add(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.add(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.remove(state.size() - 1);
+            }
+        }
+    }
+
+    /* 全排列 II */
+    List<List<Integer>> permutationsII(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="permutations_ii.cs"
+    /* 回溯算法：全排列 II */
+    void Backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.Count == choices.Length) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // 遍历所有选择
+        ISet<int> duplicated = new HashSet<int>();
+        for (int i = 0; i < choices.Length; i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && !duplicated.Contains(choice)) {
+                // 尝试：做出选择，更新状态
+                duplicated.Add(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.Add(choice);
+                // 进行下一轮选择
+                Backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.RemoveAt(state.Count - 1);
+            }
+        }
+    }
+
+    /* 全排列 II */
+    List<List<int>> PermutationsII(int[] nums) {
+        List<List<int>> res = new();
+        Backtrack(new List<int>(), nums, new bool[nums.Length], res);
+        return res;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="permutations_ii.go"
+    /* 回溯算法：全排列 II */
+    func backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {
+        // 当状态长度等于元素数量时，记录解
+        if len(*state) == len(*choices) {
+            newState := append([]int{}, *state...)
+            *res = append(*res, newState)
+        }
+        // 遍历所有选择
+        duplicated := make(map[int]struct{}, 0)
+        for i := 0; i < len(*choices); i++ {
+            choice := (*choices)[i]
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if _, ok := duplicated[choice]; !ok && !(*selected)[i] {
+                // 尝试：做出选择，更新状态
+                // 记录选择过的元素值
+                duplicated[choice] = struct{}{}
+                (*selected)[i] = true
+                *state = append(*state, choice)
+                // 进行下一轮选择
+                backtrackI(state, choices, selected, res)
+                // 回退：撤销选择，恢复到之前的状态
+                (*selected)[i] = false
+                *state = (*state)[:len(*state)-1]
+            }
+        }
+    }
+
+    /* 全排列 II */
+    func permutationsII(nums []int) [][]int {
+        res := make([][]int, 0)
+        state := make([]int, 0)
+        selected := make([]bool, len(nums))
+        backtrackII(&state, &nums, &selected, &res)
+        return res
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="permutations_ii.swift"
+    /* 回溯算法：全排列 II */
+    func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+        // 当状态长度等于元素数量时，记录解
+        if state.count == choices.count {
+            res.append(state)
+            return
+        }
+        // 遍历所有选择
+        var duplicated: Set<Int> = []
+        for (i, choice) in choices.enumerated() {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !selected[i], !duplicated.contains(choice) {
+                // 尝试：做出选择，更新状态
+                duplicated.insert(choice) // 记录选择过的元素值
+                selected[i] = true
+                state.append(choice)
+                // 进行下一轮选择
+                backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false
+                state.removeLast()
+            }
+        }
+    }
+
+    /* 全排列 II */
+    func permutationsII(nums: [Int]) -> [[Int]] {
+        var state: [Int] = []
+        var selected = Array(repeating: false, count: nums.count)
+        var res: [[Int]] = []
+        backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+        return res
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="permutations_ii.js"
+    /* 回溯算法：全排列 II */
+    function backtrack(state, choices, selected, res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.length === choices.length) {
+            res.push([...state]);
+            return;
+        }
+        // 遍历所有选择
+        const duplicated = new Set();
+        choices.forEach((choice, i) => {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && !duplicated.has(choice)) {
+                // 尝试：做出选择，更新状态
+                duplicated.add(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop();
+            }
+        });
+    }
+
+    /* 全排列 II */
+    function permutationsII(nums) {
+        const res = [];
+        backtrack([], nums, Array(nums.length).fill(false), res);
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="permutations_ii.ts"
+    /* 回溯算法：全排列 II */
+    function backtrack(
+        state: number[],
+        choices: number[],
+        selected: boolean[],
+        res: number[][]
+    ): void {
+        // 当状态长度等于元素数量时，记录解
+        if (state.length === choices.length) {
+            res.push([...state]);
+            return;
+        }
+        // 遍历所有选择
+        const duplicated = new Set();
+        choices.forEach((choice, i) => {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && !duplicated.has(choice)) {
+                // 尝试：做出选择，更新状态
+                duplicated.add(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop();
+            }
+        });
+    }
+
+    /* 全排列 II */
+    function permutationsII(nums: number[]): number[][] {
+        const res: number[][] = [];
+        backtrack([], nums, Array(nums.length).fill(false), res);
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="permutations_ii.dart"
+    /* 回溯算法：全排列 II */
+    void backtrack(
+      List<int> state,
+      List<int> choices,
+      List<bool> selected,
+      List<List<int>> res,
+    ) {
+      // 当状态长度等于元素数量时，记录解
+      if (state.length == choices.length) {
+        res.add(List.from(state));
+        return;
+      }
+      // 遍历所有选择
+      Set<int> duplicated = {};
+      for (int i = 0; i < choices.length; i++) {
+        int choice = choices[i];
+        // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+        if (!selected[i] && !duplicated.contains(choice)) {
+          // 尝试：做出选择，更新状态
+          duplicated.add(choice); // 记录选择过的元素值
+          selected[i] = true;
+          state.add(choice);
+          // 进行下一轮选择
+          backtrack(state, choices, selected, res);
+          // 回退：撤销选择，恢复到之前的状态
+          selected[i] = false;
+          state.removeLast();
+        }
+      }
+    }
+
+    /* 全排列 II */
+    List<List<int>> permutationsII(List<int> nums) {
+      List<List<int>> res = [];
+      backtrack([], nums, List.filled(nums.length, false), res);
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="permutations_ii.rs"
+    /* 回溯算法：全排列 II */
+    fn backtrack(mut state: Vec<i32>, choices: &[i32], selected: &mut [bool], res: &mut Vec<Vec<i32>>) {
+        // 当状态长度等于元素数量时，记录解
+        if state.len() == choices.len() {
+            res.push(state);
+            return;
+        }
+        // 遍历所有选择
+        let mut duplicated = HashSet::<i32>::new();
+        for i in 0..choices.len() {
+            let choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !selected[i] && !duplicated.contains(&choice) {
+                // 尝试：做出选择，更新状态
+                duplicated.insert(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state.clone(), choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.remove(state.len() - 1);
+            }
+        }
+    }
+
+    /* 全排列 II */
+    fn permutations_ii(nums: &mut [i32]) -> Vec<Vec<i32>> {
+        let mut res = Vec::new();
+        backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="permutations_ii.c"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+=== "Zig"
+
+    ```zig title="permutations_ii.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+假设元素两两之间互不相同，则 $n$ 个元素共有 $n!$  种排列（阶乘）；在记录结果时，需要复制长度为 $n$ 的列表，使用 $O(n)$ 时间。**因此时间复杂度为 $O(n!n)$** 。
+
+最大递归深度为 $n$ ，使用 $O(n)$ 栈帧空间。`selected` 使用 $O(n)$ 空间。同一时刻最多共有 $n$ 个 `duplicated` ，使用 $O(n^2)$ 空间。**因此空间复杂度为 $O(n^2)$** 。
+
+### 3. &nbsp; 两种剪枝对比
+
+请注意，虽然 `selected` 和 `duplicated` 都用作剪枝，但两者的目标是不同的。
+
+- **重复选择剪枝**：整个搜索过程中只有一个 `selected` 。它记录的是当前状态中包含哪些元素，作用是避免某个元素在 `state` 中重复出现。
+- **相等元素剪枝**：每轮选择（即每个开启的 `backtrack` 函数）都包含一个 `duplicated` 。它记录的是在遍历中哪些元素已被选择过，作用是保证相等元素只被选择一次。
+
+图 13-9 展示了两个剪枝条件的生效范围。注意，树中的每个节点代表一个选择，从根节点到叶节点的路径上的各个节点构成一个排列。
+
+![两种剪枝条件的作用范围](permutations_problem.assets/permutations_ii_pruning_summary.png)
+
+<p align="center"> 图 13-9 &nbsp; 两种剪枝条件的作用范围 </p>

docs/chapter_backtracking/summary.md

@@ -0,0 +1,27 @@
+---
+comments: true
+---
+
+# 13.5   小结
+
+### 1.   重点回顾
+
+- 回溯算法本质是穷举法，通过对解空间进行深度优先遍历来寻找符合条件的解。在搜索过程中，遇到满足条件的解则记录，直至找到所有解或遍历完成后结束。
+- 回溯算法的搜索过程包括尝试与回退两个部分。它通过深度优先搜索来尝试各种选择，当遇到不满足约束条件的情况时，则撤销上一步的选择，退回到之前的状态，并继续尝试其他选择。尝试与回退是两个方向相反的操作。
+- 回溯问题通常包含多个约束条件，它们可用于实现剪枝操作。剪枝可以提前结束不必要的搜索分支，大幅提升搜索效率。
+- 回溯算法主要可用于解决搜索问题和约束满足问题。组合优化问题虽然可以用回溯算法解决，但往往存在更高效率或更好效果的解法。
+- 全排列问题旨在搜索给定集合的所有可能的排列。我们借助一个数组来记录每个元素是否被选择，剪枝掉重复选择同一元素的搜索分支，确保每个元素只被选择一次。
+- 在全排列问题中，如果集合中存在重复元素，则最终结果会出现重复排列。我们需要约束相等元素在每轮中只能被选择一次，这通常借助一个哈希表来实现。
+- 子集和问题的目标是在给定集合中找到和为目标值的所有子集。集合不区分元素顺序，而搜索过程会输出所有顺序的结果，产生重复子集。我们在回溯前将数据进行排序，并设置一个变量来指示每一轮的遍历起点，从而将生成重复子集的搜索分支进行剪枝。
+- 对于子集和问题，数组中的相等元素会产生重复集合。我们利用数组已排序的前置条件，通过判断相邻元素是否相等实现剪枝，从而确保相等元素在每轮中只能被选中一次。
+- $n$ 皇后旨在寻找将 $n$ 个皇后放置到 $n \times n$ 尺寸棋盘上的方案，要求所有皇后两两之间无法攻击对方。该问题的约束条件有行约束、列约束、主对角线和副对角线约束。为满足行约束，我们采用按行放置的策略，保证每一行放置一个皇后。
+- 列约束和对角线约束的处理方式类似。对于列约束，我们利用一个数组来记录每一列是否有皇后，从而指示选中的格子是否合法。对于对角线约束，我们借助两个数组来分别记录该主、副对角线是否存在皇后；难点在于找处在到同一主（副）对角线上格子满足的行列索引规律。
+
+### 2.   Q & A
+
+!!! question "怎么理解回溯和递归的关系？"
+
+    总的来看，回溯是一种“算法策略”，而递归更像是一个“工具”。
+
+    - 回溯算法通常基于递归实现。然而，回溯是递归的应用场景之一，是递归在搜索问题中的应用。
+    - 递归的结构体现了“子问题分解”的解题范式，常用于解决分治、回溯、动态规划（记忆化递归）等问题。

docs/chapter_computational_complexity/index.md

@@ -0,0 +1,26 @@
+---
+comments: true
+icon: material/timer-sand
+---
+
+# 第 2 章   复杂度分析
+
+<div class="center-table" markdown>
+
+![复杂度分析](../assets/covers/chapter_complexity_analysis.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    复杂度分析犹如浩瀚的算法宇宙中的时空向导。
+    
+    它带领我们在时间与空间这两个维度上深入探索，寻找更优雅的解决方案。
+
+## 本章内容
+
+- [2.1 &nbsp; 算法效率评估](https://www.hello-algo.com/chapter_computational_complexity/performance_evaluation/)
+- [2.2 &nbsp; 迭代与递归](https://www.hello-algo.com/chapter_computational_complexity/iteration_and_recursion/)
+- [2.3 &nbsp; 时间复杂度](https://www.hello-algo.com/chapter_computational_complexity/time_complexity/)
+- [2.4 &nbsp; 空间复杂度](https://www.hello-algo.com/chapter_computational_complexity/space_complexity/)
+- [2.5 &nbsp; 小结](https://www.hello-algo.com/chapter_computational_complexity/summary/)

docs/chapter_computational_complexity/performance_evaluation.md

@@ -0,0 +1,52 @@
+---
+comments: true
+---
+
+# 2.1   算法效率评估
+
+在算法设计中，我们先后追求以下两个层面的目标。
+
+1. **找到问题解法**：算法需要在规定的输入范围内，可靠地求得问题的正确解。
+2. **寻求最优解法**：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
+
+也就是说，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度。
+
+- **时间效率**：算法运行速度的快慢。
+- **空间效率**：算法占用内存空间的大小。
+
+简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有这样我们才能将各种算法进行对比，从而指导算法设计与优化过程。
+
+效率评估方法主要分为两种：实际测试、理论估算。
+
+## 2.1.1   实际测试
+
+假设我们现在有算法 `A` 和算法 `B` ，它们都能解决同一问题，现在需要对比这两个算法的效率。最直接的方法是找一台计算机，运行这两个算法，并监控记录它们的运行时间和内存占用情况。这种评估方式能够反映真实情况，但也存在较大局限性。
+
+一方面，**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
+
+另一方面，**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这需要耗费大量的计算资源。
+
+## 2.1.2   理论估算
+
+由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 asymptotic complexity analysis」，简称「复杂度分析」。
+
+复杂度分析体现算法运行所需的时间（空间）资源与输入数据大小之间的关系。**它描述了随着输入数据大小的增加，算法执行所需时间和空间的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解。
+
+- “时间和空间资源”分别对应「时间复杂度 time complexity」和「空间复杂度 space complexity」。
+- “随着输入数据大小的增加”意味着复杂度反映了算法运行效率与输入数据体量之间的关系。
+- “时间和空间的增长趋势”表示复杂度分析关注的不是运行时间或占用空间的具体值，而是时间或空间增长的“快慢”。
+
+**复杂度分析克服了实际测试方法的弊端**，体现在以下两个方面。
+
+- 它独立于测试环境，分析结果适用于所有运行平台。
+- 它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。
+
+!!! tip
+
+    如果你仍对复杂度的概念感到困惑，无须担心，我们会在后续章节中详细介绍。
+
+复杂度分析为我们提供了一把评估算法效率的“标尺”，使我们可以衡量执行某个算法所需的时间和空间资源，对比不同算法之间的效率。
+
+复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为最先介绍的内容。然而，当我们讨论某个数据结构或算法的特点时，难以避免要分析其运行速度和空间使用情况。
+
+综上所述，建议你在深入学习数据结构与算法之前，**先对复杂度分析建立初步的了解，以便能够完成简单算法的复杂度分析**。

docs/chapter_computational_complexity/summary.md

@@ -0,0 +1,53 @@
+---
+comments: true
+---
+
+# 2.5   小结
+
+### 1.   重点回顾
+
+**算法效率评估**
+
+- 时间效率和空间效率是衡量算法优劣的两个主要评价指标。
+- 我们可以通过实际测试来评估算法效率，但难以消除测试环境的影响，且会耗费大量计算资源。
+- 复杂度分析可以克服实际测试的弊端，分析结果适用于所有运行平台，并且能够揭示算法在不同数据规模下的效率。
+
+**时间复杂度**
+
+- 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入的数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。
+- 最差时间复杂度使用大 $O$ 符号表示，对应函数渐近上界，反映当 $n$ 趋向正无穷时，操作数量 $T(n)$ 的增长级别。
+- 推算时间复杂度分为两步，首先统计操作数量，然后判断渐近上界。
+- 常见时间复杂度从小到大排列有 $O(1)$、$O(\log n)$、$O(n)$、$O(n \log n)$、$O(n^2)$、$O(2^n)$ 和 $O(n!)$ 等。
+- 某些算法的时间复杂度非固定，而是与输入数据的分布有关。时间复杂度分为最差、最佳、平均时间复杂度，最佳时间复杂度几乎不用，因为输入数据一般需要满足严格条件才能达到最佳情况。
+- 平均时间复杂度反映算法在随机数据输入下的运行效率，最接近实际应用中的算法性能。计算平均时间复杂度需要统计输入数据分布以及综合后的数学期望。
+
+**空间复杂度**
+
+- 空间复杂度的作用类似于时间复杂度，用于衡量算法占用空间随数据量增长的趋势。
+- 算法运行过程中的相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下，输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间，其中栈帧空间通常仅在递归函数中影响空间复杂度。
+- 我们通常只关注最差空间复杂度，即统计算法在最差输入数据和最差运行时间点下的空间复杂度。
+- 常见空间复杂度从小到大排列有 $O(1)$、$O(\log n)$、$O(n)$、$O(n^2)$ 和 $O(2^n)$ 等。
+
+### 2.   Q & A
+
+!!! question "尾递归的空间复杂度是 $O(1)$ 吗？"
+
+    理论上，尾递归函数的空间复杂度可以被优化至 $O(1)$ 。不过绝大多数编程语言（例如 Java、Python、C++、Go、C# 等）都不支持自动优化尾递归，因此通常认为空间复杂度是 $O(n)$ 。
+
+!!! question "函数和方法这两个术语的区别是什么？"
+
+    函数（function）可以被独立执行，所有参数都以显式传递。方法（method）与一个对象关联，被隐式传递给调用它的对象，能够对类的实例中包含的数据进行操作。
+
+    下面以几个常见的编程语言来说明。
+
+    - C 语言是过程式编程语言，没有面向对象的概念，所以只有函数。但我们可以通过创建结构体（struct）来模拟面向对象编程，与结构体相关联的函数就相当于其他语言中的方法。
+    - Java 和 C# 是面向对象的编程语言，代码块（方法）通常都是作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。
+    - C++ 和 Python 既支持过程式编程（函数），也支持面向对象编程（方法）。
+
+!!! question "图“常见的空间复杂度类型”反映的是否是占用空间的绝对大小？"
+
+    不是，该图片展示的是空间复杂度，其反映的是增长趋势，而不是占用空间的绝对大小。
+    
+    假设取 $n = 8$ ，你可能会发现每条曲线的值与函数对应不上。这是因为每条曲线都包含一个常数项，用于将取值范围压缩到一个视觉舒适的范围内。
+
+    在实际中，因为我们通常不知道每个方法的“常数项”复杂度是多少，所以一般无法仅凭复杂度来选择 $n = 8$ 之下的最优解法。但对于 $n = 8^5$ 就很好选了，这时增长趋势已经占主导了。

docs/chapter_data_structure/basic_data_types.md

@@ -0,0 +1,167 @@
+---
+comments: true
+---
+
+# 3.2   基本数据类型
+
+谈及计算机中的数据，我们会想到文本、图片、视频、语音、3D 模型等各种形式。尽管这些数据的组织形式各异，但它们都由各种基本数据类型构成。
+
+**基本数据类型是 CPU 可以直接进行运算的类型**，在算法中直接被使用，主要包括以下几种类型。
+
+- 整数类型 `byte`、`short`、`int`、`long` 。
+- 浮点数类型 `float`、`double` ，用于表示小数。
+- 字符类型 `char` ，用于表示各种语言的字母、标点符号、甚至表情符号等。
+- 布尔类型 `bool` ，用于表示“是”与“否”判断。
+
+**基本数据类型以二进制的形式存储在计算机中**。一个二进制位即为 $1$ 比特。在绝大多数现代系统中，$1$ 字节（byte）由 $8$ 比特（bits）组成。
+
+基本数据类型的取值范围取决于其占用的空间大小。下面以 Java 为例。
+
+- 整数类型 `byte` 占用 $1$ byte = $8$ bits ，可以表示 $2^{8}$ 个数字。
+- 整数类型 `int` 占用 $4$ bytes = $32$ bits ，可以表示 $2^{32}$ 个数字。
+
+表 3-1 列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无须硬背，大致理解即可，需要时可以通过查表来回忆。
+
+<p align="center"> 表 3-1 &nbsp; 基本数据类型的占用空间和取值范围 </p>
+
+<div class="center-table" markdown>
+
+| 类型   | 符号     | 占用空间         | 最小值                   | 最大值                  | 默认值         |
+| ------ | -------- | ---------------- | ------------------------ | ----------------------- | -------------- |
+| 整数   | `byte`   | 1 byte           | $-2^7$ ($-128$)          | $2^7 - 1$ ($127$)       | $0$            |
+|        | `short`  | 2 bytes          | $-2^{15}$                | $2^{15} - 1$            | $0$            |
+|        | `int`    | 4 bytes          | $-2^{31}$                | $2^{31} - 1$            | $0$            |
+|        | `long`   | 8 bytes          | $-2^{63}$                | $2^{63} - 1$            | $0$            |
+| 浮点数 | `float`  | 4 bytes          | $1.175 \times 10^{-38}$  | $3.403 \times 10^{38}$  | $0.0 f$        |
+|        | `double` | 8 bytes          | $2.225 \times 10^{-308}$ | $1.798 \times 10^{308}$ | $0.0$          |
+| 字符   | `char`   | 2 bytes / 1 byte | $0$                      | $2^{16} - 1$            | $0$            |
+| 布尔   | `bool`   | 1 byte           | $\text{false}$           | $\text{true}$           | $\text{false}$ |
+
+</div>
+
+对于表 3-1 ，需要注意以下几点。
+
+- C 和 C++ 未明确规定基本数据类型大小，而因实现和平台各异。表 3-1 遵循 LP64 [数据模型](https://en.cppreference.com/w/cpp/language/types#Properties)，其用于包括 Linux 和 macOS 在内的 Unix 64 位操作系统。
+- 字符 `char` 的大小在 C 和 C++ 中为 1 字节，在大多数编程语言中取决于特定的字符编码方法，详见“字符编码”章节。
+- 即使表示布尔量仅需 1 位（$0$ 或 $1$），它在内存中通常被存储为 1 字节。这是因为现代计算机 CPU 通常将 1 字节作为最小寻址内存单元。
+
+那么，基本数据类型与数据结构之间有什么联系呢？我们知道，数据结构是在计算机中组织与存储数据的方式。它的主语是“结构”而非“数据”。
+
+如果想要表示“一排数字”，我们自然会想到使用数组。这是因为数组的线性结构可以表示数字的相邻关系和顺序关系，但至于存储的内容是整数 `int`、小数 `float` 或是字符 `char` ，则与“数据结构”无关。
+
+换句话说，**基本数据类型提供了数据的“内容类型”，而数据结构提供了数据的“组织方式”**。例如以下代码，我们用相同的数据结构（数组）来存储与表示不同的基本数据类型，包括 `int`、`float`、`char`、`bool` 等。
+
+=== "Python"
+
+    ```python title=""
+    # 使用多种基本数据类型来初始化数组
+    numbers: list[int] = [0] * 5
+    decimals: list[float] = [0.0] * 5
+    # Python 的字符应被看作长度为一的字符串
+    characters: list[str] = ['0'] * 5
+    bools: list[bool] = [False] * 5
+    # Python 的列表可以自由存储各种基本数据类型和对象引用
+    data = [0, 0.0, 'a', False, ListNode(0)]
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    // 使用多种基本数据类型来初始化数组
+    int numbers[5];
+    float decimals[5];
+    char characters[5];
+    bool bools[5];
+    ```
+
+=== "Java"
+
+    ```java title=""
+    // 使用多种基本数据类型来初始化数组
+    int[] numbers = new int[5];
+    float[] decimals = new float[5];
+    char[] characters = new char[5];
+    boolean[] bools = new boolean[5];
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    // 使用多种基本数据类型来初始化数组
+    int[] numbers = new int[5];
+    float[] decimals = new float[5];
+    char[] characters = new char[5];
+    bool[] bools = new bool[5];
+    ```
+
+=== "Go"
+
+    ```go title=""
+    // 使用多种基本数据类型来初始化数组
+    var numbers = [5]int{}
+    var decimals = [5]float64{}
+    var characters = [5]byte{}
+    var bools = [5]bool{}
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    // 使用多种基本数据类型来初始化数组
+    let numbers = Array(repeating: Int(), count: 5)
+    let decimals = Array(repeating: Double(), count: 5)
+    let characters = Array(repeating: Character("a"), count: 5)
+    let bools = Array(repeating: Bool(), count: 5)
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    // JavaScript 的数组可以自由存储各种基本数据类型和对象
+    const array = [0, 0.0, 'a', false];
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    // 使用多种基本数据类型来初始化数组
+    const numbers: number[] = [];
+    const characters: string[] = [];
+    const bools: boolean[] = [];
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    // 使用多种基本数据类型来初始化数组
+    List<int> numbers = List.filled(5, 0);
+    List<double> decimals = List.filled(5, 0.0);
+    List<String> characters = List.filled(5, 'a');
+    List<bool> bools = List.filled(5, false);
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    // 使用多种基本数据类型来初始化数组
+    let numbers: Vec<i32> = vec![0; 5];
+    let decimals: Vec<float> = vec![0.0, 5];
+    let characters: Vec<char> = vec!['0'; 5];
+    let bools: Vec<bool> = vec![false; 5];
+    ```
+
+=== "C"
+
+    ```c title=""
+    // 使用多种基本数据类型来初始化数组
+    int numbers[10];
+    float decimals[10];
+    char characters[10];
+    bool bools[10];
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+    
+    ```

docs/chapter_data_structure/character_encoding.md

@@ -0,0 +1,97 @@
+---
+comments: true
+---
+
+# 3.4   字符编码 *
+
+在计算机中，所有数据都是以二进制数的形式存储的，字符 `char` 也不例外。为了表示字符，我们需要建立一套“字符集”，规定每个字符和二进制数之间的一一对应关系。有了字符集之后，计算机就可以通过查表完成二进制数到字符的转换。
+
+## 3.4.1   ASCII 字符集
+
+「ASCII 码」是最早出现的字符集，全称为“美国标准信息交换代码”。它使用 7 位二进制数（即一个字节的低 7 位）表示一个字符，最多能够表示 128 个不同的字符。如图 3-6 所示，ASCII 码包括英文字母的大小写、数字 0 ~ 9、一些标点符号，以及一些控制字符（如换行符和制表符）。
+
+![ASCII 码](character_encoding.assets/ascii_table.png)
+
+<p align="center"> 图 3-6 &nbsp; ASCII 码 </p>
+
+然而，**ASCII 码仅能够表示英文**。随着计算机的全球化，诞生了一种能够表示更多语言的字符集「EASCII」。它在 ASCII 的 7 位基础上扩展到 8 位，能够表示 256 个不同的字符。
+
+在世界范围内，陆续出现了一批适用于不同地区的 EASCII 字符集。这些字符集的前 128 个字符统一为 ASCII 码，后 128 个字符定义不同，以适应不同语言的需求。
+
+## 3.4.2 &nbsp; GBK 字符集
+
+后来人们发现，**EASCII 码仍然无法满足许多语言的字符数量要求**。比如汉字大约有近十万个，光日常使用的就有几千个。中国国家标准总局于 1980 年发布了「GB2312」字符集，其收录了 6763 个汉字，基本满足了汉字的计算机处理需要。
+
+然而，GB2312 无法处理部分的罕见字和繁体字。「GBK」字符集是在 GB2312 的基础上扩展得到的，它共收录了 21886 个汉字。在 GBK 的编码方案中，ASCII 字符使用一个字节表示，汉字使用两个字节表示。
+
+## 3.4.3 &nbsp; Unicode 字符集
+
+随着计算机的蓬勃发展，字符集与编码标准百花齐放，而这带来了许多问题。一方面，这些字符集一般只定义了特定语言的字符，无法在多语言环境下正常工作。另一方面，同一种语言也存在多种字符集标准，如果两台电脑安装的是不同的编码标准，则在信息传递时就会出现乱码。
+
+那个时代的研究人员就在想：**如果推出一个足够完整的字符集，将世界范围内的所有语言和符号都收录其中，不就可以解决跨语言环境和乱码问题了吗**？在这种想法的驱动下，一个大而全的字符集 Unicode 应运而生。
+
+「Unicode」的全称为“统一字符编码”，理论上能容纳一百多万个字符。它致力于将全球范围内的字符纳入到统一的字符集之中，提供一种通用的字符集来处理和显示各种语言文字，减少因为编码标准不同而产生的乱码问题。
+
+自 1991 年发布以来，Unicode 不断扩充新的语言与字符。截止 2022 年 9 月，Unicode 已经包含 149186 个字符，包括各种语言的字符、符号、甚至是表情符号等。在庞大的 Unicode 字符集中，常用的字符占用 2 字节，有些生僻的字符占 3 字节甚至 4 字节。
+
+Unicode 是一种字符集标准，本质上是给每个字符分配一个编号（称为“码点”），**但它并没有规定在计算机中如何存储这些字符码点**。我们不禁会问：当多种长度的 Unicode 码点同时出现在同一个文本中时，系统如何解析字符？例如给定一个长度为 2 字节的编码，系统如何确认它是一个 2 字节的字符还是两个 1 字节的字符？
+
+对于以上问题，**一种直接的解决方案是将所有字符存储为等长的编码**。如图 3-7 所示，“Hello”中的每个字符占用 1 字节，“算法”中的每个字符占用 2 字节。我们可以通过高位填 0 ，将“Hello 算法”中的所有字符都编码为 2 字节长度。这样系统就可以每隔 2 字节解析一个字符，恢复出这个短语的内容了。
+
+![Unicode 编码示例](character_encoding.assets/unicode_hello_algo.png)
+
+<p align="center"> 图 3-7 &nbsp; Unicode 编码示例 </p>
+
+然而 ASCII 码已经向我们证明，编码英文只需要 1 字节。若采用上述方案，英文文本占用空间的大小将会是 ASCII 编码下大小的两倍，非常浪费内存空间。因此，我们需要一种更加高效的 Unicode 编码方法。
+
+## 3.4.4 &nbsp; UTF-8 编码
+
+目前，UTF-8 已成为国际上使用最广泛的 Unicode 编码方法。**它是一种可变长的编码**，使用 1 到 4 个字节来表示一个字符，根据字符的复杂性而变。ASCII 字符只需要 1 个字节，拉丁字母和希腊字母需要 2 个字节，常用的中文字符需要 3 个字节，其他的一些生僻字符需要 4 个字节。
+
+UTF-8 的编码规则并不复杂，分为以下两种情况。
+
+- 对于长度为 1 字节的字符，将最高位设置为 $0$、其余 7 位设置为 Unicode 码点。值得注意的是，ASCII 字符在 Unicode 字符集中占据了前 128 个码点。也就是说，**UTF-8 编码可以向下兼容 ASCII 码**。这意味着我们可以使用 UTF-8 来解析年代久远的 ASCII 码文本。
+- 对于长度为 $n$ 字节的字符（其中 $n > 1$），将首个字节的高 $n$ 位都设置为 $1$、第 $n + 1$ 位设置为 $0$ ；从第二个字节开始，将每个字节的高 2 位都设置为 $10$ ；其余所有位用于填充字符的 Unicode 码点。
+
+图 3-8 展示了“Hello算法”对应的 UTF-8 编码。观察发现，由于最高 $n$ 位都被设置为 $1$ ，因此系统可以通过读取最高位 $1$ 的个数来解析出字符的长度为 $n$ 。
+
+但为什么要将其余所有字节的高 2 位都设置为 $10$ 呢？实际上，这个 $10$ 能够起到校验符的作用。假设系统从一个错误的字节开始解析文本，字节头部的 $10$ 能够帮助系统快速的判断出异常。
+
+之所以将 $10$ 当作校验符，是因为在 UTF-8 编码规则下，不可能有字符的最高两位是 $10$ 。这个结论可以用反证法来证明：假设一个字符的最高两位是 $10$ ，说明该字符的长度为 $1$ ，对应 ASCII 码。而 ASCII 码的最高位应该是 $0$ ，与假设矛盾。
+
+![UTF-8 编码示例](character_encoding.assets/utf-8_hello_algo.png)
+
+<p align="center"> 图 3-8 &nbsp; UTF-8 编码示例 </p>
+
+除了 UTF-8 之外，常见的编码方式还包括以下两种。
+
+- **UTF-16 编码**：使用 2 或 4 个字节来表示一个字符。所有的 ASCII 字符和常用的非英文字符，都用 2 个字节表示；少数字符需要用到 4 个字节表示。对于 2 字节的字符，UTF-16 编码与 Unicode 码点相等。
+- **UTF-32 编码**：每个字符都使用 4 个字节。这意味着 UTF-32 会比 UTF-8 和 UTF-16 更占用空间，特别是对于 ASCII 字符占比较高的文本。
+
+从存储空间的角度看，使用 UTF-8 表示英文字符非常高效，因为它仅需 1 个字节；使用 UTF-16 编码某些非英文字符（例如中文）会更加高效，因为它只需要 2 个字节，而 UTF-8 可能需要 3 个字节。
+
+从兼容性的角度看，UTF-8 的通用性最佳，许多工具和库都优先支持 UTF-8 。
+
+## 3.4.5 &nbsp; 编程语言的字符编码
+
+对于以往的大多数编程语言，程序运行中的字符串都采用 UTF-16 或 UTF-32 这类等长的编码。在等长编码下，我们可以将字符串看作数组来处理，这种做法具有以下优点。
+
+- **随机访问**: UTF-16 编码的字符串可以很容易地进行随机访问。UTF-8 是一种变长编码，要找到第 $i$ 个字符，我们需要从字符串的开始处遍历到第 $i$ 个字符，这需要 $O(n)$ 的时间。
+- **字符计数**: 与随机访问类似，计算 UTF-16 字符串的长度也是 $O(1)$ 的操作。但是，计算 UTF-8 编码的字符串的长度需要遍历整个字符串。
+- **字符串操作**: 在 UTF-16 编码的字符串中，很多字符串操作（如分割、连接、插入、删除等）都更容易进行。在 UTF-8 编码的字符串上进行这些操作通常需要额外的计算，以确保不会产生无效的 UTF-8 编码。
+
+实际上，编程语言的字符编码方案设计是一个很有趣的话题，其涉及到许多因素。
+
+- Java 的 `String` 类型使用 UTF-16 编码，每个字符占用 2 字节。这是因为 Java 语言设计之初，人们认为 16 位足以表示所有可能的字符。然而，这是一个不正确的判断。后来 Unicode 规范扩展到了超过 16 位，所以 Java 中的字符现在可能由一对 16 位的值（称为“代理对”）表示。
+- JavaScript 和 TypeScript 的字符串使用 UTF-16 编码的原因与 Java 类似。当 JavaScript 语言在 1995 年被 Netscape 公司首次引入时，Unicode 还处于相对早期的阶段，那时候使用 16 位的编码就足够表示所有的 Unicode 字符了。
+- C# 使用 UTF-16 编码，主要因为 .NET 平台是由 Microsoft 设计的，而 Microsoft 的很多技术，包括 Windows 操作系统，都广泛地使用 UTF-16 编码。
+
+由于以上编程语言对字符数量的低估，它们不得不采取“代理对”的方式来表示超过 16 位长度的 Unicode 字符。这是一个不得已为之的无奈之举。一方面，包含代理对的字符串中，一个字符可能占用 2 字节或 4 字节，从而丧失了等长编码的优势。另一方面，处理代理对需要增加额外代码，这增加了编程的复杂性和 Debug 难度。
+
+出于以上原因，部分编程语言提出了一些不同的编码方案。
+
+- Python 中的 `str` 使用 Unicode 编码，并采用一种灵活的字符串表示，存储的字符长度取决于字符串中最大的 Unicode 码点。若字符串中全部是 ASCII 字符，则每个字符占用 1 个字节；如果有字符超出了 ASCII 范围，但全部在基本多语言平面（BMP）内，则每个字符占用 2 个字节；如果有超出 BMP 的字符，则每个字符占用 4 个字节。
+- Go 语言的 `string` 类型在内部使用 UTF-8 编码。Go 语言还提供了 `rune` 类型，它用于表示单个 Unicode 码点。
+- Rust 语言的 str 和 String 类型在内部使用 UTF-8 编码。Rust 也提供了 `char` 类型，用于表示单个 Unicode 码点。
+
+需要注意的是，以上讨论的都是字符串在编程语言中的存储方式，**这和字符串如何在文件中存储或在网络中传输是两个不同的问题**。在文件存储或网络传输中，我们通常会将字符串编码为 UTF-8 格式，以达到最优的兼容性和空间效率。

docs/chapter_data_structure/classification_of_data_structure.md

@@ -0,0 +1,57 @@
+---
+comments: true
+---
+
+# 3.1   数据结构分类
+
+常见的数据结构包括数组、链表、栈、队列、哈希表、树、堆、图，它们可以从“逻辑结构”和“物理结构”两个维度进行分类。
+
+## 3.1.1   逻辑结构：线性与非线性
+
+**逻辑结构揭示了数据元素之间的逻辑关系**。在数组和链表中，数据按照顺序依次排列，体现了数据之间的线性关系；而在树中，数据从顶部向下按层次排列，表现出祖先与后代之间的派生关系；图则由节点和边构成，反映了复杂的网络关系。
+
+如图 3-1 所示，逻辑结构可被分为“线性”和“非线性”两大类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列。
+
+- **线性数据结构**：数组、链表、栈、队列、哈希表。
+- **非线性数据结构**：树、堆、图、哈希表。
+
+![线性与非线性数据结构](classification_of_data_structure.assets/classification_logic_structure.png)
+
+<p align="center"> 图 3-1 &nbsp; 线性与非线性数据结构 </p>
+
+非线性数据结构可以进一步被划分为树形结构和网状结构。
+
+- **线性结构**：数组、链表、队列、栈、哈希表，元素之间是一对一的顺序关系。
+- **树形结构**：树、堆、哈希表，元素之间是一对多的关系。
+- **网状结构**：图，元素之间是多对多的关系。
+
+## 3.1.2 &nbsp; 物理结构：连续与分散
+
+在计算机中，内存和硬盘是两种主要的存储硬件设备。硬盘主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。内存用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。
+
+**在算法运行过程中，相关数据都存储在内存中**。图 3-2 展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储一定大小的数据，在算法运行时，所有数据都被存储在这些单元格中。
+
+**系统通过内存地址来访问目标位置的数据**。如图 3-2 所示，计算机根据特定规则为表格中的每个单元格分配编号，确保每个内存空间都有唯一的内存地址。有了这些地址，程序便可以访问内存中的数据。
+
+![内存条、内存空间、内存地址](classification_of_data_structure.assets/computer_memory_location.png)
+
+<p align="center"> 图 3-2 &nbsp; 内存条、内存空间、内存地址 </p>
+
+内存是所有程序的共享资源，当某块内存被某个程序占用时，则无法被其他程序同时使用了。**因此在数据结构与算法的设计中，内存资源是一个重要的考虑因素**。比如，算法所占用的内存峰值不应超过系统剩余空闲内存；如果缺少连续大块的内存空间，那么所选用的数据结构必须能够存储在分散的内存空间内。
+
+如图 3-3 所示，**物理结构反映了数据在计算机内存中的存储方式**，可分为连续空间存储（数组）和分散空间存储（链表）。物理结构从底层决定了数据的访问、更新、增删等操作方法，同时在时间效率和空间效率方面呈现出互补的特点。
+
+![连续空间存储与分散空间存储](classification_of_data_structure.assets/classification_phisical_structure.png)
+
+<p align="center"> 图 3-3 &nbsp; 连续空间存储与分散空间存储 </p>
+
+值得说明的是，**所有数据结构都是基于数组、链表或二者的组合实现的**。例如，栈和队列既可以使用数组实现，也可以使用链表实现；而哈希表的实现可能同时包含数组和链表。
+
+- **基于数组可实现**：栈、队列、哈希表、树、堆、图、矩阵、张量（维度 $\geq 3$ 的数组）等。
+- **基于链表可实现**：栈、队列、哈希表、树、堆、图等。
+
+基于数组实现的数据结构也被称为“静态数据结构”，这意味着此类数据结构在初始化后长度不可变。相对应地，基于链表实现的数据结构被称为“动态数据结构”，这类数据结构在初始化后，仍可以在程序运行过程中对其长度进行调整。
+
+!!! tip
+
+    如果你感觉物理结构理解起来有困难，建议先阅读下一章“数组与链表”，然后再回顾本节内容。

docs/chapter_data_structure/index.md

@@ -0,0 +1,26 @@
+---
+comments: true
+icon: material/shape-outline
+---
+
+# 第 3 章   数据结构
+
+<div class="center-table" markdown>
+
+![数据结构](../assets/covers/chapter_data_structure.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    数据结构如同一副稳固而多样的框架。
+    
+    它为数据的有序组织提供了蓝图，使算法得以在此基础上生动起来。
+
+## 本章内容
+
+- [3.1 &nbsp; 数据结构分类](https://www.hello-algo.com/chapter_data_structure/classification_of_data_structure/)
+- [3.2 &nbsp; 基本数据类型](https://www.hello-algo.com/chapter_data_structure/basic_data_types/)
+- [3.3 &nbsp; 数字编码 *](https://www.hello-algo.com/chapter_data_structure/number_encoding/)
+- [3.4 &nbsp; 字符编码 *](https://www.hello-algo.com/chapter_data_structure/character_encoding/)
+- [3.5 &nbsp; 小结](https://www.hello-algo.com/chapter_data_structure/summary/)

docs/chapter_data_structure/number_encoding.md

@@ -0,0 +1,162 @@
+---
+comments: true
+---
+
+# 3.3   数字编码 *
+
+!!! note
+
+    在本书中，标题带有的 * 符号的是选读章节。如果你时间有限或感到理解困难，可以先跳过，等学完必读章节后再单独攻克。
+
+## 3.3.1   整数编码
+
+在上一节的表格中我们发现，所有整数类型能够表示的负数都比正数多一个，例如 `byte` 的取值范围是 $[-128, 127]$ 。这个现象比较反直觉，它的内在原因涉及到原码、反码、补码的相关知识。
+
+首先需要指出，**数字是以“补码”的形式存储在计算机中的**。在分析这样做的原因之前，我们首先给出三者的定义。
+
+- **原码**：我们将数字的二进制表示的最高位视为符号位，其中 $0$ 表示正数，$1$ 表示负数，其余位表示数字的值。
+- **反码**：正数的反码与其原码相同，负数的反码是对其原码除符号位外的所有位取反。
+- **补码**：正数的补码与其原码相同，负数的补码是在其反码的基础上加 $1$ 。
+
+图 3-4 展示了原码、反码和补码之间的转换方法。
+
+![原码、反码与补码之间的相互转换](number_encoding.assets/1s_2s_complement.png)
+
+<p align="center"> 图 3-4 &nbsp; 原码、反码与补码之间的相互转换 </p>
+
+「原码 true form」虽然最直观，但存在一些局限性。一方面，**负数的原码不能直接用于运算**。例如在原码下计算 $1 + (-2)$ ，得到的结果是 $-3$ ，这显然是不对的。
+
+$$
+\begin{aligned}
+& 1 + (-2) \newline
+& \rightarrow 0000 \; 0001 + 1000 \; 0010 \newline
+& = 1000 \; 0011 \newline
+& \rightarrow -3
+\end{aligned}
+$$
+
+为了解决此问题，计算机引入了「反码 1's complement code」。如果我们先将原码转换为反码，并在反码下计算 $1 + (-2)$ ，最后将结果从反码转化回原码，则可得到正确结果 $-1$ 。
+
+$$
+\begin{aligned}
+& 1 + (-2) \newline
+& \rightarrow 0000 \; 0001 \; \text{(原码)} + 1000 \; 0010 \; \text{(原码)} \newline
+& = 0000 \; 0001 \; \text{(反码)} + 1111  \; 1101 \; \text{(反码)} \newline
+& = 1111 \; 1110 \; \text{(反码)} \newline
+& = 1000 \; 0001 \; \text{(原码)} \newline
+& \rightarrow -1
+\end{aligned}
+$$
+
+另一方面，**数字零的原码有 $+0$ 和 $-0$ 两种表示方式**。这意味着数字零对应着两个不同的二进制编码，其可能会带来歧义。比如在条件判断中，如果没有区分正零和负零，则可能会导致判断结果出错。而如果我们想要处理正零和负零歧义，则需要引入额外的判断操作，其可能会降低计算机的运算效率。
+
+$$
+\begin{aligned}
++0 & \rightarrow 0000 \; 0000 \newline
+-0 & \rightarrow 1000 \; 0000
+\end{aligned}
+$$
+
+与原码一样，反码也存在正负零歧义问题，因此计算机进一步引入了「补码 2's complement code」。我们先来观察一下负零的原码、反码、补码的转换过程：
+
+$$
+\begin{aligned}
+-0 \rightarrow \; & 1000 \; 0000 \; \text{(原码)} \newline
+= \; & 1111 \; 1111 \; \text{(反码)} \newline
+= 1 \; & 0000 \; 0000 \; \text{(补码)} \newline
+\end{aligned}
+$$
+
+在负零的反码基础上加 $1$ 会产生进位，但 `byte` 类型的长度只有 8 位，因此溢出到第 9 位的 $1$ 会被舍弃。也就是说，**负零的补码为 $0000 \; 0000$ ，与正零的补码相同**。这意味着在补码表示中只存在一个零，正负零歧义从而得到解决。
+
+还剩余最后一个疑惑：`byte` 类型的取值范围是 $[-128, 127]$ ，多出来的一个负数 $-128$ 是如何得到的呢？我们注意到，区间 $[-127, +127]$ 内的所有整数都有对应的原码、反码和补码，并且原码和补码之间是可以互相转换的。
+
+然而，**补码 $1000 \; 0000$ 是一个例外，它并没有对应的原码**。根据转换方法，我们得到该补码的原码为 $0000 \; 0000$ 。这显然是矛盾的，因为该原码表示数字 $0$ ，它的补码应该是自身。计算机规定这个特殊的补码 $1000 \; 0000$ 代表 $-128$ 。实际上，$(-1) + (-127)$ 在补码下的计算结果就是 $-128$ 。
+
+$$
+\begin{aligned}
+& (-127) + (-1) \newline
+& \rightarrow 1111 \; 1111 \; \text{(原码)} + 1000 \; 0001 \; \text{(原码)} \newline
+& = 1000 \; 0000 \; \text{(反码)} + 1111  \; 1110 \; \text{(反码)} \newline
+& = 1000 \; 0001 \; \text{(补码)} + 1111  \; 1111 \; \text{(补码)} \newline
+& = 1000 \; 0000 \; \text{(补码)} \newline
+& \rightarrow -128
+\end{aligned}
+$$
+
+你可能已经发现，上述的所有计算都是加法运算。这暗示着一个重要事实：**计算机内部的硬件电路主要是基于加法运算设计的**。这是因为加法运算相对于其他运算（比如乘法、除法和减法）来说，硬件实现起来更简单，更容易进行并行化处理，运算速度更快。
+
+请注意，这并不意味着计算机只能做加法。**通过将加法与一些基本逻辑运算结合，计算机能够实现各种其他的数学运算**。例如，计算减法 $a - b$ 可以转换为计算加法 $a + (-b)$ ；计算乘法和除法可以转换为计算多次加法或减法。
+
+现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无须特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。
+
+补码的设计非常精妙，因篇幅关系我们就先介绍到这里，建议有兴趣的读者进一步深度了解。
+
+## 3.3.2 &nbsp; 浮点数编码
+
+细心的你可能会发现：`int` 和 `float` 长度相同，都是 4 bytes ，但为什么 `float` 的取值范围远大于 `int` ？这非常反直觉，因为按理说 `float` 需要表示小数，取值范围应该变小才对。
+
+实际上，**这是因为浮点数 `float` 采用了不同的表示方式**。记一个 32-bit 长度的二进制数为：
+
+$$
+b_{31} b_{30} b_{29} \ldots b_2 b_1 b_0
+$$
+
+根据 IEEE 754 标准，32-bit 长度的 `float` 由以下三个部分构成。
+
+- 符号位 $\mathrm{S}$ ：占 1 bit ，对应 $b_{31}$ 。
+- 指数位 $\mathrm{E}$ ：占 8 bits ，对应 $b_{30} b_{29} \ldots b_{23}$ 。
+- 分数位 $\mathrm{N}$ ：占 23 bits ，对应 $b_{22} b_{21} \ldots b_0$ 。
+
+二进制数 `float` 对应的值的计算方法：
+
+$$
+\text {val} = (-1)^{b_{31}} \times 2^{\left(b_{30} b_{29} \ldots b_{23}\right)_2-127} \times\left(1 . b_{22} b_{21} \ldots b_0\right)_2
+$$
+
+转化到十进制下的计算公式：
+
+$$
+\text {val}=(-1)^{\mathrm{S}} \times 2^{\mathrm{E} -127} \times (1 + \mathrm{N})
+$$
+
+其中各项的取值范围：
+
+$$
+\begin{aligned}
+\mathrm{S} \in & \{ 0, 1\}, \quad \mathrm{E} \in \{ 1, 2, \dots, 254 \} \newline
+(1 + \mathrm{N}) = & (1 + \sum_{i=1}^{23} b_{23-i} 2^{-i}) \subset [1, 2 - 2^{-23}]
+\end{aligned}
+$$
+
+![IEEE 754 标准下的 float 的计算示例](number_encoding.assets/ieee_754_float.png)
+
+<p align="center"> 图 3-5 &nbsp; IEEE 754 标准下的 float 的计算示例 </p>
+
+观察图 3-5 ，给定一个示例数据 $\mathrm{S} = 0$ ， $\mathrm{E} = 124$ ，$\mathrm{N} = 2^{-2} + 2^{-3} = 0.375$ ，则有：
+
+$$
+\text { val } = (-1)^0 \times 2^{124 - 127} \times (1 + 0.375) = 0.171875
+$$
+
+现在我们可以回答最初的问题：**`float` 的表示方式包含指数位，导致其取值范围远大于 `int`** 。根据以上计算，`float` 可表示的最大正数为 $2^{254 - 127} \times (2 - 2^{-23}) \approx 3.4 \times 10^{38}$ ，切换符号位便可得到最小负数。
+
+**尽管浮点数 `float` 扩展了取值范围，但其副作用是牺牲了精度**。整数类型 `int` 将全部 32 位用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 `float` 的数值越大，相邻两个数字之间的差值就会趋向越大。
+
+如表 3-2 所示，指数位 $E = 0$ 和 $E = 255$ 具有特殊含义，**用于表示零、无穷大、$\mathrm{NaN}$ 等**。
+
+<p align="center"> 表 3-2 &nbsp; 指数位含义 </p>
+
+<div class="center-table" markdown>
+
+| 指数位 E           | 分数位 $\mathrm{N} = 0$ | 分数位 $\mathrm{N} \ne 0$ | 计算公式                                                               |
+| ------------------ | ----------------------- | ------------------------- | ---------------------------------------------------------------------- |
+| $0$                | $\pm 0$                 | 次正规数                  | $(-1)^{\mathrm{S}} \times 2^{-126} \times (0.\mathrm{N})$              |
+| $1, 2, \dots, 254$ | 正规数                  | 正规数                    | $(-1)^{\mathrm{S}} \times 2^{(\mathrm{E} -127)} \times (1.\mathrm{N})$ |
+| $255$              | $\pm \infty$            | $\mathrm{NaN}$            |                                                                        |
+
+</div>
+
+值得说明的是，次正规数显著提升了浮点数的精度。最小正正规数为 $2^{-126}$ ，最小正次正规数为 $2^{-126} \times 2^{-23}$ 。
+
+双精度 `double` 也采用类似 `float` 的表示方法，在此不做赘述。

docs/chapter_data_structure/summary.md

@@ -0,0 +1,28 @@
+---
+comments: true
+---
+
+# 3.5   小结
+
+### 1.   重点回顾
+
+- 数据结构可以从逻辑结构和物理结构两个角度进行分类。逻辑结构描述了数据元素之间的逻辑关系，而物理结构描述了数据在计算机内存中的存储方式。
+- 常见的逻辑结构包括线性、树状和网状等。通常我们根据逻辑结构将数据结构分为线性（数组、链表、栈、队列）和非线性（树、图、堆）两种。哈希表的实现可能同时包含线性和非线性结构。
+- 当程序运行时，数据被存储在计算机内存中。每个内存空间都拥有对应的内存地址，程序通过这些内存地址访问数据。
+- 物理结构主要分为连续空间存储（数组）和分散空间存储（链表）。所有数据结构都是由数组、链表或两者的组合实现的。
+- 计算机中的基本数据类型包括整数 `byte`、`short`、`int`、`long` ，浮点数 `float`、`double` ，字符 `char` 和布尔 `boolean` 。它们的取值范围取决于占用空间大小和表示方式。
+- 原码、反码和补码是在计算机中编码数字的三种方法，它们之间是可以相互转换的。整数的原码的最高位是符号位，其余位是数字的值。
+- 整数在计算机中是以补码的形式存储的。在补码表示下，计算机可以对正数和负数的加法一视同仁，不需要为减法操作单独设计特殊的硬件电路，并且不存在正负零歧义的问题。
+- 浮点数的编码由 1 位符号位、8 位指数位和 23 位分数位构成。由于存在指数位，浮点数的取值范围远大于整数，代价是牺牲了精度。
+- ASCII 码是最早出现的英文字符集，长度为 1 字节，共收录 127 个字符。GBK 字符集是常用的中文字符集，共收录两万多个汉字。Unicode 致力于提供一个完整的字符集标准，收录世界内各种语言的字符，从而解决由于字符编码方法不一致而导致的乱码问题。
+- UTF-8 是最受欢迎的 Unicode 编码方法，通用性非常好。它是一种变长的编码方法，具有很好的扩展性，有效提升了存储空间的使用效率。UTF-16 和 UTF-32 是等长的编码方法。在编码中文时，UTF-16 比 UTF-8 的占用空间更小。Java 和 C# 等编程语言默认使用 UTF-16 编码。
+
+### 2.   Q & A
+
+!!! question "为什么哈希表同时包含线性数据结构和非线性数据结构？"
+
+    哈希表底层是数组，而为了解决哈希冲突，我们可能会使用“链式地址”（后续哈希表章节会讲）。在拉链法中，数组中每个地址（桶）指向一个链表；当这个链表长度超过一定阈值时，又可能被转化为树（通常为红黑树）。因此，哈希表可能同时包含线性（数组、链表）和非线性（树）数据结构。
+
+!!! question "`char` 类型的长度是 1 byte 吗？"
+
+    `char` 类型的长度由编程语言采用的编码方法决定。例如，Java、JS、TS、C# 都采用 UTF-16 编码（保存 Unicode 码点），因此 char 类型的长度为 2 bytes 。

docs/chapter_divide_and_conquer/binary_search_recur.md

@@ -0,0 +1,391 @@
+---
+comments: true
+---
+
+# 12.2   分治搜索策略
+
+我们已经学过，搜索算法分为两大类。
+
+- **暴力搜索**：它通过遍历数据结构实现，时间复杂度为 $O(n)$ 。
+- **自适应搜索**：它利用特有的数据组织形式或先验信息，可达到 $O(\log n)$ 甚至 $O(1)$ 的时间复杂度。
+
+实际上，**时间复杂度为 $O(\log n)$ 的搜索算法通常都是基于分治策略实现的**，例如二分查找和树。
+
+- 二分查找的每一步都将问题（在数组中搜索目标元素）分解为一个小问题（在数组的一半中搜索目标元素），这个过程一直持续到数组为空或找到目标元素为止。
+- 树是分治关系的代表，在二叉搜索树、AVL 树、堆等数据结构中，各种操作的时间复杂度皆为 $O(\log n)$ 。
+
+二分查找的分治策略如下所示。
+
+- **问题可以被分解**：二分查找递归地将原问题（在数组中进行查找）分解为子问题（在数组的一半中进行查找），这是通过比较中间元素和目标元素来实现的。
+- **子问题是独立的**：在二分查找中，每轮只处理一个子问题，它不受另外子问题的影响。
+- **子问题的解无须合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
+
+分治能够提升搜索效率，本质上是因为暴力搜索每轮只能排除一个选项，**而分治搜索每轮可以排除一半选项**。
+
+### 1.   基于分治实现二分
+
+在之前的章节中，二分查找是基于递推（迭代）实现的。现在我们基于分治（递归）来实现它。
+
+!!! question
+
+    给定一个长度为 $n$ 的有序数组 `nums` ，数组中所有元素都是唯一的，请查找元素 `target` 。
+
+从分治角度，我们将搜索区间 $[i, j]$ 对应的子问题记为 $f(i, j)$ 。
+
+从原问题 $f(0, n-1)$ 为起始点，通过以下步骤进行二分查找。
+
+1. 计算搜索区间 $[i, j]$ 的中点 $m$ ，根据它排除一半搜索区间。
+2. 递归求解规模减小一半的子问题，可能为 $f(i, m-1)$ 或 $f(m+1, j)$ 。
+3. 循环第 `1.` 和 `2.` 步，直至找到 `target` 或区间为空时返回。
+
+图 12-4 展示了在数组中二分查找元素 $6$ 的分治过程。
+
+![二分查找的分治过程](binary_search_recur.assets/binary_search_recur.png)
+
+<p align="center"> 图 12-4 &nbsp; 二分查找的分治过程 </p>
+
+在实现代码中，我们声明一个递归函数 `dfs()` 来求解问题 $f(i, j)$ 。
+
+=== "Python"
+
+    ```python title="binary_search_recur.py"
+    def dfs(nums: list[int], target: int, i: int, j: int) -> int:
+        """二分查找：问题 f(i, j)"""
+        # 若区间为空，代表无目标元素，则返回 -1
+        if i > j:
+            return -1
+        # 计算中点索引 m
+        m = (i + j) // 2
+        if nums[m] < target:
+            # 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j)
+        elif nums[m] > target:
+            # 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1)
+        else:
+            # 找到目标元素，返回其索引
+            return m
+
+    def binary_search(nums: list[int], target: int) -> int:
+        """二分查找"""
+        n = len(nums)
+        # 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1)
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search_recur.cpp"
+    /* 二分查找：问题 f(i, j) */
+    int dfs(vector<int> &nums, int target, int i, int j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+
+    /* 二分查找 */
+    int binarySearch(vector<int> &nums, int target) {
+        int n = nums.size();
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_search_recur.java"
+    /* 二分查找：问题 f(i, j) */
+    int dfs(int[] nums, int target, int i, int j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+
+    /* 二分查找 */
+    int binarySearch(int[] nums, int target) {
+        int n = nums.length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search_recur.cs"
+    /* 二分查找：问题 f(i, j) */
+    int Dfs(int[] nums, int target, int i, int j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return Dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return Dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+
+    /* 二分查找 */
+    int BinarySearch(int[] nums, int target) {
+        int n = nums.Length;
+        // 求解问题 f(0, n-1)
+        return Dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_recur.go"
+    /* 二分查找：问题 f(i, j) */
+    func dfs(nums []int, target, i, j int) int {
+        // 如果区间为空，代表没有目标元素，则返回 -1
+        if i > j {
+            return -1
+        }
+        //    计算索引中点
+        m := i + ((j - i) >> 1)
+        //判断中点与目标元素大小
+        if nums[m] < target {
+            // 小于则递归右半数组
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m+1, j)
+        } else if nums[m] > target {
+            // 小于则递归左半数组
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m-1)
+        } else {
+            // 找到目标元素，返回其索引
+            return m
+        }
+    }
+
+    /* 二分查找 */
+    func binarySearch(nums []int, target int) int {
+        n := len(nums)
+        return dfs(nums, target, 0, n-1)
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search_recur.swift"
+    /* 二分查找：问题 f(i, j) */
+    func dfs(nums: [Int], target: Int, i: Int, j: Int) -> Int {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if i > j {
+            return -1
+        }
+        // 计算中点索引 m
+        let m = (i + j) / 2
+        if nums[m] < target {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums: nums, target: target, i: m + 1, j: j)
+        } else if nums[m] > target {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums: nums, target: target, i: i, j: m - 1)
+        } else {
+            // 找到目标元素，返回其索引
+            return m
+        }
+    }
+
+    /* 二分查找 */
+    func binarySearch(nums: [Int], target: Int) -> Int {
+        let n = nums.count
+        // 求解问题 f(0, n-1)
+        return dfs(nums: nums, target: target, i: 0, j: n - 1)
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_search_recur.js"
+    /* 二分查找：问题 f(i, j) */
+    function dfs(nums, target, i, j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        const m = i + ((j - i) >> 1);
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+
+    /* 二分查找 */
+    function binarySearch(nums, target) {
+        const n = nums.length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_search_recur.ts"
+    /* 二分查找：问题 f(i, j) */
+    function dfs(nums: number[], target: number, i: number, j: number): number {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        const m = i + ((j - i) >> 1);
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+
+    /* 二分查找 */
+    function binarySearch(nums: number[], target: number): number {
+        const n = nums.length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search_recur.dart"
+    /* 二分查找：问题 f(i, j) */
+    int dfs(List<int> nums, int target, int i, int j) {
+      // 若区间为空，代表无目标元素，则返回 -1
+      if (i > j) {
+        return -1;
+      }
+      // 计算中点索引 m
+      int m = (i + j) ~/ 2;
+      if (nums[m] < target) {
+        // 递归子问题 f(m+1, j)
+        return dfs(nums, target, m + 1, j);
+      } else if (nums[m] > target) {
+        // 递归子问题 f(i, m-1)
+        return dfs(nums, target, i, m - 1);
+      } else {
+        // 找到目标元素，返回其索引
+        return m;
+      }
+    }
+
+    /* 二分查找 */
+    int binarySearch(List<int> nums, int target) {
+      int n = nums.length;
+      // 求解问题 f(0, n-1)
+      return dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_search_recur.rs"
+    /* 二分查找：问题 f(i, j) */
+    fn dfs(nums: &[i32], target: i32, i: i32, j: i32) -> i32 {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if i > j { return -1; }
+        let m: i32 = (i + j) / 2;
+        if nums[m as usize] < target {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if nums[m as usize] > target {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+
+    /* 二分查找 */
+    fn binary_search(nums: &[i32], target: i32) -> i32 {
+        let n = nums.len() as i32;
+        // 求解问题 f(0, n-1)
+        dfs(nums, target, 0, n - 1)
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_search_recur.c"
+    /* 二分查找：问题 f(i, j) */
+    int dfs(int nums[], int target, int i, int j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+
+    /* 二分查找 */
+    int binarySearch(int nums[], int target, int numsSize) {
+        int n = numsSize;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_recur.zig"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```

docs/chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -0,0 +1,459 @@
+---
+comments: true
+---
+
+# 12.3   构建二叉树问题
+
+!!! question
+
+    给定一个二叉树的前序遍历 `preorder` 和中序遍历 `inorder` ，请从中构建二叉树，返回二叉树的根节点。
+
+![构建二叉树的示例数据](build_binary_tree_problem.assets/build_tree_example.png)
+
+<p align="center"> 图 12-5 &nbsp; 构建二叉树的示例数据 </p>
+
+### 1. &nbsp; 判断是否为分治问题
+
+原问题定义为从 `preorder` 和 `inorder` 构建二叉树，其是一个典型的分治问题。
+
+- **问题可以被分解**：从分治的角度切入，我们可以将原问题划分为两个子问题：构建左子树、构建右子树，加上一步操作：初始化根节点。而对于每个子树（子问题），我们仍然可以复用以上划分方法，将其划分为更小的子树（子问题），直至达到最小子问题（空子树）时终止。
+- **子问题是独立的**：左子树和右子树是相互独立的，它们之间没有交集。在构建左子树时，我们只需要关注中序遍历和前序遍历中与左子树对应的部分。右子树同理。
+- **子问题的解可以合并**：一旦得到了左子树和右子树（子问题的解），我们就可以将它们链接到根节点上，得到原问题的解。
+
+### 2. &nbsp; 如何划分子树
+
+根据以上分析，这道题是可以使用分治来求解的，**但如何通过前序遍历 `preorder` 和中序遍历 `inorder` 来划分左子树和右子树呢**？
+
+根据定义，`preorder` 和 `inorder` 都可以被划分为三个部分。
+
+- 前序遍历：`[ 根节点 | 左子树 | 右子树 ]` ，例如图 12-5 的树对应 `[ 3 | 9 | 2 1 7 ]` 。
+- 中序遍历：`[ 左子树 | 根节点 ｜ 右子树 ]` ，例如图 12-5 的树对应 `[ 9 | 3 | 1 2 7 ]` 。
+
+以上图数据为例，我们可以通过图 12-6 所示的步骤得到划分结果。
+
+1. 前序遍历的首元素 3 是根节点的值。
+2. 查找根节点 3 在 `inorder` 中的索引，利用该索引可将 `inorder` 划分为 `[ 9 | 3 ｜ 1 2 7 ]` 。
+3. 根据 `inorder` 划分结果，易得左子树和右子树的节点数量分别为 1 和 3 ，从而可将 `preorder` 划分为 `[ 3 | 9 | 2 1 7 ]` 。
+
+![在前序和中序遍历中划分子树](build_binary_tree_problem.assets/build_tree_preorder_inorder_division.png)
+
+<p align="center"> 图 12-6 &nbsp; 在前序和中序遍历中划分子树 </p>
+
+### 3. &nbsp; 基于变量描述子树区间
+
+根据以上划分方法，**我们已经得到根节点、左子树、右子树在 `preorder` 和 `inorder` 中的索引区间**。而为了描述这些索引区间，我们需要借助几个指针变量。
+
+- 将当前树的根节点在 `preorder` 中的索引记为 $i$ 。
+- 将当前树的根节点在 `inorder` 中的索引记为 $m$ 。
+- 将当前树在 `inorder` 中的索引区间记为 $[l, r]$ 。
+
+如表 12-1 所示，通过以上变量即可表示根节点在 `preorder` 中的索引，以及子树在 `inorder` 中的索引区间。
+
+<p align="center"> 表 12-1 &nbsp; 根节点和子树在前序和中序遍历中的索引 </p>
+
+<div class="center-table" markdown>
+
+|        | 根节点在 `preorder` 中的索引 | 子树在 `inorder` 中的索引区间 |
+| ------ | -------------------------------- | ----------------------------- |
+| 当前树 | $i$                              | $[l, r]$                      |
+| 左子树 | $i + 1$                          | $[l, m-1]$                    |
+| 右子树 | $i + 1 + (m - l)$                | $[m+1, r]$                    |
+
+</div>
+
+请注意，右子树根节点索引中的 $(m-l)$ 的含义是“左子树的节点数量”，建议配合图 12-7 理解。
+
+![根节点和左右子树的索引区间表示](build_binary_tree_problem.assets/build_tree_division_pointers.png)
+
+<p align="center"> 图 12-7 &nbsp; 根节点和左右子树的索引区间表示 </p>
+
+### 4. &nbsp; 代码实现
+
+为了提升查询 $m$ 的效率，我们借助一个哈希表 `hmap` 来存储数组 `inorder` 中元素到索引的映射。
+
+=== "Python"
+
+    ```python title="build_tree.py"
+    def dfs(
+        preorder: list[int],
+        inorder_map: dict[int, int],
+        i: int,
+        l: int,
+        r: int,
+    ) -> TreeNode | None:
+        """构建二叉树：分治"""
+        # 子树区间为空时终止
+        if r - l < 0:
+            return None
+        # 初始化根节点
+        root = TreeNode(preorder[i])
+        # 查询 m ，从而划分左右子树
+        m = inorder_map[preorder[i]]
+        # 子问题：构建左子树
+        root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)
+        # 子问题：构建右子树
+        root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)
+        # 返回根节点
+        return root
+
+    def build_tree(preorder: list[int], inorder: list[int]) -> TreeNode | None:
+        """构建二叉树"""
+        # 初始化哈希表，存储 inorder 元素到索引的映射
+        inorder_map = {val: i for i, val in enumerate(inorder)}
+        root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)
+        return root
+    ```
+
+=== "C++"
+
+    ```cpp title="build_tree.cpp"
+    /* 构建二叉树：分治 */
+    TreeNode *dfs(vector<int> &preorder, unordered_map<int, int> &inorderMap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return NULL;
+        // 初始化根节点
+        TreeNode *root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = inorderMap[preorder[i]];
+        // 子问题：构建左子树
+        root->left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
+
+    /* 构建二叉树 */
+    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        unordered_map<int, int> inorderMap;
+        for (int i = 0; i < inorder.size(); i++) {
+            inorderMap[inorder[i]] = i;
+        }
+        TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);
+        return root;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="build_tree.java"
+    /* 构建二叉树：分治 */
+    TreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return null;
+        // 初始化根节点
+        TreeNode root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = inorderMap.get(preorder[i]);
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
+
+    /* 构建二叉树 */
+    TreeNode buildTree(int[] preorder, int[] inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        Map<Integer, Integer> inorderMap = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inorderMap.put(inorder[i], i);
+        }
+        TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+        return root;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="build_tree.cs"
+    /* 构建二叉树：分治 */
+    TreeNode Dfs(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return null;
+        // 初始化根节点
+        TreeNode root = new(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = inorderMap[preorder[i]];
+        // 子问题：构建左子树
+        root.left = Dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = Dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
+
+    /* 构建二叉树 */
+    TreeNode BuildTree(int[] preorder, int[] inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        Dictionary<int, int> inorderMap = new();
+        for (int i = 0; i < inorder.Length; i++) {
+            inorderMap.TryAdd(inorder[i], i);
+        }
+        TreeNode root = Dfs(preorder, inorderMap, 0, 0, inorder.Length - 1);
+        return root;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="build_tree.go"
+    /* 构建二叉树：分治 */
+    func dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {
+        // 子树区间为空时终止
+        if r-l < 0 {
+            return nil
+        }
+        // 初始化根节点
+        root := NewTreeNode(preorder[i])
+        // 查询 m ，从而划分左右子树
+        m := inorderMap[preorder[i]]
+        // 子问题：构建左子树
+        root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)
+        // 子问题：构建右子树
+        root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)
+        // 返回根节点
+        return root
+    }
+
+    /* 构建二叉树 */
+    func buildTree(preorder, inorder []int) *TreeNode {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        inorderMap := make(map[int]int, len(inorder))
+        for i := 0; i < len(inorder); i++ {
+            inorderMap[inorder[i]] = i
+        }
+
+        root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)
+        return root
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="build_tree.swift"
+    /* 构建二叉树：分治 */
+    func dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {
+        // 子树区间为空时终止
+        if r - l < 0 {
+            return nil
+        }
+        // 初始化根节点
+        let root = TreeNode(x: preorder[i])
+        // 查询 m ，从而划分左右子树
+        let m = inorderMap[preorder[i]]!
+        // 子问题：构建左子树
+        root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)
+        // 子问题：构建右子树
+        root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)
+        // 返回根节点
+        return root
+    }
+
+    /* 构建二叉树 */
+    func buildTree(preorder: [Int], inorder: [Int]) -> TreeNode? {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }
+        return dfs(preorder: preorder, inorderMap: inorderMap, i: 0, l: 0, r: inorder.count - 1)
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="build_tree.js"
+    /* 构建二叉树：分治 */
+    function dfs(preorder, inorderMap, i, l, r) {
+        // 子树区间为空时终止
+        if (r - l < 0) return null;
+        // 初始化根节点
+        const root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        const m = inorderMap.get(preorder[i]);
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
+
+    /* 构建二叉树 */
+    function buildTree(preorder, inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let inorderMap = new Map();
+        for (let i = 0; i < inorder.length; i++) {
+            inorderMap.set(inorder[i], i);
+        }
+        const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+        return root;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="build_tree.ts"
+    /* 构建二叉树：分治 */
+    function dfs(
+        preorder: number[],
+        inorderMap: Map<number, number>,
+        i: number,
+        l: number,
+        r: number
+    ): TreeNode | null {
+        // 子树区间为空时终止
+        if (r - l < 0) return null;
+        // 初始化根节点
+        const root: TreeNode = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        const m = inorderMap.get(preorder[i]);
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
+
+    /* 构建二叉树 */
+    function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let inorderMap = new Map<number, number>();
+        for (let i = 0; i < inorder.length; i++) {
+            inorderMap.set(inorder[i], i);
+        }
+        const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+        return root;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="build_tree.dart"
+    /* 构建二叉树：分治 */
+    TreeNode? dfs(
+      List<int> preorder,
+      Map<int, int> inorderMap,
+      int i,
+      int l,
+      int r,
+    ) {
+      // 子树区间为空时终止
+      if (r - l < 0) {
+        return null;
+      }
+      // 初始化根节点
+      TreeNode? root = TreeNode(preorder[i]);
+      // 查询 m ，从而划分左右子树
+      int m = inorderMap[preorder[i]]!;
+      // 子问题：构建左子树
+      root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+      // 子问题：构建右子树
+      root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+      // 返回根节点
+      return root;
+    }
+
+    /* 构建二叉树 */
+    TreeNode? buildTree(List<int> preorder, List<int> inorder) {
+      // 初始化哈希表，存储 inorder 元素到索引的映射
+      Map<int, int> inorderMap = {};
+      for (int i = 0; i < inorder.length; i++) {
+        inorderMap[inorder[i]] = i;
+      }
+      TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+      return root;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="build_tree.rs"
+    /* 构建二叉树：分治 */
+    fn dfs(preorder: &[i32], inorder_map: &HashMap<i32, i32>, i: i32, l: i32, r: i32) -> Option<Rc<RefCell<TreeNode>>> {
+        // 子树区间为空时终止
+        if r - l < 0 { return None; }
+        // 初始化根节点
+        let root = TreeNode::new(preorder[i as usize]);
+        // 查询 m ，从而划分左右子树
+        let m = inorder_map.get(&preorder[i as usize]).unwrap();
+        // 子问题：构建左子树
+        root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        Some(root)
+    }
+
+    /* 构建二叉树 */
+    fn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let mut inorder_map: HashMap<i32, i32> = HashMap::new();
+        for i in 0..inorder.len() {
+            inorder_map.insert(inorder[i], i as i32);
+        }
+        let root = dfs(preorder, &inorder_map, 0, 0, inorder.len() as i32 - 1);
+        root
+    }
+    ```
+
+=== "C"
+
+    ```c title="build_tree.c"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{buildTree}
+    ```
+
+=== "Zig"
+
+    ```zig title="build_tree.zig"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{buildTree}
+    ```
+
+图 12-8 展示了构建二叉树的递归过程，各个节点是在向下“递”的过程中建立的，而各条边（即引用）是在向上“归”的过程中建立的。
+
+=== "<1>"
+    ![构建二叉树的递归过程](build_binary_tree_problem.assets/built_tree_step1.png)
+
+=== "<2>"
+    ![built_tree_step2](build_binary_tree_problem.assets/built_tree_step2.png)
+
+=== "<3>"
+    ![built_tree_step3](build_binary_tree_problem.assets/built_tree_step3.png)
+
+=== "<4>"
+    ![built_tree_step4](build_binary_tree_problem.assets/built_tree_step4.png)
+
+=== "<5>"
+    ![built_tree_step5](build_binary_tree_problem.assets/built_tree_step5.png)
+
+=== "<6>"
+    ![built_tree_step6](build_binary_tree_problem.assets/built_tree_step6.png)
+
+=== "<7>"
+    ![built_tree_step7](build_binary_tree_problem.assets/built_tree_step7.png)
+
+=== "<8>"
+    ![built_tree_step8](build_binary_tree_problem.assets/built_tree_step8.png)
+
+=== "<9>"
+    ![built_tree_step9](build_binary_tree_problem.assets/built_tree_step9.png)
+
+<p align="center"> 图 12-8 &nbsp; 构建二叉树的递归过程 </p>
+
+每个递归函数内的前序遍历 `preorder` 和中序遍历 `inorder` 的划分结果如图 12-9 所示。
+
+![每个递归函数中的划分结果](build_binary_tree_problem.assets/built_tree_overall.png)
+
+<p align="center"> 图 12-9 &nbsp; 每个递归函数中的划分结果 </p>
+
+设树的节点数量为 $n$ ，初始化每一个节点（执行一个递归函数 `dfs()` ）使用 $O(1)$ 时间。**因此总体时间复杂度为 $O(n)$** 。
+
+哈希表存储 `inorder` 元素到索引的映射，空间复杂度为 $O(n)$ 。最差情况下，即二叉树退化为链表时，递归深度达到 $n$ ，使用 $O(n)$ 的栈帧空间。**因此总体空间复杂度为 $O(n)$** 。

docs/chapter_divide_and_conquer/divide_and_conquer.md

@@ -0,0 +1,101 @@
+---
+comments: true
+---
+
+# 12.1   分治算法
+
+「分治 divide and conquer」，全称分而治之，是一种非常重要且常见的算法策略。分治通常基于递归实现，包括“分”和“治”两个步骤。
+
+1. **分（划分阶段）**：递归地将原问题分解为两个或多个子问题，直至到达最小子问题时终止。
+2. **治（合并阶段）**：从已知解的最小子问题开始，从底至顶地将子问题的解进行合并，从而构建出原问题的解。
+
+如图 12-1 所示，“归并排序”是分治策略的典型应用之一。
+
+1. **分**：递归地将原数组（原问题）划分为两个子数组（子问题），直到子数组只剩一个元素（最小子问题）。
+2. **治**：从底至顶地将有序的子数组（子问题的解）进行合并，从而得到有序的原数组（原问题的解）。
+
+![归并排序的分治策略](divide_and_conquer.assets/divide_and_conquer_merge_sort.png)
+
+<p align="center"> 图 12-1 &nbsp; 归并排序的分治策略 </p>
+
+## 12.1.1 &nbsp; 如何判断分治问题
+
+一个问题是否适合使用分治解决，通常可以参考以下几个判断依据。
+
+1. **问题可以被分解**：原问题可以被分解成规模更小、类似的子问题，以及能够以相同方式递归地进行划分。
+2. **子问题是独立的**：子问题之间是没有重叠的，互相没有依赖，可以被独立解决。
+3. **子问题的解可以被合并**：原问题的解通过合并子问题的解得来。
+
+显然，归并排序是满足以上三条判断依据的。
+
+1. **问题可以被分解**：递归地将数组（原问题）划分为两个子数组（子问题）。
+2. **子问题是独立的**：每个子数组都可以独立地进行排序（子问题可以独立进行求解）。
+3. **子问题的解可以被合并**：两个有序子数组（子问题的解）可以被合并为一个有序数组（原问题的解）。
+
+## 12.1.2 &nbsp; 通过分治提升效率
+
+分治不仅可以有效地解决算法问题，**往往还可以带来算法效率的提升**。在排序算法中，快速排序、归并排序、堆排序相较于选择、冒泡、插入排序更快，就是因为它们应用了分治策略。
+
+那么，我们不禁发问：**为什么分治可以提升算法效率，其底层逻辑是什么**？换句话说，将大问题分解为多个子问题、解决子问题、将子问题的解合并为原问题的解，这几步的效率为什么比直接解决原问题的效率更高？这个问题可以从操作数量和并行计算两方面来讨论。
+
+### 1. &nbsp; 操作数量优化
+
+以“冒泡排序”为例，其处理一个长度为 $n$ 的数组需要 $O(n^2)$ 时间。假设我们按照图 12-2 所示的方式，将数组从中点分为两个子数组，则划分需要 $O(n)$ 时间，排序每个子数组需要 $O((n / 2)^2)$ 时间，合并两个子数组需要 $O(n)$ 时间，总体时间复杂度为：
+
+$$
+O(n + (\frac{n}{2})^2 \times 2 + n) = O(\frac{n^2}{2} + 2n)
+$$
+
+![划分数组前后的冒泡排序](divide_and_conquer.assets/divide_and_conquer_bubble_sort.png)
+
+<p align="center"> 图 12-2 &nbsp; 划分数组前后的冒泡排序 </p>
+
+接下来，我们计算以下不等式，其左边和右边分别为划分前和划分后的操作总数：
+
+$$
+\begin{aligned}
+n^2 & > \frac{n^2}{2} + 2n \newline
+n^2 - \frac{n^2}{2} - 2n & > 0 \newline
+n(n - 4) & > 0
+\end{aligned}
+$$
+
+**这意味着当 $n > 4$ 时，划分后的操作数量更少，排序效率应该更高**。请注意，划分后的时间复杂度仍然是平方阶 $O(n^2)$ ，只是复杂度中的常数项变小了。
+
+进一步想，**如果我们把子数组不断地再从中点划分为两个子数组**，直至子数组只剩一个元素时停止划分呢？这种思路实际上就是“归并排序”，时间复杂度为 $O(n \log n)$ 。
+
+再思考，**如果我们多设置几个划分点**，将原数组平均划分为 $k$ 个子数组呢？这种情况与“桶排序”非常类似，它非常适合排序海量数据，理论上时间复杂度可以达到 $O(n + k)$ 。
+
+### 2. &nbsp; 并行计算优化
+
+我们知道，分治生成的子问题是相互独立的，**因此通常可以并行解决**。也就是说，分治不仅可以降低算法的时间复杂度，**还有利于操作系统的并行优化**。
+
+并行优化在多核或多处理器的环境中尤其有效，因为系统可以同时处理多个子问题，更加充分地利用计算资源，从而显著减少总体的运行时间。
+
+比如在图 12-3 所示的“桶排序”中，我们将海量的数据平均分配到各个桶中，则可所有桶的排序任务分散到各个计算单元，完成后再进行结果合并。
+
+![桶排序的并行计算](divide_and_conquer.assets/divide_and_conquer_parallel_computing.png)
+
+<p align="center"> 图 12-3 &nbsp; 桶排序的并行计算 </p>
+
+## 12.1.3 &nbsp; 分治常见应用
+
+一方面，分治可以用来解决许多经典算法问题。
+
+- **寻找最近点对**：该算法首先将点集分成两部分，然后分别找出两部分中的最近点对，最后再找出跨越两部分的最近点对。
+- **大整数乘法**：例如 Karatsuba 算法，它是将大整数乘法分解为几个较小的整数的乘法和加法。
+- **矩阵乘法**：例如 Strassen 算法，它是将大矩阵乘法分解为多个小矩阵的乘法和加法。
+- **汉诺塔问题**：汉诺塔问题可以视为典型的分治策略，通过递归解决。
+- **求解逆序对**：在一个序列中，如果前面的数字大于后面的数字，那么这两个数字构成一个逆序对。求解逆序对问题可以通过分治的思想，借助归并排序进行求解。
+
+另一方面，分治在算法和数据结构的设计中应用非常广泛。
+
+- **二分查找**：二分查找是将有序数组从中点索引分为两部分，然后根据目标值与中间元素值比较结果，决定排除哪一半区间，然后在剩余区间执行相同的二分操作。
+- **归并排序**：文章开头已介绍，不再赘述。
+- **快速排序**：快速排序是选取一个基准值，然后把数组分为两个子数组，一个子数组的元素比基准值小，另一子数组的元素比基准值大，然后再对这两部分进行相同的划分操作，直至子数组只剩下一个元素。
+- **桶排序**：桶排序的基本思想是将数据分散到多个桶，然后对每个桶内的元素进行排序，最后将各个桶的元素依次取出，从而得到一个有序数组。
+- **树**：例如二叉搜索树、AVL 树、红黑树、B 树、B+ 树等，它们的查找、插入和删除等操作都可以视为分治的应用。
+- **堆**：堆是一种特殊的完全二叉树，其各种操作，如插入、删除和堆化，实际上都隐含了分治的思想。
+- **哈希表**：虽然哈希表来并不直接应用分治，但某些哈希冲突解决策略间接应用了分治策略，例如，链式地址中的长链表会被转化为红黑树，以提升查询效率。
+
+可以看出，**分治是一种“润物细无声”的算法思想**，隐含在各种算法与数据结构之中。

docs/chapter_divide_and_conquer/hanota_problem.md

@@ -0,0 +1,497 @@
+---
+comments: true
+---
+
+# 12.4   汉诺塔问题
+
+在归并排序和构建二叉树中，我们都是将原问题分解为两个规模为原问题一半的子问题。然而对于汉诺塔问题，我们采用不同的分解策略。
+
+!!! question
+
+    给定三根柱子，记为 `A`、`B` 和 `C` 。起始状态下，柱子 `A` 上套着 $n$ 个圆盘，它们从上到下按照从小到大的顺序排列。我们的任务是要把这 $n$ 个圆盘移到柱子 `C` 上，并保持它们的原有顺序不变。在移动圆盘的过程中，需要遵守以下规则。
+    
+    1. 圆盘只能从一个柱子顶部拿出，从另一个柱子顶部放入。
+    2. 每次只能移动一个圆盘。
+    3. 小圆盘必须时刻位于大圆盘之上。
+
+![汉诺塔问题示例](hanota_problem.assets/hanota_example.png)
+
+<p align="center"> 图 12-10 &nbsp; 汉诺塔问题示例 </p>
+
+**我们将规模为 $i$ 的汉诺塔问题记做 $f(i)$** 。例如 $f(3)$ 代表将 $3$ 个圆盘从 `A` 移动至 `C` 的汉诺塔问题。
+
+### 1. &nbsp; 考虑基本情况
+
+如图 12-11 所示，对于问题 $f(1)$ ，即当只有一个圆盘时，我们将它直接从 `A` 移动至 `C` 即可。
+
+=== "<1>"
+    ![规模为 1 问题的解](hanota_problem.assets/hanota_f1_step1.png)
+
+=== "<2>"
+    ![hanota_f1_step2](hanota_problem.assets/hanota_f1_step2.png)
+
+<p align="center"> 图 12-11 &nbsp; 规模为 1 问题的解 </p>
+
+如图 12-12 所示，对于问题 $f(2)$ ，即当有两个圆盘时，**由于要时刻满足小圆盘在大圆盘之上，因此需要借助 `B` 来完成移动**。
+
+1. 先将上面的小圆盘从 `A` 移至 `B` 。
+2. 再将大圆盘从 `A` 移至 `C` 。
+3. 最后将小圆盘从 `B` 移至 `C` 。
+
+=== "<1>"
+    ![规模为 2 问题的解](hanota_problem.assets/hanota_f2_step1.png)
+
+=== "<2>"
+    ![hanota_f2_step2](hanota_problem.assets/hanota_f2_step2.png)
+
+=== "<3>"
+    ![hanota_f2_step3](hanota_problem.assets/hanota_f2_step3.png)
+
+=== "<4>"
+    ![hanota_f2_step4](hanota_problem.assets/hanota_f2_step4.png)
+
+<p align="center"> 图 12-12 &nbsp; 规模为 2 问题的解 </p>
+
+解决问题 $f(2)$ 的过程可总结为：**将两个圆盘借助 `B` 从 `A` 移至 `C`** 。其中，`C` 称为目标柱、`B` 称为缓冲柱。
+
+### 2. &nbsp; 子问题分解
+
+对于问题 $f(3)$ ，即当有三个圆盘时，情况变得稍微复杂了一些。
+
+因为已知 $f(1)$ 和 $f(2)$ 的解，所以我们可从分治角度思考，**将 `A` 顶部的两个圆盘看做一个整体**，执行图 12-13 所示的步骤。这样三个圆盘就被顺利地从 `A` 移动至 `C` 了。
+
+1. 令 `B` 为目标柱、`C` 为缓冲柱，将两个圆盘从 `A` 移动至 `B` 。
+2. 将 `A` 中剩余的一个圆盘从 `A` 直接移动至 `C` 。
+3. 令 `C` 为目标柱、`A` 为缓冲柱，将两个圆盘从 `B` 移动至 `C` 。
+
+=== "<1>"
+    ![规模为 3 问题的解](hanota_problem.assets/hanota_f3_step1.png)
+
+=== "<2>"
+    ![hanota_f3_step2](hanota_problem.assets/hanota_f3_step2.png)
+
+=== "<3>"
+    ![hanota_f3_step3](hanota_problem.assets/hanota_f3_step3.png)
+
+=== "<4>"
+    ![hanota_f3_step4](hanota_problem.assets/hanota_f3_step4.png)
+
+<p align="center"> 图 12-13 &nbsp; 规模为 3 问题的解 </p>
+
+本质上看，**我们将问题 $f(3)$ 划分为两个子问题 $f(2)$ 和子问题 $f(1)$** 。按顺序解决这三个子问题之后，原问题随之得到解决。这说明子问题是独立的，而且解是可以合并的。
+
+至此，我们可总结出图 12-14 所示的汉诺塔问题的分治策略：将原问题 $f(n)$ 划分为两个子问题 $f(n-1)$ 和一个子问题 $f(1)$ ，并按照以下顺序解决这三个子问题。
+
+1. 将 $n-1$ 个圆盘借助 `C` 从 `A` 移至 `B` 。
+2. 将剩余 $1$ 个圆盘从 `A` 直接移至 `C` 。
+3. 将 $n-1$ 个圆盘借助 `A` 从 `B` 移至 `C` 。
+
+对于这两个子问题 $f(n-1)$ ，**可以通过相同的方式进行递归划分**，直至达到最小子问题 $f(1)$ 。而 $f(1)$ 的解是已知的，只需一次移动操作即可。
+
+![汉诺塔问题的分治策略](hanota_problem.assets/hanota_divide_and_conquer.png)
+
+<p align="center"> 图 12-14 &nbsp; 汉诺塔问题的分治策略 </p>
+
+### 3. &nbsp; 代码实现
+
+在代码中，我们声明一个递归函数 `dfs(i, src, buf, tar)` ，它的作用是将柱 `src` 顶部的 $i$ 个圆盘借助缓冲柱 `buf` 移动至目标柱 `tar` 。
+
+=== "Python"
+
+    ```python title="hanota.py"
+    def move(src: list[int], tar: list[int]):
+        """移动一个圆盘"""
+        # 从 src 顶部拿出一个圆盘
+        pan = src.pop()
+        # 将圆盘放入 tar 顶部
+        tar.append(pan)
+
+    def dfs(i: int, src: list[int], buf: list[int], tar: list[int]):
+        """求解汉诺塔：问题 f(i)"""
+        # 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1:
+            move(src, tar)
+            return
+        # 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf)
+        # 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar)
+        # 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar)
+
+    def solve_hanota(A: list[int], B: list[int], C: list[int]):
+        """求解汉诺塔"""
+        n = len(A)
+        # 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C)
+    ```
+
+=== "C++"
+
+    ```cpp title="hanota.cpp"
+    /* 移动一个圆盘 */
+    void move(vector<int> &src, vector<int> &tar) {
+        // 从 src 顶部拿出一个圆盘
+        int pan = src.back();
+        src.pop_back();
+        // 将圆盘放入 tar 顶部
+        tar.push_back(pan);
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
+
+    /* 求解汉诺塔 */
+    void solveHanota(vector<int> &A, vector<int> &B, vector<int> &C) {
+        int n = A.size();
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
+    ```
+
+=== "Java"
+
+    ```java title="hanota.java"
+    /* 移动一个圆盘 */
+    void move(List<Integer> src, List<Integer> tar) {
+        // 从 src 顶部拿出一个圆盘
+        Integer pan = src.remove(src.size() - 1);
+        // 将圆盘放入 tar 顶部
+        tar.add(pan);
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
+
+    /* 求解汉诺塔 */
+    void solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {
+        int n = A.size();
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="hanota.cs"
+    /* 移动一个圆盘 */
+    void Move(List<int> src, List<int> tar) {
+        // 从 src 顶部拿出一个圆盘
+        int pan = src[^1];
+        src.RemoveAt(src.Count - 1);
+        // 将圆盘放入 tar 顶部
+        tar.Add(pan);
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    void Dfs(int i, List<int> src, List<int> buf, List<int> tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            Move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        Dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        Move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        Dfs(i - 1, buf, src, tar);
+    }
+
+    /* 求解汉诺塔 */
+    void SolveHanota(List<int> A, List<int> B, List<int> C) {
+        int n = A.Count;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        Dfs(n, A, B, C);
+    }
+    ```
+
+=== "Go"
+
+    ```go title="hanota.go"
+    /* 移动一个圆盘 */
+    func move(src, tar *list.List) {
+        // 从 src 顶部拿出一个圆盘
+        pan := src.Back()
+        // 将圆盘放入 tar 顶部
+        tar.PushBack(pan.Value)
+        // 移除 src 顶部圆盘
+        src.Remove(pan)
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    func dfsHanota(i int, src, buf, tar *list.List) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1 {
+            move(src, tar)
+            return
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfsHanota(i-1, src, tar, buf)
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar)
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfsHanota(i-1, buf, src, tar)
+    }
+
+    /* 求解汉诺塔 */
+    func solveHanota(A, B, C *list.List) {
+        n := A.Len()
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfsHanota(n, A, B, C)
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="hanota.swift"
+    /* 移动一个圆盘 */
+    func move(src: inout [Int], tar: inout [Int]) {
+        // 从 src 顶部拿出一个圆盘
+        let pan = src.popLast()!
+        // 将圆盘放入 tar 顶部
+        tar.append(pan)
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    func dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1 {
+            move(src: &src, tar: &tar)
+            return
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i: i - 1, src: &src, buf: &tar, tar: &buf)
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src: &src, tar: &tar)
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i: i - 1, src: &buf, buf: &src, tar: &tar)
+    }
+
+    /* 求解汉诺塔 */
+    func solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {
+        let n = A.count
+        // 列表尾部是柱子顶部
+        // 将 src 顶部 n 个圆盘借助 B 移到 C
+        dfs(i: n, src: &A, buf: &B, tar: &C)
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="hanota.js"
+    /* 移动一个圆盘 */
+    function move(src, tar) {
+        // 从 src 顶部拿出一个圆盘
+        const pan = src.pop();
+        // 将圆盘放入 tar 顶部
+        tar.push(pan);
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    function dfs(i, src, buf, tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i === 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
+
+    /* 求解汉诺塔 */
+    function solveHanota(A, B, C) {
+        const n = A.length;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="hanota.ts"
+    /* 移动一个圆盘 */
+    function move(src: number[], tar: number[]): void {
+        // 从 src 顶部拿出一个圆盘
+        const pan = src.pop();
+        // 将圆盘放入 tar 顶部
+        tar.push(pan);
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    function dfs(i: number, src: number[], buf: number[], tar: number[]): void {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i === 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
+
+    /* 求解汉诺塔 */
+    function solveHanota(A: number[], B: number[], C: number[]): void {
+        const n = A.length;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="hanota.dart"
+    /* 移动一个圆盘 */
+    void move(List<int> src, List<int> tar) {
+      // 从 src 顶部拿出一个圆盘
+      int pan = src.removeLast();
+      // 将圆盘放入 tar 顶部
+      tar.add(pan);
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, List<int> src, List<int> buf, List<int> tar) {
+      // 若 src 只剩下一个圆盘，则直接将其移到 tar
+      if (i == 1) {
+        move(src, tar);
+        return;
+      }
+      // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+      dfs(i - 1, src, tar, buf);
+      // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+      move(src, tar);
+      // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+      dfs(i - 1, buf, src, tar);
+    }
+
+    /* 求解汉诺塔 */
+    void solveHanota(List<int> A, List<int> B, List<int> C) {
+      int n = A.length;
+      // 将 A 顶部 n 个圆盘借助 B 移到 C
+      dfs(n, A, B, C);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="hanota.rs"
+    /* 移动一个圆盘 */
+    fn move_pan(src: &mut Vec<i32>, tar: &mut Vec<i32>) {
+        // 从 src 顶部拿出一个圆盘
+        let pan = src.remove(src.len() - 1);
+        // 将圆盘放入 tar 顶部
+        tar.push(pan);
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    fn dfs(i: i32, src: &mut Vec<i32>, buf: &mut Vec<i32>, tar: &mut Vec<i32>) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1 {
+            move_pan(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move_pan(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
+
+    /* 求解汉诺塔 */
+    fn solve_hanota(A: &mut Vec<i32>, B: &mut Vec<i32>, C: &mut Vec<i32>) {
+        let n = A.len() as i32;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
+    ```
+
+=== "C"
+
+    ```c title="hanota.c"
+    /* 移动一个圆盘 */
+    void move(vector *src, vector *tar) {
+        // 从 src 顶部拿出一个圆盘
+        int *panTemp = vectorBack(src);
+        int *pan = malloc(sizeof(int));
+        *pan = *panTemp;
+        vectorPopback(src);
+        // 将圆盘放入 tar 顶部
+        vectorPushback(tar, pan, sizeof(int));
+    }
+
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, vector *src, vector *buf, vector *tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
+
+    /* 求解汉诺塔 */
+    void solveHanota(vector *A, vector *B, vector *C) {
+        int n = A->size;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="hanota.zig"
+    [class]{}-[func]{move}
+
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{solveHanota}
+    ```
+
+如图 12-15 所示，汉诺塔问题形成一个高度为 $n$ 的递归树，每个节点代表一个子问题、对应一个开启的 `dfs()` 函数，**因此时间复杂度为 $O(2^n)$ ，空间复杂度为 $O(n)$** 。
+
+![汉诺塔问题的递归树](hanota_problem.assets/hanota_recursive_tree.png)
+
+<p align="center"> 图 12-15 &nbsp; 汉诺塔问题的递归树 </p>
+
+!!! quote
+
+    汉诺塔问题源自一种古老的传说故事。在古印度的一个寺庙里，僧侣们有三根高大的钻石柱子，以及 $64$ 个大小不一的金圆盘。僧侣们不断地移动原盘，他们相信在最后一个圆盘被正确放置的那一刻，这个世界就会结束。
+
+    然而，即使僧侣们每秒钟移动一次，总共需要大约 $2^{64} \approx 1.84×10^{19}$ 秒，合约 $5850$ 亿年，远远超过了现在对宇宙年龄的估计。所以，倘若这个传说是真的，我们应该不需要担心世界末日的到来。

docs/chapter_divide_and_conquer/index.md

@@ -0,0 +1,26 @@
+---
+comments: true
+icon: material/set-split
+---
+
+# 第 12 章   分治
+
+<div class="center-table" markdown>
+
+![分治](../assets/covers/chapter_divide_and_conquer.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    难题被逐层拆解，每一次的拆解都使它变得更为简单。
+    
+    分而治之揭示了一个重要的事实：从简单做起，一切都不再复杂。
+
+## 本章内容
+
+- [12.1 &nbsp; 分治算法](https://www.hello-algo.com/chapter_divide_and_conquer/divide_and_conquer/)
+- [12.2 &nbsp; 分治搜索策略](https://www.hello-algo.com/chapter_divide_and_conquer/binary_search_recur/)
+- [12.3 &nbsp; 构建树问题](https://www.hello-algo.com/chapter_divide_and_conquer/build_binary_tree_problem/)
+- [12.4 &nbsp; 汉诺塔问题](https://www.hello-algo.com/chapter_divide_and_conquer/hanota_problem/)
+- [12.5 &nbsp; 小结](https://www.hello-algo.com/chapter_divide_and_conquer/summary/)

docs/chapter_divide_and_conquer/summary.md

@@ -0,0 +1,15 @@
+---
+comments: true
+---
+
+# 12.5   小结
+
+- 分治算法是一种常见的算法设计策略，包括分（划分）和治（合并）两个阶段，通常基于递归实现。
+- 判断是否是分治算法问题的依据包括：问题能否被分解、子问题是否独立、子问题是否可以被合并。
+- 归并排序是分治策略的典型应用，其递归地将数组划分为等长的两个子数组，直到只剩一个元素时开始逐层合并，从而完成排序。
+- 引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了操作数量；另一方面，分治后有利于系统的并行优化。
+- 分治既可以解决许多算法问题，也广泛应用于数据结构与算法设计中，处处可见其身影。
+- 相较于暴力搜索，自适应搜索效率更高。时间复杂度为 $O(\log n)$ 的搜索算法通常都是基于分治策略实现的。
+- 二分查找是分治策略的另一个典型应用，它不包含将子问题的解进行合并的步骤。我们可以通过递归分治实现二分查找。
+- 在构建二叉树问题中，构建树（原问题）可以被划分为构建左子树和右子树（子问题），其可以通过划分前序遍历和中序遍历的索引区间来实现。
+- 在汉诺塔问题中，一个规模为 $n$ 的问题可以被划分为两个规模为 $n-1$ 的子问题和一个规模为 $1$ 的子问题。按顺序解决这三个子问题后，原问题随之得到解决。

docs/chapter_dynamic_programming/dp_problem_features.md

@@ -0,0 +1,847 @@
+---
+comments: true
+---
+
+# 14.2   动态规划问题特性
+
+在上节中，我们学习了动态规划是如何通过子问题分解来求解问题的。实际上，子问题分解是一种通用的算法思路，在分治、动态规划、回溯中的侧重点不同。
+
+- 分治算法递归地将原问题划分为多个相互独立的子问题，直至最小子问题，并在回溯中合并子问题的解，最终得到原问题的解。
+- 动态规划也对问题进行递归分解，但与分治算法的主要区别是，动态规划中的子问题是相互依赖的，在分解过程中会出现许多重叠子问题。
+- 回溯算法在尝试和回退中穷举所有可能的解，并通过剪枝避免不必要的搜索分支。原问题的解由一系列决策步骤构成，我们可以将每个决策步骤之前的子序列看作为一个子问题。
+
+实际上，动态规划常用来求解最优化问题，它们不仅包含重叠子问题，还具有另外两大特性：最优子结构、无后效性。
+
+## 14.2.1   最优子结构
+
+我们对爬楼梯问题稍作改动，使之更加适合展示最优子结构概念。
+
+!!! question "爬楼梯最小代价"
+
+    给定一个楼梯，你每步可以上 $1$ 阶或者 $2$ 阶，每一阶楼梯上都贴有一个非负整数，表示你在该台阶所需要付出的代价。给定一个非负整数数组 $cost$ ，其中 $cost[i]$ 表示在第 $i$ 个台阶需要付出的代价，$cost[0]$ 为地面起始点。请计算最少需要付出多少代价才能到达顶部？
+
+如图 14-6 所示，若第 $1$、$2$、$3$ 阶的代价分别为 $1$、$10$、$1$ ，则从地面爬到第 $3$ 阶的最小代价为 $2$ 。
+
+![爬到第 3 阶的最小代价](dp_problem_features.assets/min_cost_cs_example.png)
+
+<p align="center"> 图 14-6 &nbsp; 爬到第 3 阶的最小代价 </p>
+
+设 $dp[i]$ 为爬到第 $i$ 阶累计付出的代价，由于第 $i$ 阶只可能从 $i - 1$ 阶或 $i - 2$ 阶走来，因此 $dp[i]$ 只可能等于 $dp[i - 1] + cost[i]$ 或 $dp[i - 2] + cost[i]$ 。为了尽可能减少代价，我们应该选择两者中较小的那一个：
+
+$$
+dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
+$$
+
+这便可以引出最优子结构的含义：**原问题的最优解是从子问题的最优解构建得来的**。
+
+本题显然具有最优子结构：我们从两个子问题最优解 $dp[i-1]$ 和 $dp[i-2]$ 中挑选出较优的那一个，并用它构建出原问题 $dp[i]$ 的最优解。
+
+那么，上节的爬楼梯题目有没有最优子结构呢？它的目标是求解方案数量，看似是一个计数问题，但如果换一种问法：“求解最大方案数量”。我们意外地发现，**虽然题目修改前后是等价的，但最优子结构浮现出来了**：第 $n$ 阶最大方案数量等于第 $n-1$ 阶和第 $n-2$ 阶最大方案数量之和。所以说，最优子结构的解释方式比较灵活，在不同问题中会有不同的含义。
+
+根据状态转移方程，以及初始状态 $dp[1] = cost[1]$ 和 $dp[2] = cost[2]$ ，我们就可以得到动态规划代码。
+
+=== "Python"
+
+    ```python title="min_cost_climbing_stairs_dp.py"
+    def min_cost_climbing_stairs_dp(cost: list[int]) -> int:
+        """爬楼梯最小代价：动态规划"""
+        n = len(cost) - 1
+        if n == 1 or n == 2:
+            return cost[n]
+        # 初始化 dp 表，用于存储子问题的解
+        dp = [0] * (n + 1)
+        # 初始状态：预设最小子问题的解
+        dp[1], dp[2] = cost[1], cost[2]
+        # 状态转移：从较小子问题逐步求解较大子问题
+        for i in range(3, n + 1):
+            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
+        return dp[n]
+    ```
+
+=== "C++"
+
+    ```cpp title="min_cost_climbing_stairs_dp.cpp"
+    /* 爬楼梯最小代价：动态规划 */
+    int minCostClimbingStairsDP(vector<int> &cost) {
+        int n = cost.size() - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // 初始化 dp 表，用于存储子问题的解
+        vector<int> dp(n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+    ```
+
+=== "Java"
+
+    ```java title="min_cost_climbing_stairs_dp.java"
+    /* 爬楼梯最小代价：动态规划 */
+    int minCostClimbingStairsDP(int[] cost) {
+        int n = cost.length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // 初始化 dp 表，用于存储子问题的解
+        int[] dp = new int[n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="min_cost_climbing_stairs_dp.cs"
+    /* 爬楼梯最小代价：动态规划 */
+    int MinCostClimbingStairsDP(int[] cost) {
+        int n = cost.Length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // 初始化 dp 表，用于存储子问题的解
+        int[] dp = new int[n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+    ```
+
+=== "Go"
+
+    ```go title="min_cost_climbing_stairs_dp.go"
+    /* 爬楼梯最小代价：动态规划 */
+    func minCostClimbingStairsDP(cost []int) int {
+        n := len(cost) - 1
+        if n == 1 || n == 2 {
+            return cost[n]
+        }
+        min := func(a, b int) int {
+            if a < b {
+                return a
+            }
+            return b
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        dp := make([]int, n+1)
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1]
+        dp[2] = cost[2]
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i := 3; i <= n; i++ {
+            dp[i] = min(dp[i-1], dp[i-2]) + cost[i]
+        }
+        return dp[n]
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="min_cost_climbing_stairs_dp.swift"
+    /* 爬楼梯最小代价：动态规划 */
+    func minCostClimbingStairsDP(cost: [Int]) -> Int {
+        let n = cost.count - 1
+        if n == 1 || n == 2 {
+            return cost[n]
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        var dp = Array(repeating: 0, count: n + 1)
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1]
+        dp[2] = cost[2]
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i in stride(from: 3, through: n, by: 1) {
+            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
+        }
+        return dp[n]
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="min_cost_climbing_stairs_dp.js"
+    /* 爬楼梯最小代价：动态规划 */
+    function minCostClimbingStairsDP(cost) {
+        const n = cost.length - 1;
+        if (n === 1 || n === 2) {
+            return cost[n];
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        const dp = new Array(n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (let i = 3; i <= n; i++) {
+            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="min_cost_climbing_stairs_dp.ts"
+    /* 爬楼梯最小代价：动态规划 */
+    function minCostClimbingStairsDP(cost: Array<number>): number {
+        const n = cost.length - 1;
+        if (n === 1 || n === 2) {
+            return cost[n];
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        const dp = new Array(n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (let i = 3; i <= n; i++) {
+            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="min_cost_climbing_stairs_dp.dart"
+    /* 爬楼梯最小代价：动态规划 */
+    int minCostClimbingStairsDP(List<int> cost) {
+      int n = cost.length - 1;
+      if (n == 1 || n == 2) return cost[n];
+      // 初始化 dp 表，用于存储子问题的解
+      List<int> dp = List.filled(n + 1, 0);
+      // 初始状态：预设最小子问题的解
+      dp[1] = cost[1];
+      dp[2] = cost[2];
+      // 状态转移：从较小子问题逐步求解较大子问题
+      for (int i = 3; i <= n; i++) {
+        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
+      }
+      return dp[n];
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="min_cost_climbing_stairs_dp.rs"
+    /* 爬楼梯最小代价：动态规划 */
+    fn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {
+        let n = cost.len() - 1;
+        if n == 1 || n == 2 { return cost[n]; }
+        // 初始化 dp 表，用于存储子问题的解
+        let mut dp = vec![-1; n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i in 3..=n {
+            dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        dp[n]
+    }
+    ```
+
+=== "C"
+
+    ```c title="min_cost_climbing_stairs_dp.c"
+    /* 爬楼梯最小代价：动态规划 */
+    int minCostClimbingStairsDP(int cost[], int costSize) {
+        int n = costSize - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // 初始化 dp 表，用于存储子问题的解
+        int dp[n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="min_cost_climbing_stairs_dp.zig"
+    // 爬楼梯最小代价：动态规划
+    fn minCostClimbingStairsDP(comptime cost: []i32) i32 {
+        comptime var n = cost.len - 1;
+        if (n == 1 or n == 2) {
+            return cost[n];
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        var dp = [_]i32{-1} ** (n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (3..n + 1) |i| {
+            dp[i] = @min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+    ```
+
+图 14-7 展示了以上代码的动态规划过程。
+
+![爬楼梯最小代价的动态规划过程](dp_problem_features.assets/min_cost_cs_dp.png)
+
+<p align="center"> 图 14-7 &nbsp; 爬楼梯最小代价的动态规划过程 </p>
+
+本题也可以进行空间优化，将一维压缩至零维，使得空间复杂度从 $O(n)$ 降低至 $O(1)$ 。
+
+=== "Python"
+
+    ```python title="min_cost_climbing_stairs_dp.py"
+    def min_cost_climbing_stairs_dp_comp(cost: list[int]) -> int:
+        """爬楼梯最小代价：空间优化后的动态规划"""
+        n = len(cost) - 1
+        if n == 1 or n == 2:
+            return cost[n]
+        a, b = cost[1], cost[2]
+        for i in range(3, n + 1):
+            a, b = b, min(a, b) + cost[i]
+        return b
+    ```
+
+=== "C++"
+
+    ```cpp title="min_cost_climbing_stairs_dp.cpp"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int minCostClimbingStairsDPComp(vector<int> &cost) {
+        int n = cost.size() - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="min_cost_climbing_stairs_dp.java"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int minCostClimbingStairsDPComp(int[] cost) {
+        int n = cost.length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = Math.min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="min_cost_climbing_stairs_dp.cs"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int MinCostClimbingStairsDPComp(int[] cost) {
+        int n = cost.Length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = Math.Min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="min_cost_climbing_stairs_dp.go"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    func minCostClimbingStairsDPComp(cost []int) int {
+        n := len(cost) - 1
+        if n == 1 || n == 2 {
+            return cost[n]
+        }
+        min := func(a, b int) int {
+            if a < b {
+                return a
+            }
+            return b
+        }
+        // 初始状态：预设最小子问题的解
+        a, b := cost[1], cost[2]
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i := 3; i <= n; i++ {
+            tmp := b
+            b = min(a, tmp) + cost[i]
+            a = tmp
+        }
+        return b
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="min_cost_climbing_stairs_dp.swift"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    func minCostClimbingStairsDPComp(cost: [Int]) -> Int {
+        let n = cost.count - 1
+        if n == 1 || n == 2 {
+            return cost[n]
+        }
+        var (a, b) = (cost[1], cost[2])
+        for i in stride(from: 3, through: n, by: 1) {
+            (a, b) = (b, min(a, b) + cost[i])
+        }
+        return b
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="min_cost_climbing_stairs_dp.js"
+    /* 爬楼梯最小代价：状态压缩后的动态规划 */
+    function minCostClimbingStairsDPComp(cost) {
+        const n = cost.length - 1;
+        if (n === 1 || n === 2) {
+            return cost[n];
+        }
+        let a = cost[1],
+            b = cost[2];
+        for (let i = 3; i <= n; i++) {
+            const tmp = b;
+            b = Math.min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="min_cost_climbing_stairs_dp.ts"
+    /* 爬楼梯最小代价：状态压缩后的动态规划 */
+    function minCostClimbingStairsDPComp(cost: Array<number>): number {
+        const n = cost.length - 1;
+        if (n === 1 || n === 2) {
+            return cost[n];
+        }
+        let a = cost[1],
+            b = cost[2];
+        for (let i = 3; i <= n; i++) {
+            const tmp = b;
+            b = Math.min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="min_cost_climbing_stairs_dp.dart"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int minCostClimbingStairsDPComp(List<int> cost) {
+      int n = cost.length - 1;
+      if (n == 1 || n == 2) return cost[n];
+      int a = cost[1], b = cost[2];
+      for (int i = 3; i <= n; i++) {
+        int tmp = b;
+        b = min(a, tmp) + cost[i];
+        a = tmp;
+      }
+      return b;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="min_cost_climbing_stairs_dp.rs"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    fn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {
+        let n = cost.len() - 1;
+        if n == 1 || n == 2 { return cost[n] };
+        let (mut a, mut b) = (cost[1], cost[2]);
+        for i in 3..=n {
+            let tmp = b;
+            b = cmp::min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        b
+    }
+    ```
+
+=== "C"
+
+    ```c title="min_cost_climbing_stairs_dp.c"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int minCostClimbingStairsDPComp(int cost[], int costSize) {
+        int n = costSize - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="min_cost_climbing_stairs_dp.zig"
+    // 爬楼梯最小代价：空间优化后的动态规划
+    fn minCostClimbingStairsDPComp(cost: []i32) i32 {
+        var n = cost.len - 1;
+        if (n == 1 or n == 2) {
+            return cost[n];
+        }
+        var a = cost[1];
+        var b = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (3..n + 1) |i| {
+            var tmp = b;
+            b = @min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+    ```
+
+## 14.2.2 &nbsp; 无后效性
+
+无后效性是动态规划能够有效解决问题的重要特性之一，定义为：**给定一个确定的状态，它的未来发展只与当前状态有关，而与当前状态过去所经历过的所有状态无关**。
+
+以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无须考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。
+
+然而，如果我们向爬楼梯问题添加一个约束，情况就不一样了。
+
+!!! question "带约束爬楼梯"
+
+    给定一个共有 $n$ 阶的楼梯，你每步可以上 $1$ 阶或者 $2$ 阶，**但不能连续两轮跳 $1$ 阶**，请问有多少种方案可以爬到楼顶。
+
+例如图 14-8 ，爬上第 $3$ 阶仅剩 $2$ 种可行方案，其中连续三次跳 $1$ 阶的方案不满足约束条件，因此被舍弃。
+
+![带约束爬到第 3 阶的方案数量](dp_problem_features.assets/climbing_stairs_constraint_example.png)
+
+<p align="center"> 图 14-8 &nbsp; 带约束爬到第 3 阶的方案数量 </p>
+
+在该问题中，如果上一轮是跳 $1$ 阶上来的，那么下一轮就必须跳 $2$ 阶。这意味着，**下一步选择不能由当前状态（当前楼梯阶数）独立决定，还和前一个状态（上轮楼梯阶数）有关**。
+
+不难发现，此问题已不满足无后效性，状态转移方程 $dp[i] = dp[i-1] + dp[i-2]$ 也失效了，因为 $dp[i-1]$ 代表本轮跳 $1$ 阶，但其中包含了许多“上一轮跳 $1$ 阶上来的”方案，而为了满足约束，我们就不能将 $dp[i-1]$ 直接计入 $dp[i]$ 中。
+
+为此，我们需要扩展状态定义：**状态 $[i, j]$ 表示处在第 $i$ 阶、并且上一轮跳了 $j$ 阶**，其中 $j \in \{1, 2\}$ 。此状态定义有效地区分了上一轮跳了 $1$ 阶还是 $2$ 阶，我们可以据此来判断当前状态是从何而来的。
+
+- 当上一轮跳了 $1$ 阶时，上上一轮只能选择跳 $2$ 阶，即 $dp[i, 1]$ 只能从 $dp[i-1, 2]$ 转移过来。
+- 当上一轮跳了 $2$ 阶时，上上一轮可选择跳 $1$ 阶或跳 $2$ 阶，即 $dp[i, 2]$ 可以从 $dp[i-2, 1]$ 或 $dp[i-2, 2]$ 转移过来。
+
+如图 14-9 所示，在该定义下，$dp[i, j]$ 表示状态 $[i, j]$ 对应的方案数。此时状态转移方程为：
+
+$$
+\begin{cases}
+dp[i, 1] = dp[i-1, 2] \\
+dp[i, 2] = dp[i-2, 1] + dp[i-2, 2]
+\end{cases}
+$$
+
+![考虑约束下的递推关系](dp_problem_features.assets/climbing_stairs_constraint_state_transfer.png)
+
+<p align="center"> 图 14-9 &nbsp; 考虑约束下的递推关系 </p>
+
+最终，返回 $dp[n, 1] + dp[n, 2]$ 即可，两者之和代表爬到第 $n$ 阶的方案总数。
+
+=== "Python"
+
+    ```python title="climbing_stairs_constraint_dp.py"
+    def climbing_stairs_constraint_dp(n: int) -> int:
+        """带约束爬楼梯：动态规划"""
+        if n == 1 or n == 2:
+            return 1
+        # 初始化 dp 表，用于存储子问题的解
+        dp = [[0] * 3 for _ in range(n + 1)]
+        # 初始状态：预设最小子问题的解
+        dp[1][1], dp[1][2] = 1, 0
+        dp[2][1], dp[2][2] = 0, 1
+        # 状态转移：从较小子问题逐步求解较大子问题
+        for i in range(3, n + 1):
+            dp[i][1] = dp[i - 1][2]
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2]
+        return dp[n][1] + dp[n][2]
+    ```
+
+=== "C++"
+
+    ```cpp title="climbing_stairs_constraint_dp.cpp"
+    /* 带约束爬楼梯：动态规划 */
+    int climbingStairsConstraintDP(int n) {
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        vector<vector<int>> dp(n + 1, vector<int>(3, 0));
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
+    ```
+
+=== "Java"
+
+    ```java title="climbing_stairs_constraint_dp.java"
+    /* 带约束爬楼梯：动态规划 */
+    int climbingStairsConstraintDP(int n) {
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        int[][] dp = new int[n + 1][3];
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="climbing_stairs_constraint_dp.cs"
+    /* 带约束爬楼梯：动态规划 */
+    int ClimbingStairsConstraintDP(int n) {
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        int[,] dp = new int[n + 1, 3];
+        // 初始状态：预设最小子问题的解
+        dp[1, 1] = 1;
+        dp[1, 2] = 0;
+        dp[2, 1] = 0;
+        dp[2, 2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i, 1] = dp[i - 1, 2];
+            dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];
+        }
+        return dp[n, 1] + dp[n, 2];
+    }
+    ```
+
+=== "Go"
+
+    ```go title="climbing_stairs_constraint_dp.go"
+    /* 带约束爬楼梯：动态规划 */
+    func climbingStairsConstraintDP(n int) int {
+        if n == 1 || n == 2 {
+            return 1
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        dp := make([][3]int, n+1)
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1
+        dp[1][2] = 0
+        dp[2][1] = 0
+        dp[2][2] = 1
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i := 3; i <= n; i++ {
+            dp[i][1] = dp[i-1][2]
+            dp[i][2] = dp[i-2][1] + dp[i-2][2]
+        }
+        return dp[n][1] + dp[n][2]
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="climbing_stairs_constraint_dp.swift"
+    /* 带约束爬楼梯：动态规划 */
+    func climbingStairsConstraintDP(n: Int) -> Int {
+        if n == 1 || n == 2 {
+            return 1
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1
+        dp[1][2] = 0
+        dp[2][1] = 0
+        dp[2][2] = 1
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i in stride(from: 3, through: n, by: 1) {
+            dp[i][1] = dp[i - 1][2]
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2]
+        }
+        return dp[n][1] + dp[n][2]
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="climbing_stairs_constraint_dp.js"
+    /* 带约束爬楼梯：动态规划 */
+    function climbingStairsConstraintDP(n) {
+        if (n === 1 || n === 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        const dp = Array.from(new Array(n + 1), () => new Array(3));
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (let i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="climbing_stairs_constraint_dp.ts"
+    /* 带约束爬楼梯：动态规划 */
+    function climbingStairsConstraintDP(n: number): number {
+        if (n === 1 || n === 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        const dp = Array.from({ length: n + 1 }, () => new Array(3));
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (let i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="climbing_stairs_constraint_dp.dart"
+    /* 带约束爬楼梯：动态规划 */
+    int climbingStairsConstraintDP(int n) {
+      if (n == 1 || n == 2) {
+        return 1;
+      }
+      // 初始化 dp 表，用于存储子问题的解
+      List<List<int>> dp = List.generate(n + 1, (index) => List.filled(3, 0));
+      // 初始状态：预设最小子问题的解
+      dp[1][1] = 1;
+      dp[1][2] = 0;
+      dp[2][1] = 0;
+      dp[2][2] = 1;
+      // 状态转移：从较小子问题逐步求解较大子问题
+      for (int i = 3; i <= n; i++) {
+        dp[i][1] = dp[i - 1][2];
+        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+      }
+      return dp[n][1] + dp[n][2];
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="climbing_stairs_constraint_dp.rs"
+    /* 带约束爬楼梯：动态规划 */
+    fn climbing_stairs_constraint_dp(n: usize) -> i32 {
+        if n == 1 || n == 2 { return 1 };
+        // 初始化 dp 表，用于存储子问题的解
+        let mut dp = vec![vec![-1; 3]; n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i in 3..=n {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        dp[n][1] + dp[n][2]
+    }
+    ```
+
+=== "C"
+
+    ```c title="climbing_stairs_constraint_dp.c"
+    [class]{}-[func]{climbingStairsConstraintDP}
+    ```
+
+=== "Zig"
+
+    ```zig title="climbing_stairs_constraint_dp.zig"
+    // 带约束爬楼梯：动态规划
+    fn climbingStairsConstraintDP(comptime n: usize) i32 {
+        if (n == 1 or n == 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        var dp = [_][3]i32{ [_]i32{ -1, -1, -1 } } ** (n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (3..n + 1) |i| {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
+    ```
+
+在上面的案例中，由于仅需多考虑前面一个状态，我们仍然可以通过扩展状态定义，使得问题重新满足无后效性。然而，某些问题具有非常严重的“有后效性”。
+
+!!! question "爬楼梯与障碍生成"
+
+    给定一个共有 $n$ 阶的楼梯，你每步可以上 $1$ 阶或者 $2$ 阶。**规定当爬到第 $i$ 阶时，系统自动会给第 $2i$ 阶上放上障碍物，之后所有轮都不允许跳到第 $2i$ 阶上**。例如，前两轮分别跳到了第 $2$、$3$ 阶上，则之后就不能跳到第 $4$、$6$ 阶上。请问有多少种方案可以爬到楼顶。
+
+在这个问题中，下次跳跃依赖于过去所有的状态，因为每一次跳跃都会在更高的阶梯上设置障碍，并影响未来的跳跃。对于这类问题，动态规划往往难以解决。
+
+实际上，许多复杂的组合优化问题（例如旅行商问题）都不满足无后效性。对于这类问题，我们通常会选择使用其他方法，例如启发式搜索、遗传算法、强化学习等，从而在有限时间内得到可用的局部最优解。

docs/chapter_dynamic_programming/edit_distance_problem.md

@@ -0,0 +1,850 @@
+---
+comments: true
+---
+
+# 14.6   编辑距离问题
+
+编辑距离，也被称为 Levenshtein 距离，指两个字符串之间互相转换的最小修改次数，通常用于在信息检索和自然语言处理中度量两个序列的相似度。
+
+!!! question
+
+    输入两个字符串 $s$ 和 $t$ ，返回将 $s$ 转换为 $t$ 所需的最少编辑步数。
+    
+    你可以在一个字符串中进行三种编辑操作：插入一个字符、删除一个字符、替换字符为任意一个字符。
+
+如图 14-27 所示，将 `kitten` 转换为 `sitting` 需要编辑 3 步，包括 2 次替换操作与 1 次添加操作；将 `hello` 转换为 `algo` 需要 3 步，包括 2 次替换操作和 1 次删除操作。
+
+![编辑距离的示例数据](edit_distance_problem.assets/edit_distance_example.png)
+
+<p align="center"> 图 14-27 &nbsp; 编辑距离的示例数据 </p>
+
+**编辑距离问题可以很自然地用决策树模型来解释**。字符串对应树节点，一轮决策（一次编辑操作）对应树的一条边。
+
+如图 14-28 所示，在不限制操作的情况下，每个节点都可以派生出许多条边，每条边对应一种操作，这意味着从 `hello` 转换到 `algo` 有许多种可能的路径。
+
+从决策树的角度看，本题的目标是求解节点 `hello` 和节点 `algo` 之间的最短路径。
+
+![基于决策树模型表示编辑距离问题](edit_distance_problem.assets/edit_distance_decision_tree.png)
+
+<p align="center"> 图 14-28 &nbsp; 基于决策树模型表示编辑距离问题 </p>
+
+### 1. &nbsp; 动态规划思路
+
+**第一步：思考每轮的决策，定义状态，从而得到 $dp$ 表**
+
+每一轮的决策是对字符串 $s$ 进行一次编辑操作。
+
+我们希望在编辑操作的过程中，问题的规模逐渐缩小，这样才能构建子问题。设字符串 $s$ 和 $t$ 的长度分别为 $n$ 和 $m$ ，我们先考虑两字符串尾部的字符 $s[n-1]$ 和 $t[m-1]$ 。
+
+- 若 $s[n-1]$ 和 $t[m-1]$ 相同，我们可以跳过它们，直接考虑 $s[n-2]$ 和 $t[m-2]$ 。
+- 若 $s[n-1]$ 和 $t[m-1]$ 不同，我们需要对 $s$ 进行一次编辑（插入、删除、替换），使得两字符串尾部的字符相同，从而可以跳过它们，考虑规模更小的问题。
+
+也就是说，我们在字符串 $s$ 中进行的每一轮决策（编辑操作），都会使得 $s$ 和 $t$ 中剩余的待匹配字符发生变化。因此，状态为当前在 $s$ 和 $t$ 中考虑的第 $i$ 和 $j$ 个字符，记为 $[i, j]$ 。
+
+状态 $[i, j]$ 对应的子问题：**将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数**。
+
+至此，得到一个尺寸为 $(i+1) \times (j+1)$ 的二维 $dp$ 表。
+
+**第二步：找出最优子结构，进而推导出状态转移方程**
+
+考虑子问题 $dp[i, j]$ ，其对应的两个字符串的尾部字符为 $s[i-1]$ 和 $t[j-1]$ ，可根据不同编辑操作分为图 14-29 所示的三种情况。
+
+1. 在 $s[i-1]$ 之后添加 $t[j-1]$ ，则剩余子问题 $dp[i, j-1]$ 。
+2. 删除 $s[i-1]$ ，则剩余子问题 $dp[i-1, j]$ 。
+3. 将 $s[i-1]$ 替换为 $t[j-1]$ ，则剩余子问题 $dp[i-1, j-1]$ 。
+
+![编辑距离的状态转移](edit_distance_problem.assets/edit_distance_state_transfer.png)
+
+<p align="center"> 图 14-29 &nbsp; 编辑距离的状态转移 </p>
+
+根据以上分析，可得最优子结构：$dp[i, j]$ 的最少编辑步数等于 $dp[i, j-1]$、$dp[i-1, j]$、$dp[i-1, j-1]$ 三者中的最少编辑步数，再加上本次的编辑步数 $1$ 。对应的状态转移方程为：
+
+$$
+dp[i, j] = \min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1
+$$
+
+请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无须编辑当前字符**，这种情况下的状态转移方程为：
+
+$$
+dp[i, j] = dp[i-1, j-1]
+$$
+
+**第三步：确定边界条件和状态转移顺序**
+
+当两字符串都为空时，编辑步数为 $0$ ，即 $dp[0, 0] = 0$ 。当 $s$ 为空但 $t$ 不为空时，最少编辑步数等于 $t$ 的长度，即首行 $dp[0, j] = j$ 。当 $s$ 不为空但 $t$ 为空时，等于 $s$ 的长度，即首列 $dp[i, 0] = i$ 。
+
+观察状态转移方程，解 $dp[i, j]$ 依赖左方、上方、左上方的解，因此通过两层循环正序遍历整个 $dp$ 表即可。
+
+### 2. &nbsp; 代码实现
+
+=== "Python"
+
+    ```python title="edit_distance.py"
+    def edit_distance_dp(s: str, t: str) -> int:
+        """编辑距离：动态规划"""
+        n, m = len(s), len(t)
+        dp = [[0] * (m + 1) for _ in range(n + 1)]
+        # 状态转移：首行首列
+        for i in range(1, n + 1):
+            dp[i][0] = i
+        for j in range(1, m + 1):
+            dp[0][j] = j
+        # 状态转移：其余行列
+        for i in range(1, n + 1):
+            for j in range(1, m + 1):
+                if s[i - 1] == t[j - 1]:
+                    # 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1]
+                else:
+                    # 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1
+        return dp[n][m]
+    ```
+
+=== "C++"
+
+    ```cpp title="edit_distance.cpp"
+    /* 编辑距离：动态规划 */
+    int editDistanceDP(string s, string t) {
+        int n = s.length(), m = t.length();
+        vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
+        // 状态转移：首行首列
+        for (int i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (int j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
+    ```
+
+=== "Java"
+
+    ```java title="edit_distance.java"
+    /* 编辑距离：动态规划 */
+    int editDistanceDP(String s, String t) {
+        int n = s.length(), m = t.length();
+        int[][] dp = new int[n + 1][m + 1];
+        // 状态转移：首行首列
+        for (int i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (int j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="edit_distance.cs"
+    /* 编辑距离：动态规划 */
+    int EditDistanceDP(string s, string t) {
+        int n = s.Length, m = t.Length;
+        int[,] dp = new int[n + 1, m + 1];
+        // 状态转移：首行首列
+        for (int i = 1; i <= n; i++) {
+            dp[i, 0] = i;
+        }
+        for (int j = 1; j <= m; j++) {
+            dp[0, j] = j;
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i, j] = dp[i - 1, j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n, m];
+    }
+    ```
+
+=== "Go"
+
+    ```go title="edit_distance.go"
+    /* 编辑距离：动态规划 */
+    func editDistanceDP(s string, t string) int {
+        n := len(s)
+        m := len(t)
+        dp := make([][]int, n+1)
+        for i := 0; i <= n; i++ {
+            dp[i] = make([]int, m+1)
+        }
+        // 状态转移：首行首列
+        for i := 1; i <= n; i++ {
+            dp[i][0] = i
+        }
+        for j := 1; j <= m; j++ {
+            dp[0][j] = j
+        }
+        // 状态转移：其余行列
+        for i := 1; i <= n; i++ {
+            for j := 1; j <= m; j++ {
+                if s[i-1] == t[j-1] {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i-1][j-1]
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1
+                }
+            }
+        }
+        return dp[n][m]
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="edit_distance.swift"
+    /* 编辑距离：动态规划 */
+    func editDistanceDP(s: String, t: String) -> Int {
+        let n = s.utf8CString.count
+        let m = t.utf8CString.count
+        var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)
+        // 状态转移：首行首列
+        for i in stride(from: 1, through: n, by: 1) {
+            dp[i][0] = i
+        }
+        for j in stride(from: 1, through: m, by: 1) {
+            dp[0][j] = j
+        }
+        // 状态转移：其余行列
+        for i in stride(from: 1, through: n, by: 1) {
+            for j in stride(from: 1, through: m, by: 1) {
+                if s.utf8CString[i - 1] == t.utf8CString[j - 1] {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1]
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1
+                }
+            }
+        }
+        return dp[n][m]
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="edit_distance.js"
+    /* 编辑距离：动态规划 */
+    function editDistanceDP(s, t) {
+        const n = s.length,
+            m = t.length;
+        const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+        // 状态转移：首行首列
+        for (let i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (let j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // 状态转移：其余行列
+        for (let i = 1; i <= n; i++) {
+            for (let j = 1; j <= m; j++) {
+                if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] =
+                        Math.min(
+                            Math.min(dp[i][j - 1], dp[i - 1][j]),
+                            dp[i - 1][j - 1]
+                        ) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="edit_distance.ts"
+    /* 编辑距离：动态规划 */
+    function editDistanceDP(s: string, t: string): number {
+        const n = s.length,
+            m = t.length;
+        const dp = Array.from({ length: n + 1 }, () =>
+            Array.from({ length: m + 1 }, () => 0)
+        );
+        // 状态转移：首行首列
+        for (let i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (let j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // 状态转移：其余行列
+        for (let i = 1; i <= n; i++) {
+            for (let j = 1; j <= m; j++) {
+                if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] =
+                        Math.min(
+                            Math.min(dp[i][j - 1], dp[i - 1][j]),
+                            dp[i - 1][j - 1]
+                        ) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="edit_distance.dart"
+    /* 编辑距离：动态规划 */
+    int editDistanceDP(String s, String t) {
+      int n = s.length, m = t.length;
+      List<List<int>> dp = List.generate(n + 1, (_) => List.filled(m + 1, 0));
+      // 状态转移：首行首列
+      for (int i = 1; i <= n; i++) {
+        dp[i][0] = i;
+      }
+      for (int j = 1; j <= m; j++) {
+        dp[0][j] = j;
+      }
+      // 状态转移：其余行列
+      for (int i = 1; i <= n; i++) {
+        for (int j = 1; j <= m; j++) {
+          if (s[i - 1] == t[j - 1]) {
+            // 若两字符相等，则直接跳过此两字符
+            dp[i][j] = dp[i - 1][j - 1];
+          } else {
+            // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+            dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+          }
+        }
+      }
+      return dp[n][m];
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="edit_distance.rs"
+    /* 编辑距离：动态规划 */
+    fn edit_distance_dp(s: &str, t: &str) -> i32 {
+        let (n, m) = (s.len(), t.len());
+        let mut dp = vec![vec![0; m + 1]; n + 1];
+        // 状态转移：首行首列
+        for i in 1..= n {
+            dp[i][0] = i as i32;
+        }
+        for j in 1..m {
+            dp[0][j] = j as i32;
+        }
+        // 状态转移：其余行列
+        for i in 1..=n {
+            for j in 1..=m {
+                if s.chars().nth(i - 1) == t.chars().nth(j - 1) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        dp[n][m]
+    }
+    ```
+
+=== "C"
+
+    ```c title="edit_distance.c"
+    [class]{}-[func]{editDistanceDP}
+    ```
+
+=== "Zig"
+
+    ```zig title="edit_distance.zig"
+    // 编辑距离：动态规划
+    fn editDistanceDP(comptime s: []const u8, comptime t: []const u8) i32 {
+        comptime var n = s.len;
+        comptime var m = t.len;
+        var dp = [_][m + 1]i32{[_]i32{0} ** (m + 1)} ** (n + 1);
+        // 状态转移：首行首列
+        for (1..n + 1) |i| {
+            dp[i][0] = @intCast(i);
+        }
+        for (1..m + 1) |j| {
+            dp[0][j] = @intCast(j);
+        }
+        // 状态转移：其余行列
+        for (1..n + 1) |i| {
+            for (1..m + 1) |j| {
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = @min(@min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
+    ```
+
+如图 14-30 所示，编辑距离问题的状态转移过程与背包问题非常类似，都可以看作是填写一个二维网格的过程。
+
+=== "<1>"
+    ![编辑距离的动态规划过程](edit_distance_problem.assets/edit_distance_dp_step1.png)
+
+=== "<2>"
+    ![edit_distance_dp_step2](edit_distance_problem.assets/edit_distance_dp_step2.png)
+
+=== "<3>"
+    ![edit_distance_dp_step3](edit_distance_problem.assets/edit_distance_dp_step3.png)
+
+=== "<4>"
+    ![edit_distance_dp_step4](edit_distance_problem.assets/edit_distance_dp_step4.png)
+
+=== "<5>"
+    ![edit_distance_dp_step5](edit_distance_problem.assets/edit_distance_dp_step5.png)
+
+=== "<6>"
+    ![edit_distance_dp_step6](edit_distance_problem.assets/edit_distance_dp_step6.png)
+
+=== "<7>"
+    ![edit_distance_dp_step7](edit_distance_problem.assets/edit_distance_dp_step7.png)
+
+=== "<8>"
+    ![edit_distance_dp_step8](edit_distance_problem.assets/edit_distance_dp_step8.png)
+
+=== "<9>"
+    ![edit_distance_dp_step9](edit_distance_problem.assets/edit_distance_dp_step9.png)
+
+=== "<10>"
+    ![edit_distance_dp_step10](edit_distance_problem.assets/edit_distance_dp_step10.png)
+
+=== "<11>"
+    ![edit_distance_dp_step11](edit_distance_problem.assets/edit_distance_dp_step11.png)
+
+=== "<12>"
+    ![edit_distance_dp_step12](edit_distance_problem.assets/edit_distance_dp_step12.png)
+
+=== "<13>"
+    ![edit_distance_dp_step13](edit_distance_problem.assets/edit_distance_dp_step13.png)
+
+=== "<14>"
+    ![edit_distance_dp_step14](edit_distance_problem.assets/edit_distance_dp_step14.png)
+
+=== "<15>"
+    ![edit_distance_dp_step15](edit_distance_problem.assets/edit_distance_dp_step15.png)
+
+<p align="center"> 图 14-30 &nbsp; 编辑距离的动态规划过程 </p>
+
+### 3. &nbsp; 空间优化
+
+由于 $dp[i,j]$ 是由上方 $dp[i-1, j]$、左方 $dp[i, j-1]$、左上方状态 $dp[i-1, j-1]$ 转移而来，而正序遍历会丢失左上方 $dp[i-1, j-1]$ ，倒序遍历无法提前构建 $dp[i, j-1]$ ，因此两种遍历顺序都不可取。
+
+为此，我们可以使用一个变量 `leftup` 来暂存左上方的解 $dp[i-1, j-1]$ ，从而只需考虑左方和上方的解。此时的情况与完全背包问题相同，可使用正序遍历。
+
+=== "Python"
+
+    ```python title="edit_distance.py"
+    def edit_distance_dp_comp(s: str, t: str) -> int:
+        """编辑距离：空间优化后的动态规划"""
+        n, m = len(s), len(t)
+        dp = [0] * (m + 1)
+        # 状态转移：首行
+        for j in range(1, m + 1):
+            dp[j] = j
+        # 状态转移：其余行
+        for i in range(1, n + 1):
+            # 状态转移：首列
+            leftup = dp[0]  # 暂存 dp[i-1, j-1]
+            dp[0] += 1
+            # 状态转移：其余列
+            for j in range(1, m + 1):
+                temp = dp[j]
+                if s[i - 1] == t[j - 1]:
+                    # 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup
+                else:
+                    # 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = min(dp[j - 1], dp[j], leftup) + 1
+                leftup = temp  # 更新为下一轮的 dp[i-1, j-1]
+        return dp[m]
+    ```
+
+=== "C++"
+
+    ```cpp title="edit_distance.cpp"
+    /* 编辑距离：空间优化后的动态规划 */
+    int editDistanceDPComp(string s, string t) {
+        int n = s.length(), m = t.length();
+        vector<int> dp(m + 1, 0);
+        // 状态转移：首行
+        for (int j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (int i = 1; i <= n; i++) {
+            // 状态转移：首列
+            int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (int j = 1; j <= m; j++) {
+                int temp = dp[j];
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
+    ```
+
+=== "Java"
+
+    ```java title="edit_distance.java"
+    /* 编辑距离：空间优化后的动态规划 */
+    int editDistanceDPComp(String s, String t) {
+        int n = s.length(), m = t.length();
+        int[] dp = new int[m + 1];
+        // 状态转移：首行
+        for (int j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (int i = 1; i <= n; i++) {
+            // 状态转移：首列
+            int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (int j = 1; j <= m; j++) {
+                int temp = dp[j];
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="edit_distance.cs"
+    /* 编辑距离：空间优化后的动态规划 */
+    int EditDistanceDPComp(string s, string t) {
+        int n = s.Length, m = t.Length;
+        int[] dp = new int[m + 1];
+        // 状态转移：首行
+        for (int j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (int i = 1; i <= n; i++) {
+            // 状态转移：首列
+            int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (int j = 1; j <= m; j++) {
+                int temp = dp[j];
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
+    ```
+
+=== "Go"
+
+    ```go title="edit_distance.go"
+    /* 编辑距离：空间优化后的动态规划 */
+    func editDistanceDPComp(s string, t string) int {
+        n := len(s)
+        m := len(t)
+        dp := make([]int, m+1)
+        // 状态转移：首行
+        for j := 1; j <= m; j++ {
+            dp[j] = j
+        }
+        // 状态转移：其余行
+        for i := 1; i <= n; i++ {
+            // 状态转移：首列
+            leftUp := dp[0] // 暂存 dp[i-1, j-1]
+            dp[0] = i
+            // 状态转移：其余列
+            for j := 1; j <= m; j++ {
+                temp := dp[j]
+                if s[i-1] == t[j-1] {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftUp
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1
+                }
+                leftUp = temp // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m]
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="edit_distance.swift"
+    /* 编辑距离：空间优化后的动态规划 */
+    func editDistanceDPComp(s: String, t: String) -> Int {
+        let n = s.utf8CString.count
+        let m = t.utf8CString.count
+        var dp = Array(repeating: 0, count: m + 1)
+        // 状态转移：首行
+        for j in stride(from: 1, through: m, by: 1) {
+            dp[j] = j
+        }
+        // 状态转移：其余行
+        for i in stride(from: 1, through: n, by: 1) {
+            // 状态转移：首列
+            var leftup = dp[0] // 暂存 dp[i-1, j-1]
+            dp[0] = i
+            // 状态转移：其余列
+            for j in stride(from: 1, through: m, by: 1) {
+                let temp = dp[j]
+                if s.utf8CString[i - 1] == t.utf8CString[j - 1] {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1
+                }
+                leftup = temp // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m]
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="edit_distance.js"
+    /* 编辑距离：状态压缩后的动态规划 */
+    function editDistanceDPComp(s, t) {
+        const n = s.length,
+            m = t.length;
+        const dp = new Array(m + 1).fill(0);
+        // 状态转移：首行
+        for (let j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (let i = 1; i <= n; i++) {
+            // 状态转移：首列
+            let leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (let j = 1; j <= m; j++) {
+                const temp = dp[j];
+                if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="edit_distance.ts"
+    /* 编辑距离：状态压缩后的动态规划 */
+    function editDistanceDPComp(s: string, t: string): number {
+        const n = s.length,
+            m = t.length;
+        const dp = new Array(m + 1).fill(0);
+        // 状态转移：首行
+        for (let j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (let i = 1; i <= n; i++) {
+            // 状态转移：首列
+            let leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (let j = 1; j <= m; j++) {
+                const temp = dp[j];
+                if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="edit_distance.dart"
+    /* 编辑距离：空间优化后的动态规划 */
+    int editDistanceDPComp(String s, String t) {
+      int n = s.length, m = t.length;
+      List<int> dp = List.filled(m + 1, 0);
+      // 状态转移：首行
+      for (int j = 1; j <= m; j++) {
+        dp[j] = j;
+      }
+      // 状态转移：其余行
+      for (int i = 1; i <= n; i++) {
+        // 状态转移：首列
+        int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+        dp[0] = i;
+        // 状态转移：其余列
+        for (int j = 1; j <= m; j++) {
+          int temp = dp[j];
+          if (s[i - 1] == t[j - 1]) {
+            // 若两字符相等，则直接跳过此两字符
+            dp[j] = leftup;
+          } else {
+            // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+            dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
+          }
+          leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+        }
+      }
+      return dp[m];
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="edit_distance.rs"
+    /* 编辑距离：空间优化后的动态规划 */
+    fn edit_distance_dp_comp(s: &str, t: &str) -> i32 {
+        let (n, m) = (s.len(), t.len());
+        let mut dp = vec![0; m + 1];
+        // 状态转移：首行
+        for j in 1..m {
+            dp[j] = j as i32;
+        }
+        // 状态转移：其余行
+        for i in 1..=n {
+            // 状态转移：首列
+            let mut leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i as i32;
+            // 状态转移：其余列
+            for j in 1..=m {
+                let temp = dp[j];
+                if s.chars().nth(i - 1) == t.chars().nth(j - 1) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        dp[m]
+    }
+    ```
+
+=== "C"
+
+    ```c title="edit_distance.c"
+    [class]{}-[func]{editDistanceDPComp}
+    ```
+
+=== "Zig"
+
+    ```zig title="edit_distance.zig"
+    // 编辑距离：空间优化后的动态规划
+    fn editDistanceDPComp(comptime s: []const u8, comptime t: []const u8) i32 {
+        comptime var n = s.len;
+        comptime var m = t.len;
+        var dp = [_]i32{0} ** (m + 1);
+        // 状态转移：首行
+        for (1..m + 1) |j| {
+            dp[j] = @intCast(j);
+        }
+        // 状态转移：其余行
+        for (1..n + 1) |i| {
+            // 状态转移：首列
+            var leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = @intCast(i);
+            // 状态转移：其余列
+            for (1..m + 1) |j| {
+                var temp = dp[j];
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = @min(@min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
+    ```

docs/chapter_dynamic_programming/index.md

@@ -0,0 +1,28 @@
+---
+comments: true
+icon: material/table-pivot
+---
+
+# 第 14 章   动态规划
+
+<div class="center-table" markdown>
+
+![动态规划](../assets/covers/chapter_dynamic_programming.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    小溪汇入河流，江河汇入大海。
+    
+    动态规划将小问题的解汇集成大问题的答案，一步步引领我们走向解决问题的彼岸。
+
+## 本章内容
+
+- [14.1 &nbsp; 初探动态规划](https://www.hello-algo.com/chapter_dynamic_programming/intro_to_dynamic_programming/)
+- [14.2 &nbsp; DP 问题特性](https://www.hello-algo.com/chapter_dynamic_programming/dp_problem_features/)
+- [14.3 &nbsp; DP 解题思路](https://www.hello-algo.com/chapter_dynamic_programming/dp_solution_pipeline/)
+- [14.4 &nbsp; 0-1 背包问题](https://www.hello-algo.com/chapter_dynamic_programming/knapsack_problem/)
+- [14.5 &nbsp; 完全背包问题](https://www.hello-algo.com/chapter_dynamic_programming/unbounded_knapsack_problem/)
+- [14.6 &nbsp; 编辑距离问题](https://www.hello-algo.com/chapter_dynamic_programming/edit_distance_problem/)
+- [14.7 &nbsp; 小结](https://www.hello-algo.com/chapter_dynamic_programming/summary/)

docs/chapter_dynamic_programming/summary.md

@@ -0,0 +1,27 @@
+---
+comments: true
+---
+
+# 14.7   小结
+
+- 动态规划对问题进行分解，并通过存储子问题的解来规避重复计算，实现高效的计算效率。
+- 不考虑时间的前提下，所有动态规划问题都可以用回溯（暴力搜索）进行求解，但递归树中存在大量的重叠子问题，效率极低。通过引入记忆化列表，可以存储所有计算过的子问题的解，从而保证重叠子问题只被计算一次。
+- 记忆化递归是一种从顶至底的递归式解法，而与之对应的动态规划是一种从底至顶的递推式解法，其如同“填写表格”一样。由于当前状态仅依赖于某些局部状态，因此我们可以消除 $dp$ 表的一个维度，从而降低空间复杂度。
+- 子问题分解是一种通用的算法思路，在分治、动态规划、回溯中具有不同的性质。
+- 动态规划问题的三大特性：重叠子问题、最优子结构、无后效性。
+- 如果原问题的最优解可以从子问题的最优解构建得来，则它就具有最优子结构。
+- 无后效性指对于一个状态，其未来发展只与该状态有关，与其所经历的过去的所有状态无关。许多组合优化问题都不具有无后效性，无法使用动态规划快速求解。
+
+**背包问题**
+
+- 背包问题是最典型的动态规划题目，具有 0-1 背包、完全背包、多重背包等变种问题。
+- 0-1 背包的状态定义为前 $i$ 个物品在剩余容量为 $c$ 的背包中的最大价值。根据不放入背包和放入背包两种决策，可得到最优子结构，并构建出状态转移方程。在空间优化中，由于每个状态依赖正上方和左上方的状态，因此需要倒序遍历列表，避免左上方状态被覆盖。
+- 完全背包的每种物品的选取数量无限制，因此选择放入物品的状态转移与 0-1 背包不同。由于状态依赖于正上方和正左方的状态，因此在空间优化中应当正序遍历。
+- 零钱兑换问题是完全背包的一个变种。它从求“最大”价值变为求“最小”硬币数量，因此状态转移方程中的 $\max()$ 应改为 $\min()$ 。从求“不超过”背包容量到求“恰好”凑出目标金额，因此使用 $amt + 1$ 来表示“无法凑出目标金额”的无效解。
+- 零钱兑换 II 问题从求“最少硬币数量”改为求“硬币组合数量”，状态转移方程相应地从 $\min()$ 改为求和运算符。
+
+**编辑距离问题**
+
+- 编辑距离（Levenshtein 距离）用于衡量两个字符串之间的相似度，其定义为从一个字符串到另一个字符串的最小编辑步数，编辑操作包括添加、删除、替换。
+- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无须编辑当前字符。
+- 在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此空间优化后正序或倒序遍历都无法正确地进行状态转移。为此，我们利用一个变量暂存左上方状态，从而转化到与完全背包等价的情况，可以在空间优化后进行正序遍历。

docs/chapter_graph/graph.md

@@ -0,0 +1,103 @@
+---
+comments: true
+---
+
+# 9.1   图
+
+「图 graph」是一种非线性数据结构，由「顶点 vertex」和「边 edge」组成。我们可以将图 $G$ 抽象地表示为一组顶点 $V$ 和一组边 $E$ 的集合。以下示例展示了一个包含 5 个顶点和 7 条边的图。
+
+$$
+\begin{aligned}
+V & = \{ 1, 2, 3, 4, 5 \} \newline
+E & = \{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \} \newline
+G & = \{ V, E \} \newline
+\end{aligned}
+$$
+
+如果将顶点看作节点，将边看作连接各个节点的引用（指针），我们就可以将图看作是一种从链表拓展而来的数据结构。如图 9-1 所示，**相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高**，从而更为复杂。
+
+![链表、树、图之间的关系](graph.assets/linkedlist_tree_graph.png)
+
+<p align="center"> 图 9-1 &nbsp; 链表、树、图之间的关系 </p>
+
+## 9.1.1 &nbsp; 图常见类型与术语
+
+根据边是否具有方向，可分为图 9-2 所示的「无向图 undirected graph」和「有向图 directed graph」。
+
+- 在无向图中，边表示两顶点之间的“双向”连接关系，例如微信或 QQ 中的“好友关系”。
+- 在有向图中，边具有方向性，即 $A \rightarrow B$ 和 $A \leftarrow B$ 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系。
+
+![有向图与无向图](graph.assets/directed_graph.png)
+
+<p align="center"> 图 9-2 &nbsp; 有向图与无向图 </p>
+
+根据所有顶点是否连通，可分为图 9-3 所示的「连通图 connected graph」和「非连通图 disconnected graph」。
+
+- 对于连通图，从某个顶点出发，可以到达其余任意顶点。
+- 对于非连通图，从某个顶点出发，至少有一个顶点无法到达。
+
+![连通图与非连通图](graph.assets/connected_graph.png)
+
+<p align="center"> 图 9-3 &nbsp; 连通图与非连通图 </p>
+
+我们还可以为边添加“权重”变量，从而得到图 9-4 所示的「有权图 weighted graph」。例如在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。
+
+![有权图与无权图](graph.assets/weighted_graph.png)
+
+<p align="center"> 图 9-4 &nbsp; 有权图与无权图 </p>
+
+图数据结构包含以下常用术语。
+
+- 「邻接 adjacency」：当两顶点之间存在边相连时，称这两顶点“邻接”。在图 9-4 中，顶点 1 的邻接顶点为顶点 2、3、5。
+- 「路径 path」：从顶点 A 到顶点 B 经过的边构成的序列被称为从 A 到 B 的“路径”。在图 9-4 中，边序列 1-5-2-4 是顶点 1 到顶点 4 的一条路径。
+- 「度 degree」：一个顶点拥有的边数。对于有向图，「入度 In-Degree」表示有多少条边指向该顶点，「出度 Out-Degree」表示有多少条边从该顶点指出。
+
+## 9.1.2 &nbsp; 图的表示
+
+图的常用表示方式包括“邻接矩阵”和“邻接表”。以下使用无向图进行举例。
+
+### 1. &nbsp; 邻接矩阵
+
+设图的顶点数量为 $n$ ，「邻接矩阵 adjacency matrix」使用一个 $n \times n$ 大小的矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，用 $1$ 或 $0$ 表示两个顶点之间是否存在边。
+
+如图 9-5 所示，设邻接矩阵为 $M$、顶点列表为 $V$ ，那么矩阵元素 $M[i, j] = 1$ 表示顶点 $V[i]$ 到顶点 $V[j]$ 之间存在边，反之 $M[i, j] = 0$ 表示两顶点之间无边。
+
+![图的邻接矩阵表示](graph.assets/adjacency_matrix.png)
+
+<p align="center"> 图 9-5 &nbsp; 图的邻接矩阵表示 </p>
+
+邻接矩阵具有以下特性。
+
+- 顶点不能与自身相连，因此邻接矩阵主对角线元素没有意义。
+- 对于无向图，两个方向的边等价，此时邻接矩阵关于主对角线对称。
+- 将邻接矩阵的元素从 $1$ 和 $0$ 替换为权重，则可表示有权图。
+
+使用邻接矩阵表示图时，我们可以直接访问矩阵元素以获取边，因此增删查操作的效率很高，时间复杂度均为 $O(1)$ 。然而，矩阵的空间复杂度为 $O(n^2)$ ，内存占用较多。
+
+### 2. &nbsp; 邻接表
+
+「邻接表 adjacency list」使用 $n$ 个链表来表示图，链表节点表示顶点。第 $i$ 条链表对应顶点 $i$ ，其中存储了该顶点的所有邻接顶点（即与该顶点相连的顶点）。图 9-6 展示了一个使用邻接表存储的图的示例。
+
+![图的邻接表表示](graph.assets/adjacency_list.png)
+
+<p align="center"> 图 9-6 &nbsp; 图的邻接表表示 </p>
+
+邻接表仅存储实际存在的边，而边的总数通常远小于 $n^2$ ，因此它更加节省空间。然而，在邻接表中需要通过遍历链表来查找边，因此其时间效率不如邻接矩阵。
+
+观察图 9-6 ，**邻接表结构与哈希表中的“链式地址”非常相似，因此我们也可以采用类似方法来优化效率**。比如当链表较长时，可以将链表转化为 AVL 树或红黑树，从而将时间效率从 $O(n)$ 优化至 $O(\log n)$ ；还可以把链表转换为哈希表，从而将时间复杂度降低至 $O(1)$ 。
+
+## 9.1.3 &nbsp; 图常见应用
+
+如表 9-1 所示，许多现实系统都可以用图来建模，相应的问题也可以约化为图计算问题。
+
+<p align="center"> 表 9-1 &nbsp; 现实生活中常见的图 </p>
+
+<div class="center-table" markdown>
+
+|        | 顶点 | 边               | 图计算问题   |
+| ------ | ---- | --------------- | ------------ |
+| 社交网络 | 用户 | 好友关系           | 潜在好友推荐 |
+| 地铁线路 | 站点 | 站点间的连通性      | 最短路线推荐 |
+| 太阳系  | 星体 | 星体间的万有引力作用  | 行星轨道计算 |
+
+</div>

docs/chapter_graph/graph_traversal.md

@@ -0,0 +1,848 @@
+---
+comments: true
+---
+
+# 9.3   图的遍历
+
+树代表的是“一对多”的关系，而图则具有更高的自由度，可以表示任意的“多对多”关系。因此，我们可以把树看作是图的一种特例。显然，**树的遍历操作也是图的遍历操作的一种特例**。
+
+图和树都需要应用搜索算法来实现遍历操作。图的遍历方式可分为两种：「广度优先遍历 breadth-first traversal」和「深度优先遍历 depth-first traversal」。它们也常被称为「广度优先搜索 breadth-first search」和「深度优先搜索 depth-first search」，简称 BFS 和 DFS 。
+
+## 9.3.1   广度优先遍历
+
+**广度优先遍历是一种由近及远的遍历方式，从某个节点出发，始终优先访问距离最近的顶点，并一层层向外扩张**。如图 9-9 所示，从左上角顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接顶点，以此类推，直至所有顶点访问完毕。
+
+![图的广度优先遍历](graph_traversal.assets/graph_bfs.png)
+
+<p align="center"> 图 9-9 &nbsp; 图的广度优先遍历 </p>
+
+### 1. &nbsp; 算法实现
+
+BFS 通常借助队列来实现。队列具有“先入先出”的性质，这与 BFS 的“由近及远”的思想异曲同工。
+
+1. 将遍历起始顶点 `startVet` 加入队列，并开启循环。
+2. 在循环的每轮迭代中，弹出队首顶点并记录访问，然后将该顶点的所有邻接顶点加入到队列尾部。
+3. 循环步骤 `2.` ，直到所有顶点被访问完成后结束。
+
+为了防止重复遍历顶点，我们需要借助一个哈希表 `visited` 来记录哪些节点已被访问。
+
+=== "Python"
+
+    ```python title="graph_bfs.py"
+    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
+        """广度优先遍历 BFS"""
+        # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+        # 顶点遍历序列
+        res = []
+        # 哈希表，用于记录已被访问过的顶点
+        visited = set[Vertex]([start_vet])
+        # 队列用于实现 BFS
+        que = deque[Vertex]([start_vet])
+        # 以顶点 vet 为起点，循环直至访问完所有顶点
+        while len(que) > 0:
+            vet = que.popleft()  # 队首顶点出队
+            res.append(vet)  # 记录访问顶点
+            # 遍历该顶点的所有邻接顶点
+            for adj_vet in graph.adj_list[vet]:
+                if adj_vet in visited:
+                    continue  # 跳过已被访问过的顶点
+                que.append(adj_vet)  # 只入队未访问的顶点
+                visited.add(adj_vet)  # 标记该顶点已被访问
+        # 返回顶点遍历序列
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="graph_bfs.cpp"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    vector<Vertex *> graphBFS(GraphAdjList &graph, Vertex *startVet) {
+        // 顶点遍历序列
+        vector<Vertex *> res;
+        // 哈希表，用于记录已被访问过的顶点
+        unordered_set<Vertex *> visited = {startVet};
+        // 队列用于实现 BFS
+        queue<Vertex *> que;
+        que.push(startVet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (!que.empty()) {
+            Vertex *vet = que.front();
+            que.pop();          // 队首顶点出队
+            res.push_back(vet); // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for (auto adjVet : graph.adjList[vet]) {
+                if (visited.count(adjVet))
+                    continue;            // 跳过已被访问过的顶点
+                que.push(adjVet);        // 只入队未访问的顶点
+                visited.emplace(adjVet); // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="graph_bfs.java"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+        // 顶点遍历序列
+        List<Vertex> res = new ArrayList<>();
+        // 哈希表，用于记录已被访问过的顶点
+        Set<Vertex> visited = new HashSet<>();
+        visited.add(startVet);
+        // 队列用于实现 BFS
+        Queue<Vertex> que = new LinkedList<>();
+        que.offer(startVet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (!que.isEmpty()) {
+            Vertex vet = que.poll(); // 队首顶点出队
+            res.add(vet);            // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for (Vertex adjVet : graph.adjList.get(vet)) {
+                if (visited.contains(adjVet))
+                    continue;        // 跳过已被访问过的顶点
+                que.offer(adjVet);   // 只入队未访问的顶点
+                visited.add(adjVet); // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="graph_bfs.cs"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    List<Vertex> GraphBFS(GraphAdjList graph, Vertex startVet) {
+        // 顶点遍历序列
+        List<Vertex> res = new();
+        // 哈希表，用于记录已被访问过的顶点
+        HashSet<Vertex> visited = new() { startVet };
+        // 队列用于实现 BFS
+        Queue<Vertex> que = new();
+        que.Enqueue(startVet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (que.Count > 0) {
+            Vertex vet = que.Dequeue(); // 队首顶点出队
+            res.Add(vet);               // 记录访问顶点
+            foreach (Vertex adjVet in graph.adjList[vet]) {
+                if (visited.Contains(adjVet)) {
+                    continue;          // 跳过已被访问过的顶点
+                }
+                que.Enqueue(adjVet);   // 只入队未访问的顶点
+                visited.Add(adjVet);   // 标记该顶点已被访问
+            }
+        }
+
+        // 返回顶点遍历序列
+        return res;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="graph_bfs.go"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphBFS(g *graphAdjList, startVet Vertex) []Vertex {
+        // 顶点遍历序列
+        res := make([]Vertex, 0)
+        // 哈希表，用于记录已被访问过的顶点
+        visited := make(map[Vertex]struct{})
+        visited[startVet] = struct{}{}
+        // 队列用于实现 BFS, 使用切片模拟队列
+        queue := make([]Vertex, 0)
+        queue = append(queue, startVet)
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        for len(queue) > 0 {
+            // 队首顶点出队
+            vet := queue[0]
+            queue = queue[1:]
+            // 记录访问顶点
+            res = append(res, vet)
+            // 遍历该顶点的所有邻接顶点
+            for _, adjVet := range g.adjList[vet] {
+                _, isExist := visited[adjVet]
+                // 只入队未访问的顶点
+                if !isExist {
+                    queue = append(queue, adjVet)
+                    visited[adjVet] = struct{}{}
+                }
+            }
+        }
+        // 返回顶点遍历序列
+        return res
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="graph_bfs.swift"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphBFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {
+        // 顶点遍历序列
+        var res: [Vertex] = []
+        // 哈希表，用于记录已被访问过的顶点
+        var visited: Set<Vertex> = [startVet]
+        // 队列用于实现 BFS
+        var que: [Vertex] = [startVet]
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while !que.isEmpty {
+            let vet = que.removeFirst() // 队首顶点出队
+            res.append(vet) // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for adjVet in graph.adjList[vet] ?? [] {
+                if visited.contains(adjVet) {
+                    continue // 跳过已被访问过的顶点
+                }
+                que.append(adjVet) // 只入队未访问的顶点
+                visited.insert(adjVet) // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="graph_bfs.js"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function graphBFS(graph, startVet) {
+        // 顶点遍历序列
+        const res = [];
+        // 哈希表，用于记录已被访问过的顶点
+        const visited = new Set();
+        visited.add(startVet);
+        // 队列用于实现 BFS
+        const que = [startVet];
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (que.length) {
+            const vet = que.shift(); // 队首顶点出队
+            res.push(vet); // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for (const adjVet of graph.adjList.get(vet) ?? []) {
+                if (visited.has(adjVet)) {
+                    continue; // 跳过已被访问过的顶点
+                }
+                que.push(adjVet); // 只入队未访问的顶点
+                visited.add(adjVet); // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="graph_bfs.ts"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
+        // 顶点遍历序列
+        const res: Vertex[] = [];
+        // 哈希表，用于记录已被访问过的顶点
+        const visited: Set<Vertex> = new Set();
+        visited.add(startVet);
+        // 队列用于实现 BFS
+        const que = [startVet];
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (que.length) {
+            const vet = que.shift(); // 队首顶点出队
+            res.push(vet); // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for (const adjVet of graph.adjList.get(vet) ?? []) {
+                if (visited.has(adjVet)) {
+                    continue; // 跳过已被访问过的顶点
+                }
+                que.push(adjVet); // 只入队未访问
+                visited.add(adjVet); // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="graph_bfs.dart"
+    /* 广度优先遍历 BFS */
+    List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+      // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+      // 顶点遍历序列
+      List<Vertex> res = [];
+      // 哈希表，用于记录已被访问过的顶点
+      Set<Vertex> visited = {};
+      visited.add(startVet);
+      // 队列用于实现 BFS
+      Queue<Vertex> que = Queue();
+      que.add(startVet);
+      // 以顶点 vet 为起点，循环直至访问完所有顶点
+      while (que.isNotEmpty) {
+        Vertex vet = que.removeFirst(); // 队首顶点出队
+        res.add(vet); // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        for (Vertex adjVet in graph.adjList[vet]!) {
+          if (visited.contains(adjVet)) {
+            continue; // 跳过已被访问过的顶点
+          }
+          que.add(adjVet); // 只入队未访问的顶点
+          visited.add(adjVet); // 标记该顶点已被访问
+        }
+      }
+      // 返回顶点遍历序列
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="graph_bfs.rs"
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    fn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
+        // 顶点遍历序列
+        let mut res = vec![];
+        // 哈希表，用于记录已被访问过的顶点
+        let mut visited = HashSet::new();
+        visited.insert(start_vet);
+        // 队列用于实现 BFS
+        let mut que = VecDeque::new();
+        que.push_back(start_vet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while !que.is_empty() {
+            let vet = que.pop_front().unwrap(); // 队首顶点出队
+            res.push(vet); // 记录访问顶点
+                        // 遍历该顶点的所有邻接顶点
+            if let Some(adj_vets) = graph.adj_list.get(&vet) {
+                for &adj_vet in adj_vets {
+                    if visited.contains(&adj_vet) {
+                        continue; // 跳过已被访问过的顶点
+                    }
+                    que.push_back(adj_vet); // 只入队未访问的顶点
+                    visited.insert(adj_vet); // 标记该顶点已被访问
+                }
+            }
+        }
+        // 返回顶点遍历序列
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="graph_bfs.c"
+    /* 广度优先遍历 */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    Vertex **graphBFS(graphAdjList *t, Vertex *startVet) {
+        // 顶点遍历序列
+        Vertex **res = (Vertex **)malloc(sizeof(Vertex *) * t->size);
+        memset(res, 0, sizeof(Vertex *) * t->size);
+        // 队列用于实现 BFS
+        queue *que = newQueue(t->size);
+        // 哈希表，用于记录已被访问过的顶点
+        hashTable *visited = newHash(t->size);
+        int resIndex = 0;
+        queuePush(que, startVet);         // 将第一个元素入队
+        hashMark(visited, startVet->pos); // 标记第一个入队的顶点
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (que->head < que->tail) {
+            // 遍历该顶点的边链表，将所有与该顶点有连接的，并且未被标记的顶点入队
+            Node *n = queueTop(que)->linked->head->next;
+            while (n != 0) {
+                // 查询哈希表，若该索引的顶点已入队，则跳过，否则入队并标记
+                if (hashQuery(visited, n->val->pos) == 1) {
+                    n = n->next;
+                    continue; // 跳过已被访问过的顶点
+                }
+                queuePush(que, n->val);         // 只入队未访问的顶点
+                hashMark(visited, n->val->pos); // 标记该顶点已被访问
+            }
+            // 队首元素存入数组
+            res[resIndex] = queueTop(que); // 队首顶点加入顶点遍历序列
+            resIndex++;
+            queuePop(que); // 队首元素出队
+        }
+        // 释放内存
+        freeQueue(que);
+        freeHash(visited);
+        resIndex = 0;
+        // 返回顶点遍历序列
+        return res;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="graph_bfs.zig"
+    [class]{}-[func]{graphBFS}
+    ```
+
+代码相对抽象，建议对照图 9-10 来加深理解。
+
+=== "<1>"
+    ![图的广度优先遍历步骤](graph_traversal.assets/graph_bfs_step1.png)
+
+=== "<2>"
+    ![graph_bfs_step2](graph_traversal.assets/graph_bfs_step2.png)
+
+=== "<3>"
+    ![graph_bfs_step3](graph_traversal.assets/graph_bfs_step3.png)
+
+=== "<4>"
+    ![graph_bfs_step4](graph_traversal.assets/graph_bfs_step4.png)
+
+=== "<5>"
+    ![graph_bfs_step5](graph_traversal.assets/graph_bfs_step5.png)
+
+=== "<6>"
+    ![graph_bfs_step6](graph_traversal.assets/graph_bfs_step6.png)
+
+=== "<7>"
+    ![graph_bfs_step7](graph_traversal.assets/graph_bfs_step7.png)
+
+=== "<8>"
+    ![graph_bfs_step8](graph_traversal.assets/graph_bfs_step8.png)
+
+=== "<9>"
+    ![graph_bfs_step9](graph_traversal.assets/graph_bfs_step9.png)
+
+=== "<10>"
+    ![graph_bfs_step10](graph_traversal.assets/graph_bfs_step10.png)
+
+=== "<11>"
+    ![graph_bfs_step11](graph_traversal.assets/graph_bfs_step11.png)
+
+<p align="center"> 图 9-10 &nbsp; 图的广度优先遍历步骤 </p>
+
+!!! question "广度优先遍历的序列是否唯一？"
+
+    不唯一。广度优先遍历只要求按“由近及远”的顺序遍历，**而多个相同距离的顶点的遍历顺序是允许被任意打乱的**。以图 9-10 为例，顶点 $1$、$3$ 的访问顺序可以交换、顶点 $2$、$4$、$6$ 的访问顺序也可以任意交换。
+
+### 2. &nbsp; 复杂度分析
+
+**时间复杂度：** 所有顶点都会入队并出队一次，使用 $O(|V|)$ 时间；在遍历邻接顶点的过程中，由于是无向图，因此所有边都会被访问 $2$ 次，使用 $O(2|E|)$ 时间；总体使用 $O(|V| + |E|)$ 时间。
+
+**空间复杂度：** 列表 `res` ，哈希表 `visited` ，队列 `que` 中的顶点数量最多为 $|V|$ ，使用 $O(|V|)$ 空间。
+
+## 9.3.2 &nbsp; 深度优先遍历
+
+**深度优先遍历是一种优先走到底、无路可走再回头的遍历方式**。如图 9-11 所示，从左上角顶点出发，访问当前顶点的某个邻接顶点，直到走到尽头时返回，再继续走到尽头并返回，以此类推，直至所有顶点遍历完成。
+
+![图的深度优先遍历](graph_traversal.assets/graph_dfs.png)
+
+<p align="center"> 图 9-11 &nbsp; 图的深度优先遍历 </p>
+
+### 1. &nbsp; 算法实现
+
+这种“走到尽头再返回”的算法范式通常基于递归来实现。与广度优先遍历类似，在深度优先遍历中我们也需要借助一个哈希表 `visited` 来记录已被访问的顶点，以避免重复访问顶点。
+
+=== "Python"
+
+    ```python title="graph_dfs.py"
+    def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):
+        """深度优先遍历 DFS 辅助函数"""
+        res.append(vet)  # 记录访问顶点
+        visited.add(vet)  # 标记该顶点已被访问
+        # 遍历该顶点的所有邻接顶点
+        for adjVet in graph.adj_list[vet]:
+            if adjVet in visited:
+                continue  # 跳过已被访问过的顶点
+            # 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet)
+
+    def graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
+        """深度优先遍历 DFS"""
+        # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+        # 顶点遍历序列
+        res = []
+        # 哈希表，用于记录已被访问过的顶点
+        visited = set[Vertex]()
+        dfs(graph, visited, res, start_vet)
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="graph_dfs.cpp"
+    /* 深度优先遍历 DFS 辅助函数 */
+    void dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {
+        res.push_back(vet);   // 记录访问顶点
+        visited.emplace(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for (Vertex *adjVet : graph.adjList[vet]) {
+            if (visited.count(adjVet))
+                continue; // 跳过已被访问过的顶点
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    vector<Vertex *> graphDFS(GraphAdjList &graph, Vertex *startVet) {
+        // 顶点遍历序列
+        vector<Vertex *> res;
+        // 哈希表，用于记录已被访问过的顶点
+        unordered_set<Vertex *> visited;
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="graph_dfs.java"
+    /* 深度优先遍历 DFS 辅助函数 */
+    void dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {
+        res.add(vet);     // 记录访问顶点
+        visited.add(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for (Vertex adjVet : graph.adjList.get(vet)) {
+            if (visited.contains(adjVet))
+                continue; // 跳过已被访问过的顶点
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
+        // 顶点遍历序列
+        List<Vertex> res = new ArrayList<>();
+        // 哈希表，用于记录已被访问过的顶点
+        Set<Vertex> visited = new HashSet<>();
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="graph_dfs.cs"
+    /* 深度优先遍历 DFS 辅助函数 */
+    void Dfs(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {
+        res.Add(vet);     // 记录访问顶点
+        visited.Add(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        foreach (Vertex adjVet in graph.adjList[vet]) {
+            if (visited.Contains(adjVet)) {
+                continue; // 跳过已被访问过的顶点                             
+            }
+            // 递归访问邻接顶点
+            Dfs(graph, visited, res, adjVet);
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    List<Vertex> GraphDFS(GraphAdjList graph, Vertex startVet) {
+        // 顶点遍历序列
+        List<Vertex> res = new();
+        // 哈希表，用于记录已被访问过的顶点
+        HashSet<Vertex> visited = new();
+        Dfs(graph, visited, res, startVet);
+        return res;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="graph_dfs.go"
+    /* 深度优先遍历 DFS 辅助函数 */
+    func dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {
+        // append 操作会返回新的的引用，必须让原引用重新赋值为新slice的引用
+        *res = append(*res, vet)
+        visited[vet] = struct{}{}
+        // 遍历该顶点的所有邻接顶点
+        for _, adjVet := range g.adjList[vet] {
+            _, isExist := visited[adjVet]
+            // 递归访问邻接顶点
+            if !isExist {
+                dfs(g, visited, res, adjVet)
+            }
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphDFS(g *graphAdjList, startVet Vertex) []Vertex {
+        // 顶点遍历序列
+        res := make([]Vertex, 0)
+        // 哈希表，用于记录已被访问过的顶点
+        visited := make(map[Vertex]struct{})
+        dfs(g, visited, &res, startVet)
+        // 返回顶点遍历序列
+        return res
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="graph_dfs.swift"
+    /* 深度优先遍历 DFS 辅助函数 */
+    func dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {
+        res.append(vet) // 记录访问顶点
+        visited.insert(vet) // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for adjVet in graph.adjList[vet] ?? [] {
+            if visited.contains(adjVet) {
+                continue // 跳过已被访问过的顶点
+            }
+            // 递归访问邻接顶点
+            dfs(graph: graph, visited: &visited, res: &res, vet: adjVet)
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphDFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {
+        // 顶点遍历序列
+        var res: [Vertex] = []
+        // 哈希表，用于记录已被访问过的顶点
+        var visited: Set<Vertex> = []
+        dfs(graph: graph, visited: &visited, res: &res, vet: startVet)
+        return res
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="graph_dfs.js"
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function dfs(graph, visited, res, vet) {
+        res.push(vet); // 记录访问顶点
+        visited.add(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for (const adjVet of graph.adjList.get(vet)) {
+            if (visited.has(adjVet)) {
+                continue; // 跳过已被访问过的顶点
+            }
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function graphDFS(graph, startVet) {
+        // 顶点遍历序列
+        const res = [];
+        // 哈希表，用于记录已被访问过的顶点
+        const visited = new Set();
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="graph_dfs.ts"
+    /* 深度优先遍历 DFS 辅助函数 */
+    function dfs(
+        graph: GraphAdjList,
+        visited: Set<Vertex>,
+        res: Vertex[],
+        vet: Vertex
+    ): void {
+        res.push(vet); // 记录访问顶点
+        visited.add(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for (const adjVet of graph.adjList.get(vet)) {
+            if (visited.has(adjVet)) {
+                continue; // 跳过已被访问过的顶点
+            }
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
+        // 顶点遍历序列
+        const res: Vertex[] = [];
+        // 哈希表，用于记录已被访问过的顶点
+        const visited: Set<Vertex> = new Set();
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="graph_dfs.dart"
+    /* 深度优先遍历 DFS 辅助函数 */
+    void dfs(
+      GraphAdjList graph,
+      Set<Vertex> visited,
+      List<Vertex> res,
+      Vertex vet,
+    ) {
+      res.add(vet); // 记录访问顶点
+      visited.add(vet); // 标记该顶点已被访问
+      // 遍历该顶点的所有邻接顶点
+      for (Vertex adjVet in graph.adjList[vet]!) {
+        if (visited.contains(adjVet)) {
+          continue; // 跳过已被访问过的顶点
+        }
+        // 递归访问邻接顶点
+        dfs(graph, visited, res, adjVet);
+      }
+    }
+
+    /* 深度优先遍历 DFS */
+    List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
+      // 顶点遍历序列
+      List<Vertex> res = [];
+      // 哈希表，用于记录已被访问过的顶点
+      Set<Vertex> visited = {};
+      dfs(graph, visited, res, startVet);
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="graph_dfs.rs"
+    /* 深度优先遍历 DFS 辅助函数 */
+    fn dfs(graph: &GraphAdjList, visited: &mut HashSet<Vertex>, res: &mut Vec<Vertex>, vet: Vertex) {
+        res.push(vet); // 记录访问顶点
+        visited.insert(vet); // 标记该顶点已被访问
+                             // 遍历该顶点的所有邻接顶点
+        if let Some(adj_vets) = graph.adj_list.get(&vet) {
+            for &adj_vet in adj_vets {
+                if visited.contains(&adj_vet) {
+                    continue; // 跳过已被访问过的顶点
+                }
+                // 递归访问邻接顶点
+                dfs(graph, visited, res, adj_vet);
+            }
+        }
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    fn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
+        // 顶点遍历序列
+        let mut res = vec![];
+        // 哈希表，用于记录已被访问过的顶点
+        let mut visited = HashSet::new();
+        dfs(&graph, &mut visited, &mut res, start_vet);
+
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="graph_dfs.c"
+    /* 深度优先遍历 DFS 辅助函数 */
+    int resIndex = 0;
+    void dfs(graphAdjList *graph, hashTable *visited, Vertex *vet, Vertex **res) {
+        if (hashQuery(visited, vet->pos) == 1) {
+            return; // 跳过已被访问过的顶点
+        }
+        hashMark(visited, vet->pos); // 标记顶点并将顶点存入数组
+        res[resIndex] = vet;         // 将顶点存入数组
+        resIndex++;
+        // 遍历该顶点链表
+        Node *n = vet->linked->head->next;
+        while (n != 0) {
+            // 递归访问邻接顶点
+            dfs(graph, visited, n->val, res);
+            n = n->next;
+        }
+        return;
+    }
+
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    Vertex **graphDFS(graphAdjList *graph, Vertex *startVet) {
+        // 顶点遍历序列
+        Vertex **res = (Vertex **)malloc(sizeof(Vertex *) * graph->size);
+        memset(res, 0, sizeof(Vertex *) * graph->size);
+        // 哈希表，用于记录已被访问过的顶点
+        hashTable *visited = newHash(graph->size);
+        dfs(graph, visited, startVet, res);
+        // 释放哈希表内存并将数组索引归零
+        freeHash(visited);
+        resIndex = 0;
+        // 返回遍历数组
+        return res;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="graph_dfs.zig"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{graphDFS}
+    ```
+
+深度优先遍历的算法流程如图 9-12 所示。
+
+- **直虚线代表向下递推**，表示开启了一个新的递归方法来访问新顶点。
+- **曲虚线代表向上回溯**，表示此递归方法已经返回，回溯到了开启此递归方法的位置。
+
+为了加深理解，建议将图示与代码结合起来，在脑中（或者用笔画下来）模拟整个 DFS 过程，包括每个递归方法何时开启、何时返回。
+
+=== "<1>"
+    ![图的深度优先遍历步骤](graph_traversal.assets/graph_dfs_step1.png)
+
+=== "<2>"
+    ![graph_dfs_step2](graph_traversal.assets/graph_dfs_step2.png)
+
+=== "<3>"
+    ![graph_dfs_step3](graph_traversal.assets/graph_dfs_step3.png)
+
+=== "<4>"
+    ![graph_dfs_step4](graph_traversal.assets/graph_dfs_step4.png)
+
+=== "<5>"
+    ![graph_dfs_step5](graph_traversal.assets/graph_dfs_step5.png)
+
+=== "<6>"
+    ![graph_dfs_step6](graph_traversal.assets/graph_dfs_step6.png)
+
+=== "<7>"
+    ![graph_dfs_step7](graph_traversal.assets/graph_dfs_step7.png)
+
+=== "<8>"
+    ![graph_dfs_step8](graph_traversal.assets/graph_dfs_step8.png)
+
+=== "<9>"
+    ![graph_dfs_step9](graph_traversal.assets/graph_dfs_step9.png)
+
+=== "<10>"
+    ![graph_dfs_step10](graph_traversal.assets/graph_dfs_step10.png)
+
+=== "<11>"
+    ![graph_dfs_step11](graph_traversal.assets/graph_dfs_step11.png)
+
+<p align="center"> 图 9-12 &nbsp; 图的深度优先遍历步骤 </p>
+
+!!! question "深度优先遍历的序列是否唯一？"
+
+    与广度优先遍历类似，深度优先遍历序列的顺序也不是唯一的。给定某顶点，先往哪个方向探索都可以，即邻接顶点的顺序可以任意打乱，都是深度优先遍历。
+    
+    以树的遍历为例，“根 $\rightarrow$ 左 $\rightarrow$ 右”、“左 $\rightarrow$ 根 $\rightarrow$ 右”、“左 $\rightarrow$ 右 $\rightarrow$ 根”分别对应前序、中序、后序遍历，它们展示了三种不同的遍历优先级，然而这三者都属于深度优先遍历。
+
+### 2. &nbsp; 复杂度分析
+
+**时间复杂度：** 所有顶点都会被访问 $1$ 次，使用 $O(|V|)$ 时间；所有边都会被访问 $2$ 次，使用 $O(2|E|)$ 时间；总体使用 $O(|V| + |E|)$ 时间。
+
+**空间复杂度：** 列表 `res` ，哈希表 `visited` 顶点数量最多为 $|V|$ ，递归深度最大为 $|V|$ ，因此使用 $O(|V|)$ 空间。

docs/chapter_graph/index.md

@@ -0,0 +1,25 @@
+---
+comments: true
+icon: material/graphql
+---
+
+# 第 9 章   图
+
+<div class="center-table" markdown>
+
+![图](../assets/covers/chapter_graph.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    在生命旅途中，我们就像是每个节点，被无数看不见的边相连。
+    
+    每一次的相识与相离，都在这张巨大的网络图中留下独特的印记。
+
+## 本章内容
+
+- [9.1 &nbsp; 图](https://www.hello-algo.com/chapter_graph/graph/)
+- [9.2 &nbsp; 图基础操作](https://www.hello-algo.com/chapter_graph/graph_operations/)
+- [9.3 &nbsp; 图的遍历](https://www.hello-algo.com/chapter_graph/graph_traversal/)
+- [9.4 &nbsp; 小结](https://www.hello-algo.com/chapter_graph/summary/)

docs/chapter_graph/summary.md

@@ -0,0 +1,34 @@
+---
+comments: true
+---
+
+# 9.4   小结
+
+### 1.   重点回顾
+
+- 图由顶点和边组成，可以被表示为一组顶点和一组边构成的集合。
+- 相较于线性关系（链表）和分治关系（树），网络关系（图）具有更高的自由度，因而更为复杂。
+- 有向图的边具有方向性，连通图中的任意顶点均可达，有权图的每条边都包含权重变量。
+- 邻接矩阵利用矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，用 $1$ 或 $0$ 表示两个顶点之间有边或无边。邻接矩阵在增删查操作上效率很高，但空间占用较多。
+- 邻接表使用多个链表来表示图，第 $i$ 条链表对应顶点 $i$ ，其中存储了该顶点的所有邻接顶点。邻接表相对于邻接矩阵更加节省空间，但由于需要遍历链表来查找边，时间效率较低。
+- 当邻接表中的链表过长时，可以将其转换为红黑树或哈希表，从而提升查询效率。
+- 从算法思想角度分析，邻接矩阵体现“以空间换时间”，邻接表体现“以时间换空间”。
+- 图可用于建模各类现实系统，如社交网络、地铁线路等。
+- 树是图的一种特例，树的遍历也是图的遍历的一种特例。
+- 图的广度优先遍历是一种由近及远、层层扩张的搜索方式，通常借助队列实现。
+- 图的深度优先遍历是一种优先走到底、无路可走时再回溯的搜索方式，常基于递归来实现。
+
+### 2.   Q & A
+
+!!! question "路径的定义是顶点序列还是边序列？"
+
+    维基百科上不同语言版本的定义不一致：英文版是“路径是一个边序列”，而中文版是“路径是一个顶点序列”。以下是英文版原文：In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.
+    在本文中，路径被认为是一个边序列，而不是一个顶点序列。这是因为两个顶点之间可能存在多条边连接，此时每条边都对应一条路径。
+
+!!! question "非连通图中，是否会有无法遍历到的点？"
+
+    在非连通图中，从某个顶点出发，至少有一个顶点无法到达。遍历非连通图需要设置多个起点，以遍历到图的所有连通分量。
+
+!!! question "在邻接表中，“与该顶点相连的所有顶点”的顶点顺序是否有要求？"
+
+    可以是任意顺序。但在实际应用中，可能会需要按照指定规则来排序，比如按照顶点添加的次序、或者按照顶点值大小的顺序等等，这样可以有助于快速查找“带有某种极值”的顶点。

docs/chapter_greedy/fractional_knapsack_problem.md

@@ -0,0 +1,490 @@
+---
+comments: true
+---
+
+# 15.2   分数背包问题
+
+!!! question
+
+    给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$、价值为 $val[i-1]$ ，和一个容量为 $cap$ 的背包。每个物品只能选择一次，**但可以选择物品的一部分，价值根据选择的重量比例计算**，问在不超过背包容量下背包中物品的最大价值。
+
+![分数背包问题的示例数据](fractional_knapsack_problem.assets/fractional_knapsack_example.png)
+
+<p align="center"> 图 15-3 &nbsp; 分数背包问题的示例数据 </p>
+
+分数背包和 0-1 背包整体上非常相似，状态包含当前物品 $i$ 和容量 $c$ ，目标是求不超过背包容量下的最大价值。
+
+不同点在于，本题允许只选择物品的一部分。如图 15-4 所示，**我们可以对物品任意地进行切分，并按照重量比例来计算物品价值**。
+
+1. 对于物品 $i$ ，它在单位重量下的价值为 $val[i-1] / wgt[i-1]$ ，简称为单位价值。
+2. 假设放入一部分物品 $i$ ，重量为 $w$ ，则背包增加的价值为 $w \times val[i-1] / wgt[i-1]$ 。
+
+![物品在单位重量下的价值](fractional_knapsack_problem.assets/fractional_knapsack_unit_value.png)
+
+<p align="center"> 图 15-4 &nbsp; 物品在单位重量下的价值 </p>
+
+### 1. &nbsp; 贪心策略确定
+
+最大化背包内物品总价值，**本质上是要最大化单位重量下的物品价值**。由此便可推出图 15-5 所示的贪心策略。
+
+1. 将物品按照单位价值从高到低进行排序。
+2. 遍历所有物品，**每轮贪心地选择单位价值最高的物品**。
+3. 若剩余背包容量不足，则使用当前物品的一部分填满背包即可。
+
+![分数背包的贪心策略](fractional_knapsack_problem.assets/fractional_knapsack_greedy_strategy.png)
+
+<p align="center"> 图 15-5 &nbsp; 分数背包的贪心策略 </p>
+
+### 2. &nbsp; 代码实现
+
+我们建立了一个物品类 `Item` ，以便将物品按照单位价值进行排序。循环进行贪心选择，当背包已满时跳出并返回解。
+
+=== "Python"
+
+    ```python title="fractional_knapsack.py"
+    class Item:
+        """物品"""
+
+        def __init__(self, w: int, v: int):
+            self.w = w  # 物品重量
+            self.v = v  # 物品价值
+
+    def fractional_knapsack(wgt: list[int], val: list[int], cap: int) -> int:
+        """分数背包：贪心"""
+        # 创建物品列表，包含两个属性：重量、价值
+        items = [Item(w, v) for w, v in zip(wgt, val)]
+        # 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort(key=lambda item: item.v / item.w, reverse=True)
+        # 循环贪心选择
+        res = 0
+        for item in items:
+            if item.w <= cap:
+                # 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v
+                cap -= item.w
+            else:
+                # 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (item.v / item.w) * cap
+                # 已无剩余容量，因此跳出循环
+                break
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="fractional_knapsack.cpp"
+    /* 物品 */
+    class Item {
+      public:
+        int w; // 物品重量
+        int v; // 物品价值
+
+        Item(int w, int v) : w(w), v(v) {
+        }
+    };
+
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        vector<Item> items;
+        for (int i = 0; i < wgt.size(); i++) {
+            items.push_back(Item(wgt[i], val[i]));
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });
+        // 循环贪心选择
+        double res = 0;
+        for (auto &item : items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (double)item.v / item.w * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="fractional_knapsack.java"
+    /* 物品 */
+    class Item {
+        int w; // 物品重量
+        int v; // 物品价值
+
+        public Item(int w, int v) {
+            this.w = w;
+            this.v = v;
+        }
+    }
+
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(int[] wgt, int[] val, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        Item[] items = new Item[wgt.length];
+        for (int i = 0; i < wgt.length; i++) {
+            items[i] = new Item(wgt[i], val[i]);
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        Arrays.sort(items, Comparator.comparingDouble(item -> -((double) item.v / item.w)));
+        // 循环贪心选择
+        double res = 0;
+        for (Item item : items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (double) item.v / item.w * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="fractional_knapsack.cs"
+    /* 物品 */
+    class Item {
+        public int w; // 物品重量
+        public int v; // 物品价值
+
+        public Item(int w, int v) {
+            this.w = w;
+            this.v = v;
+        }
+    }
+
+    /* 分数背包：贪心 */
+    double FractionalKnapsack(int[] wgt, int[] val, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        Item[] items = new Item[wgt.Length];
+        for (int i = 0; i < wgt.Length; i++) {
+            items[i] = new Item(wgt[i], val[i]);
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        Array.Sort(items, (x, y) => (y.v / y.w).CompareTo(x.v / x.w));
+        // 循环贪心选择
+        double res = 0;
+        foreach (Item item in items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (double)item.v / item.w * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="fractional_knapsack.go"
+    /* 物品 */
+    type Item struct {
+        w int // 物品重量
+        v int // 物品价值
+    }
+
+    /* 分数背包：贪心 */
+    func fractionalKnapsack(wgt []int, val []int, cap int) float64 {
+        // 创建物品列表，包含两个属性：重量、价值
+        items := make([]Item, len(wgt))
+        for i := 0; i < len(wgt); i++ {
+            items[i] = Item{wgt[i], val[i]}
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        sort.Slice(items, func(i, j int) bool {
+            return float64(items[i].v)/float64(items[i].w) > float64(items[j].v)/float64(items[j].w)
+        })
+        // 循环贪心选择
+        res := 0.0
+        for _, item := range items {
+            if item.w <= cap {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += float64(item.v)
+                cap -= item.w
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += float64(item.v) / float64(item.w) * float64(cap)
+                // 已无剩余容量，因此跳出循环
+                break
+            }
+        }
+        return res
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="fractional_knapsack.swift"
+    /* 物品 */
+    class Item {
+        var w: Int // 物品重量
+        var v: Int // 物品价值
+
+        init(w: Int, v: Int) {
+            self.w = w
+            self.v = v
+        }
+    }
+
+    /* 分数背包：贪心 */
+    func fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -> Double {
+        // 创建物品列表，包含两个属性：重量、价值
+        var items = zip(wgt, val).map { Item(w: $0, v: $1) }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort(by: { -(Double($0.v) / Double($0.w)) < -(Double($1.v) / Double($1.w)) })
+        // 循环贪心选择
+        var res = 0.0
+        var cap = cap
+        for item in items {
+            if item.w <= cap {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += Double(item.v)
+                cap -= item.w
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += Double(item.v) / Double(item.w) * Double(cap)
+                // 已无剩余容量，因此跳出循环
+                break
+            }
+        }
+        return res
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="fractional_knapsack.js"
+    /* 物品 */
+    class Item {
+        constructor(w, v) {
+            this.w = w; // 物品重量
+            this.v = v; // 物品价值
+        }
+    }
+
+    /* 分数背包：贪心 */
+    function fractionalKnapsack(wgt, val, cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        const items = wgt.map((w, i) => new Item(w, val[i]));
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort((a, b) => b.v / b.w - a.v / a.w);
+        // 循环贪心选择
+        let res = 0;
+        for (const item of items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (item.v / item.w) * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="fractional_knapsack.ts"
+    /* 物品 */
+    class Item {
+        w: number; // 物品重量
+        v: number; // 物品价值
+
+        constructor(w: number, v: number) {
+            this.w = w;
+            this.v = v;
+        }
+    }
+
+    /* 分数背包：贪心 */
+    function fractionalKnapsack(wgt: number[], val: number[], cap: number): number {
+        // 创建物品列表，包含两个属性：重量、价值
+        const items: Item[] = wgt.map((w, i) => new Item(w, val[i]));
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort((a, b) => b.v / b.w - a.v / a.w);
+        // 循环贪心选择
+        let res = 0;
+        for (const item of items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (item.v / item.w) * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="fractional_knapsack.dart"
+    /* 物品 */
+    class Item {
+      int w; // 物品重量
+      int v; // 物品价值
+
+      Item(this.w, this.v);
+    }
+
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(List<int> wgt, List<int> val, int cap) {
+      // 创建物品列表，包含两个属性：重量、价值
+      List<Item> items = List.generate(wgt.length, (i) => Item(wgt[i], val[i]));
+      // 按照单位价值 item.v / item.w 从高到低进行排序
+      items.sort((a, b) => (b.v / b.w).compareTo(a.v / a.w));
+      // 循环贪心选择
+      double res = 0;
+      for (Item item in items) {
+        if (item.w <= cap) {
+          // 若剩余容量充足，则将当前物品整个装进背包
+          res += item.v;
+          cap -= item.w;
+        } else {
+          // 若剩余容量不足，则将当前物品的一部分装进背包
+          res += item.v / item.w * cap;
+          // 已无剩余容量，因此跳出循环
+          break;
+        }
+      }
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="fractional_knapsack.rs"
+    /* 物品 */
+    struct Item {
+        w: i32, // 物品重量
+        v: i32, // 物品价值
+    }
+
+    impl Item {
+        fn new(w: i32, v: i32) -> Self {
+            Self { w, v }
+        }
+    }
+
+    /* 分数背包：贪心 */
+    fn fractional_knapsack(wgt: &[i32], val: &[i32], mut cap: i32) -> f64 {
+        // 创建物品列表，包含两个属性：重量、价值
+        let mut items = wgt
+            .iter()
+            .zip(val.iter())
+            .map(|(&w, &v)| Item::new(w, v))
+            .collect::<Vec<Item>>();
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort_by(|a, b| {
+            (b.v as f64 / b.w as f64)
+                .partial_cmp(&(a.v as f64 / a.w as f64))
+                .unwrap()
+        });
+        // 循环贪心选择
+        let mut res = 0.0;
+        for item in &items {
+            if item.w <= cap {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v as f64;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += item.v as f64 / item.w as f64 * cap as f64;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="fractional_knapsack.c"
+    /* 物品 */
+    struct Item {
+        int w; // 物品重量
+        int v; // 物品价值
+    };
+
+    typedef struct Item Item;
+
+    /* 分数背包：贪心 */
+    float fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        Item *items = malloc(sizeof(Item) * itemCount);
+        for (int i = 0; i < itemCount; i++) {
+            items[i] = (Item){.w = wgt[i], .v = val[i]};
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);
+        // 循环贪心选择
+        float res = 0.0;
+        for (int i = 0; i < itemCount; i++) {
+            if (items[i].w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += items[i].v;
+                cap -= items[i].w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (float)cap / items[i].w * items[i].v;
+                cap = 0;
+                break;
+            }
+        }
+        free(items);
+        return res;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="fractional_knapsack.zig"
+    [class]{Item}-[func]{}
+
+    [class]{}-[func]{fractionalKnapsack}
+    ```
+
+最差情况下，需要遍历整个物品列表，**因此时间复杂度为 $O(n)$** ，其中 $n$ 为物品数量。
+
+由于初始化了一个 `Item` 对象列表，**因此空间复杂度为 $O(n)$** 。
+
+### 3. &nbsp; 正确性证明
+
+采用反证法。假设物品 $x$ 是单位价值最高的物品，使用某算法求得最大价值为 `res` ，但该解中不包含物品 $x$ 。
+
+现在从背包中拿出单位重量的任意物品，并替换为单位重量的物品 $x$ 。由于物品 $x$ 的单位价值最高，因此替换后的总价值一定大于 `res` 。**这与 `res` 是最优解矛盾，说明最优解中必须包含物品 $x$** 。
+
+对于该解中的其他物品，我们也可以构建出上述矛盾。总而言之，**单位价值更大的物品总是更优选择**，这说明贪心策略是有效的。
+
+如图 15-6 所示，如果将物品重量和物品单位价值分别看作一个 2D 图表的横轴和纵轴，则分数背包问题可被转化为“求在有限横轴区间下的最大围成面积”。这个类比可以帮助我们从几何角度理解贪心策略的有效性。
+
+![分数背包问题的几何表示](fractional_knapsack_problem.assets/fractional_knapsack_area_chart.png)
+
+<p align="center"> 图 15-6 &nbsp; 分数背包问题的几何表示 </p>

docs/chapter_greedy/greedy_algorithm.md

@@ -0,0 +1,360 @@
+---
+comments: true
+---
+
+# 15.1   贪心算法
+
+「贪心算法 greedy algorithm」是一种常见的解决优化问题的算法，其基本思想是在问题的每个决策阶段，都选择当前看起来最优的选择，即贪心地做出局部最优的决策，以期望获得全局最优解。贪心算法简洁且高效，在许多实际问题中都有着广泛的应用。
+
+贪心算法和动态规划都常用于解决优化问题。它们之间存在一些相似之处，比如都依赖最优子结构性质，但工作原理是不同的。
+
+- 动态规划会根据之前阶段的所有决策来考虑当前决策，并使用过去子问题的解来构建当前子问题的解。
+- 贪心算法不会重新考虑过去的决策，而是一路向前地进行贪心选择，不断缩小问题范围，直至问题被解决。
+
+我们先通过例题“零钱兑换”了解贪心算法的工作原理。这道题已经在动态规划章节中介绍过，相信你对它并不陌生。
+
+!!! question
+
+    给定 $n$ 种硬币，第 $i$ 种硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，每种硬币可以重复选取，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 $-1$ 。
+
+本题的贪心策略如图 15-1 所示。给定目标金额，**我们贪心地选择不大于且最接近它的硬币**，不断循环该步骤，直至凑出目标金额为止。
+
+![零钱兑换的贪心策略](greedy_algorithm.assets/coin_change_greedy_strategy.png)
+
+<p align="center"> 图 15-1 &nbsp; 零钱兑换的贪心策略 </p>
+
+实现代码如下所示。你可能会不由地发出感叹：So Clean ！贪心算法仅用十行代码就解决了零钱兑换问题。
+
+=== "Python"
+
+    ```python title="coin_change_greedy.py"
+    def coin_change_greedy(coins: list[int], amt: int) -> int:
+        """零钱兑换：贪心"""
+        # 假设 coins 列表有序
+        i = len(coins) - 1
+        count = 0
+        # 循环进行贪心选择，直到无剩余金额
+        while amt > 0:
+            # 找到小于且最接近剩余金额的硬币
+            while i > 0 and coins[i] > amt:
+                i -= 1
+            # 选择 coins[i]
+            amt -= coins[i]
+            count += 1
+        # 若未找到可行方案，则返回 -1
+        return count if amt == 0 else -1
+    ```
+
+=== "C++"
+
+    ```cpp title="coin_change_greedy.cpp"
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(vector<int> &coins, int amt) {
+        // 假设 coins 列表有序
+        int i = coins.size() - 1;
+        int count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="coin_change_greedy.java"
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(int[] coins, int amt) {
+        // 假设 coins 列表有序
+        int i = coins.length - 1;
+        int count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="coin_change_greedy.cs"
+    /* 零钱兑换：贪心 */
+    int CoinChangeGreedy(int[] coins, int amt) {
+        // 假设 coins 列表有序
+        int i = coins.Length - 1;
+        int count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="coin_change_greedy.go"
+    /* 零钱兑换：贪心 */
+    func coinChangeGreedy(coins []int, amt int) int {
+        // 假设 coins 列表有序
+        i := len(coins) - 1
+        count := 0
+        // 循环进行贪心选择，直到无剩余金额
+        for amt > 0 {
+            // 找到小于且最接近剩余金额的硬币
+            for i > 0 && coins[i] > amt {
+                i--
+            }
+            // 选择 coins[i]
+            amt -= coins[i]
+            count++
+        }
+        // 若未找到可行方案，则返回 -1
+        if amt != 0 {
+            return -1
+        }
+        return count
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="coin_change_greedy.swift"
+    /* 零钱兑换：贪心 */
+    func coinChangeGreedy(coins: [Int], amt: Int) -> Int {
+        // 假设 coins 列表有序
+        var i = coins.count - 1
+        var count = 0
+        var amt = amt
+        // 循环进行贪心选择，直到无剩余金额
+        while amt > 0 {
+            // 找到小于且最接近剩余金额的硬币
+            while i > 0 && coins[i] > amt {
+                i -= 1
+            }
+            // 选择 coins[i]
+            amt -= coins[i]
+            count += 1
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="coin_change_greedy.js"
+    /* 零钱兑换：贪心 */
+    function coinChangeGreedy(coins, amt) {
+        // 假设 coins 数组有序
+        let i = coins.length - 1;
+        let count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt === 0 ? count : -1;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="coin_change_greedy.ts"
+    /* 零钱兑换：贪心 */
+    function coinChangeGreedy(coins: number[], amt: number): number {
+        // 假设 coins 数组有序
+        let i = coins.length - 1;
+        let count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt === 0 ? count : -1;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="coin_change_greedy.dart"
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(List<int> coins, int amt) {
+      // 假设 coins 列表有序
+      int i = coins.length - 1;
+      int count = 0;
+      // 循环进行贪心选择，直到无剩余金额
+      while (amt > 0) {
+        // 找到小于且最接近剩余金额的硬币
+        while (i > 0 && coins[i] > amt) {
+          i--;
+        }
+        // 选择 coins[i]
+        amt -= coins[i];
+        count++;
+      }
+      // 若未找到可行方案，则返回 -1
+      return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="coin_change_greedy.rs"
+    /* 零钱兑换：贪心 */
+    fn coin_change_greedy(coins: &[i32], mut amt: i32) -> i32 {
+        // 假设 coins 列表有序
+        let mut i = coins.len() - 1;
+        let mut count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while amt > 0 {
+            // 找到小于且最接近剩余金额的硬币
+            while i > 0 && coins[i] > amt {
+                i -= 1;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count += 1;
+        }
+        // 若未找到可行方案，则返回 -1
+        if amt == 0 {
+            count
+        } else {
+            -1
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="coin_change_greedy.c"
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(int* coins, int size, int amt) {
+        // 假设 coins 列表有序
+        int i = size - 1;
+        int count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="coin_change_greedy.zig"
+    [class]{}-[func]{coinChangeGreedy}
+    ```
+
+## 15.1.1 &nbsp; 贪心优点与局限性
+
+**贪心算法不仅操作直接、实现简单，而且通常效率也很高**。在以上代码中，记硬币最小面值为 $\min(coins)$ ，则贪心选择最多循环 $amt / \min(coins)$ 次，时间复杂度为 $O(amt / \min(coins))$ 。这比动态规划解法的时间复杂度 $O(n \times amt)$ 提升了一个数量级。
+
+然而，**对于某些硬币面值组合，贪心算法并不能找到最优解**。图 15-2 给出了两个示例。
+
+- **正例 $coins = [1, 5, 10, 20, 50, 100]$**：在该硬币组合下，给定任意 $amt$ ，贪心算法都可以找出最优解。
+- **反例 $coins = [1, 20, 50]$**：假设 $amt = 60$ ，贪心算法只能找到 $50 + 1 \times 10$ 的兑换组合，共计 $11$ 枚硬币，但动态规划可以找到最优解 $20 + 20 + 20$ ，仅需 $3$ 枚硬币。
+- **反例 $coins = [1, 49, 50]$**：假设 $amt = 98$ ，贪心算法只能找到 $50 + 1 \times 48$ 的兑换组合，共计 $49$ 枚硬币，但动态规划可以找到最优解 $49 + 49$ ，仅需 $2$ 枚硬币。
+
+![贪心无法找出最优解的示例](greedy_algorithm.assets/coin_change_greedy_vs_dp.png)
+
+<p align="center"> 图 15-2 &nbsp; 贪心无法找出最优解的示例 </p>
+
+也就是说，对于零钱兑换问题，贪心算法无法保证找到全局最优解，并且有可能找到非常差的解。它更适合用动态规划解决。
+
+一般情况下，贪心算法适用于以下两类问题。
+
+1. **可以保证找到最优解**：贪心算法在这种情况下往往是最优选择，因为它往往比回溯、动态规划更高效。
+2. **可以找到近似最优解**：贪心算法在这种情况下也是可用的。对于很多复杂问题来说，寻找全局最优解是非常困难的，能以较高效率找到次优解也是非常不错的。
+
+## 15.1.2 &nbsp; 贪心算法特性
+
+那么问题来了，什么样的问题适合用贪心算法求解呢？或者说，贪心算法在什么情况下可以保证找到最优解？
+
+相较于动态规划，贪心算法的使用条件更加苛刻，其主要关注问题的两个性质。
+
+- **贪心选择性质**：只有当局部最优选择始终可以导致全局最优解时，贪心算法才能保证得到最优解。
+- **最优子结构**：原问题的最优解包含子问题的最优解。
+
+最优子结构已经在动态规划章节中介绍过，不再赘述。值得注意的是，一些问题的最优子结构并不明显，但仍然可使用贪心算法解决。
+
+我们主要探究贪心选择性质的判断方法。虽然它的描述看上去比较简单，**但实际上对于许多问题，证明贪心选择性质不是一件易事**。
+
+例如零钱兑换问题，我们虽然能够容易地举出反例，对贪心选择性质进行证伪，但证实的难度较大。如果问：**满足什么条件的硬币组合可以使用贪心算法求解**？我们往往只能凭借直觉或举例子来给出一个模棱两可的答案，而难以给出严谨的数学证明。
+
+!!! quote
+
+    有一篇论文给出了一个 $O(n^3)$ 时间复杂度的算法，用于判断一个硬币组合是否可以使用贪心算法找出任何金额的最优解。
+
+    Pearson, David. A polynomial-time algorithm for the change-making problem. Operations Research Letters 33.3 (2005): 231-234.
+
+## 15.1.3 &nbsp; 贪心解题步骤
+
+贪心问题的解决流程大体可分为以下三步。
+
+1. **问题分析**：梳理与理解问题特性，包括状态定义、优化目标和约束条件等。这一步在回溯和动态规划中都有涉及。
+2. **确定贪心策略**：确定如何在每一步中做出贪心选择。这个策略能够在每一步减小问题的规模，并最终能解决整个问题。
+3. **正确性证明**：通常需要证明问题具有贪心选择性质和最优子结构。这个步骤可能需要使用到数学证明，例如归纳法或反证法等。
+
+确定贪心策略是求解问题的核心步骤，但实施起来可能并不容易，主要包含以下原因。
+
+- **不同问题的贪心策略的差异较大**。对于许多问题来说，贪心策略都比较浅显，我们通过一些大概的思考与尝试就能得出。而对于一些复杂问题，贪心策略可能非常隐蔽，这种情况就非常考验个人的解题经验与算法能力了。
+- **某些贪心策略具有较强的迷惑性**。当我们满怀信心设计好贪心策略，写出解题代码并提交运行，很可能发现部分测试样例无法通过。这是因为设计的贪心策略只是“部分正确”的，上文介绍的零钱兑换就是个典型案例。
+
+为了保证正确性，我们应该对贪心策略进行严谨的数学证明，**通常需要用到反证法或数学归纳法**。
+
+然而，正确性证明也很可能不是一件易事。如若没有头绪，我们通常会选择面向测试用例进行 Debug ，一步步修改与验证贪心策略。
+
+## 15.1.4 &nbsp; 贪心典型例题
+
+贪心算法常常应用在满足贪心选择性质和最优子结构的优化问题中，以下列举了一些典型的贪心算法问题。
+
+- **硬币找零问题**：在某些硬币组合下，贪心算法总是可以得到最优解。
+- **区间调度问题**：假设你有一些任务，每个任务在一段时间内进行，你的目标是完成尽可能多的任务。如果每次都选择结束时间最早的任务，那么贪心算法就可以得到最优解。
+- **分数背包问题**：给定一组物品和一个载重量，你的目标是选择一组物品，使得总重量不超过载重量，且总价值最大。如果每次都选择性价比最高（价值 / 重量）的物品，那么贪心算法在一些情况下可以得到最优解。
+- **股票买卖问题**：给定一组股票的历史价格，你可以进行多次买卖，但如果你已经持有股票，那么在卖出之前不能再买，目标是获取最大利润。
+- **霍夫曼编码**：霍夫曼编码是一种用于无损数据压缩的贪心算法。通过构建霍夫曼树，每次选择出现频率最小的两个节点合并，最后得到的霍夫曼树的带权路径长度（即编码长度）最小。
+- **Dijkstra 算法**：它是一种解决给定源顶点到其余各顶点的最短路径问题的贪心算法。

docs/chapter_greedy/index.md

@@ -0,0 +1,26 @@
+---
+comments: true
+icon: material/head-heart-outline
+---
+
+# 第 15 章   贪心
+
+<div class="center-table" markdown>
+
+![贪心](../assets/covers/chapter_greedy.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    向日葵朝着太阳转动，时刻都在追求自身成长的最大可能。
+
+    贪心策略在一轮轮的简单选择中，逐步导向最佳的答案。
+
+## 本章内容
+
+- [15.1 &nbsp; 贪心算法](https://www.hello-algo.com/chapter_greedy/greedy_algorithm/)
+- [15.2 &nbsp; 分数背包问题](https://www.hello-algo.com/chapter_greedy/fractional_knapsack_problem/)
+- [15.3 &nbsp; 最大容量问题](https://www.hello-algo.com/chapter_greedy/max_capacity_problem/)
+- [15.4 &nbsp; 最大切分乘积问题](https://www.hello-algo.com/chapter_greedy/max_product_cutting_problem/)
+- [15.5 &nbsp; 小结](https://www.hello-algo.com/chapter_greedy/summary/)

docs/chapter_greedy/max_capacity_problem.md

@@ -0,0 +1,393 @@
+---
+comments: true
+---
+
+# 15.3   最大容量问题
+
+!!! question
+
+    输入一个数组 $ht$ ，数组中的每个元素代表一个垂直隔板的高度。数组中的任意两个隔板，以及它们之间的空间可以组成一个容器。
+    
+    容器的容量等于高度和宽度的乘积（即面积），其中高度由较短的隔板决定，宽度是两个隔板的数组索引之差。
+    
+    请在数组中选择两个隔板，使得组成的容器的容量最大，返回最大容量。
+
+![最大容量问题的示例数据](max_capacity_problem.assets/max_capacity_example.png)
+
+<p align="center"> 图 15-7 &nbsp; 最大容量问题的示例数据 </p>
+
+容器由任意两个隔板围成，**因此本题的状态为两个隔板的索引，记为 $[i, j]$** 。
+
+根据题意，容量等于高度乘以宽度，其中高度由短板决定，宽度是两隔板的索引之差。设容量为 $cap[i, j]$ ，则可得计算公式：
+
+$$
+cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
+$$
+
+设数组长度为 $n$ ，两个隔板的组合数量（即状态总数）为 $C_n^2 = \frac{n(n - 1)}{2}$ 个。最直接地，**我们可以穷举所有状态**，从而求得最大容量，时间复杂度为 $O(n^2)$ 。
+
+### 1. &nbsp; 贪心策略确定
+
+这道题还有更高效率的解法。如图 15-8 所示，现选取一个状态 $[i, j]$ ，其满足索引 $i < j$ 且高度 $ht[i] < ht[j]$ ，即 $i$ 为短板、$j$ 为长板。
+
+![初始状态](max_capacity_problem.assets/max_capacity_initial_state.png)
+
+<p align="center"> 图 15-8 &nbsp; 初始状态 </p>
+
+如图 15-9 所示，**若此时将长板 $j$ 向短板 $i$ 靠近，则容量一定变小**。
+
+这是因为在移动长板 $j$ 后，宽度 $j-i$ 肯定变小；而高度由短板决定，因此高度只可能不变（ $i$ 仍为短板）或变小（移动后的 $j$ 成为短板）。
+
+![向内移动长板后的状态](max_capacity_problem.assets/max_capacity_moving_long_board.png)
+
+<p align="center"> 图 15-9 &nbsp; 向内移动长板后的状态 </p>
+
+反向思考，**我们只有向内收缩短板 $i$ ，才有可能使容量变大**。因为虽然宽度一定变小，**但高度可能会变大**（移动后的短板 $i$ 可能会变长）。例如在图 15-10 中，移动短板后面积变大。
+
+![向内移动短板后的状态](max_capacity_problem.assets/max_capacity_moving_short_board.png)
+
+<p align="center"> 图 15-10 &nbsp; 向内移动短板后的状态 </p>
+
+由此便可推出本题的贪心策略：初始化两指针分裂容器两端，每轮向内收缩短板对应的指针，直至两指针相遇。
+
+图 15-11 展示了贪心策略的执行过程。
+
+1. 初始状态下，指针 $i$ 和 $j$ 分列与数组两端。
+2. 计算当前状态的容量 $cap[i, j]$ ，并更新最大容量。
+3. 比较板 $i$ 和 板 $j$ 的高度，并将短板向内移动一格。
+4. 循环执行第 `2.` 和 `3.` 步，直至 $i$ 和 $j$ 相遇时结束。
+
+=== "<1>"
+    ![最大容量问题的贪心过程](max_capacity_problem.assets/max_capacity_greedy_step1.png)
+
+=== "<2>"
+    ![max_capacity_greedy_step2](max_capacity_problem.assets/max_capacity_greedy_step2.png)
+
+=== "<3>"
+    ![max_capacity_greedy_step3](max_capacity_problem.assets/max_capacity_greedy_step3.png)
+
+=== "<4>"
+    ![max_capacity_greedy_step4](max_capacity_problem.assets/max_capacity_greedy_step4.png)
+
+=== "<5>"
+    ![max_capacity_greedy_step5](max_capacity_problem.assets/max_capacity_greedy_step5.png)
+
+=== "<6>"
+    ![max_capacity_greedy_step6](max_capacity_problem.assets/max_capacity_greedy_step6.png)
+
+=== "<7>"
+    ![max_capacity_greedy_step7](max_capacity_problem.assets/max_capacity_greedy_step7.png)
+
+=== "<8>"
+    ![max_capacity_greedy_step8](max_capacity_problem.assets/max_capacity_greedy_step8.png)
+
+=== "<9>"
+    ![max_capacity_greedy_step9](max_capacity_problem.assets/max_capacity_greedy_step9.png)
+
+<p align="center"> 图 15-11 &nbsp; 最大容量问题的贪心过程 </p>
+
+### 2. &nbsp; 代码实现
+
+代码循环最多 $n$ 轮，**因此时间复杂度为 $O(n)$** 。
+
+变量 $i$、$j$、$res$ 使用常数大小额外空间，**因此空间复杂度为 $O(1)$** 。
+
+=== "Python"
+
+    ```python title="max_capacity.py"
+    def max_capacity(ht: list[int]) -> int:
+        """最大容量：贪心"""
+        # 初始化 i, j 分列数组两端
+        i, j = 0, len(ht) - 1
+        # 初始最大容量为 0
+        res = 0
+        # 循环贪心选择，直至两板相遇
+        while i < j:
+            # 更新最大容量
+            cap = min(ht[i], ht[j]) * (j - i)
+            res = max(res, cap)
+            # 向内移动短板
+            if ht[i] < ht[j]:
+                i += 1
+            else:
+                j -= 1
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="max_capacity.cpp"
+    /* 最大容量：贪心 */
+    int maxCapacity(vector<int> &ht) {
+        // 初始化 i, j 分列数组两端
+        int i = 0, j = ht.size() - 1;
+        // 初始最大容量为 0
+        int res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = min(ht[i], ht[j]) * (j - i);
+            res = max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="max_capacity.java"
+    /* 最大容量：贪心 */
+    int maxCapacity(int[] ht) {
+        // 初始化 i, j 分列数组两端
+        int i = 0, j = ht.length - 1;
+        // 初始最大容量为 0
+        int res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="max_capacity.cs"
+    /* 最大容量：贪心 */
+    int MaxCapacity(int[] ht) {
+        // 初始化 i, j 分列数组两端
+        int i = 0, j = ht.Length - 1;
+        // 初始最大容量为 0
+        int res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = Math.Min(ht[i], ht[j]) * (j - i);
+            res = Math.Max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="max_capacity.go"
+    /* 最大容量：贪心 */
+    func maxCapacity(ht []int) int {
+        // 初始化 i, j 分列数组两端
+        i, j := 0, len(ht)-1
+        // 初始最大容量为 0
+        res := 0
+        // 循环贪心选择，直至两板相遇
+        for i < j {
+            // 更新最大容量
+            capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)
+            res = int(math.Max(float64(res), float64(capacity)))
+            // 向内移动短板
+            if ht[i] < ht[j] {
+                i++
+            } else {
+                j--
+            }
+        }
+        return res
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="max_capacity.swift"
+    /* 最大容量：贪心 */
+    func maxCapacity(ht: [Int]) -> Int {
+        // 初始化 i, j 分列数组两端
+        var i = 0, j = ht.count - 1
+        // 初始最大容量为 0
+        var res = 0
+        // 循环贪心选择，直至两板相遇
+        while i < j {
+            // 更新最大容量
+            let cap = min(ht[i], ht[j]) * (j - i)
+            res = max(res, cap)
+            // 向内移动短板
+            if ht[i] < ht[j] {
+                i += 1
+            } else {
+                j -= 1
+            }
+        }
+        return res
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="max_capacity.js"
+    /* 最大容量：贪心 */
+    function maxCapacity(ht) {
+        // 初始化 i, j 分列数组两端
+        let i = 0,
+            j = ht.length - 1;
+        // 初始最大容量为 0
+        let res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            const cap = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="max_capacity.ts"
+    /* 最大容量：贪心 */
+    function maxCapacity(ht: number[]): number {
+        // 初始化 i, j 分列数组两端
+        let i = 0,
+            j = ht.length - 1;
+        // 初始最大容量为 0
+        let res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            const cap: number = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="max_capacity.dart"
+    /* 最大容量：贪心 */
+    int maxCapacity(List<int> ht) {
+      // 初始化 i, j 分列数组两端
+      int i = 0, j = ht.length - 1;
+      // 初始最大容量为 0
+      int res = 0;
+      // 循环贪心选择，直至两板相遇
+      while (i < j) {
+        // 更新最大容量
+        int cap = min(ht[i], ht[j]) * (j - i);
+        res = max(res, cap);
+        // 向内移动短板
+        if (ht[i] < ht[j]) {
+          i++;
+        } else {
+          j--;
+        }
+      }
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="max_capacity.rs"
+    /* 最大容量：贪心 */
+    fn max_capacity(ht: &[i32]) -> i32 {
+        // 初始化 i, j 分列数组两端
+        let mut i = 0;
+        let mut j = ht.len() - 1;
+        // 初始最大容量为 0
+        let mut res = 0;
+        // 循环贪心选择，直至两板相遇
+        while i < j {
+            // 更新最大容量
+            let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;
+            res = std::cmp::max(res, cap);
+            // 向内移动短板
+            if ht[i] < ht[j] {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="max_capacity.c"
+    /* 最大容量：贪心 */
+    int maxCapacity(int ht[], int htLength) {
+        // 初始化 i, j 分列数组两端
+        int i = 0;
+        int j = htLength - 1;
+        // 初始最大容量为 0
+        int res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            int capacity = MIN(ht[i], ht[j]) * (j - i);
+            res = MAX(res, capacity);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="max_capacity.zig"
+    [class]{}-[func]{maxCapacity}
+    ```
+
+### 3. &nbsp; 正确性证明
+
+之所以贪心比穷举更快，是因为每轮的贪心选择都会“跳过”一些状态。
+
+比如在状态 $cap[i, j]$ 下，$i$ 为短板、$j$ 为长板。若贪心地将短板 $i$ 向内移动一格，会导致图 15-12 所示的状态被“跳过”。**这意味着之后无法验证这些状态的容量大小**。
+
+$$
+cap[i, i+1], cap[i, i+2], \dots, cap[i, j-2], cap[i, j-1]
+$$
+
+![移动短板导致被跳过的状态](max_capacity_problem.assets/max_capacity_skipped_states.png)
+
+<p align="center"> 图 15-12 &nbsp; 移动短板导致被跳过的状态 </p>
+
+观察发现，**这些被跳过的状态实际上就是将长板 $j$ 向内移动的所有状态**。而在第二步中，我们已经证明内移长板一定会导致容量变小。也就是说，被跳过的状态都不可能是最优解，**跳过它们不会导致错过最优解**。
+
+以上的分析说明，**移动短板的操作是“安全”的**，贪心策略是有效的。

docs/chapter_greedy/max_product_cutting_problem.md

@@ -0,0 +1,369 @@
+---
+comments: true
+---
+
+# 15.4   最大切分乘积问题
+
+!!! question
+
+    给定一个正整数 $n$ ，将其切分为至少两个正整数的和，求切分后所有整数的乘积最大是多少。
+
+![最大切分乘积的问题定义](max_product_cutting_problem.assets/max_product_cutting_definition.png)
+
+<p align="center"> 图 15-13 &nbsp; 最大切分乘积的问题定义 </p>
+
+假设我们将 $n$ 切分为 $m$ 个整数因子，其中第 $i$ 个因子记为 $n_i$ ，即
+
+$$
+n = \sum_{i=1}^{m}n_i
+$$
+
+本题目标是求得所有整数因子的最大乘积，即
+
+$$
+\max(\prod_{i=1}^{m}n_i)
+$$
+
+我们需要思考的是：切分数量 $m$ 应该多大，每个 $n_i$ 应该是多少？
+
+### 1. &nbsp; 贪心策略确定
+
+根据经验，两个整数的乘积往往比它们的加和更大。假设从 $n$ 中分出一个因子 $2$ ，则它们的乘积为 $2(n-2)$ 。我们将该乘积与 $n$ 作比较：
+
+$$
+\begin{aligned}
+2(n-2) & \geq n \newline
+2n - n - 4 & \geq 0 \newline
+n & \geq 4
+\end{aligned}
+$$
+
+如图 15-14 所示，当 $n \geq 4$ 时，切分出一个 $2$ 后乘积会变大，**这说明大于等于 $4$ 的整数都应该被切分**。
+
+**贪心策略一**：如果切分方案中包含 $\geq 4$ 的因子，那么它就应该被继续切分。最终的切分方案只应出现 $1$、$2$、$3$ 这三种因子。
+
+![切分导致乘积变大](max_product_cutting_problem.assets/max_product_cutting_greedy_infer1.png)
+
+<p align="center"> 图 15-14 &nbsp; 切分导致乘积变大 </p>
+
+接下来思考哪个因子是最优的。在 $1$、$2$、$3$ 这三个因子中，显然 $1$ 是最差的，因为 $1 \times (n-1) < n$ 恒成立，即切分出 $1$ 反而会导致乘积减小。
+
+如图 15-15 所示，当 $n = 6$ 时，有 $3 \times 3 > 2 \times 2 \times 2$ 。**这意味着切分出 $3$ 比切分出 $2$ 更优**。
+
+**贪心策略二**：在切分方案中，最多只应存在两个 $2$ 。因为三个 $2$ 总是可以被替换为两个 $3$ ，从而获得更大乘积。
+
+![最优切分因子](max_product_cutting_problem.assets/max_product_cutting_greedy_infer2.png)
+
+<p align="center"> 图 15-15 &nbsp; 最优切分因子 </p>
+
+总结以上，可推出以下贪心策略。
+
+1. 输入整数 $n$ ，从其不断地切分出因子 $3$ ，直至余数为 $0$、$1$、$2$ 。
+2. 当余数为 $0$ 时，代表 $n$ 是 $3$ 的倍数，因此不做任何处理。
+3. 当余数为 $2$ 时，不继续划分，保留之。
+4. 当余数为 $1$ 时，由于 $2 \times 2 > 1 \times 3$ ，因此应将最后一个 $3$ 替换为 $2$ 。
+
+### 2. &nbsp; 代码实现
+
+如图 15-16 所示，我们无须通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
+
+$$
+n = 3 a + b
+$$
+
+请注意，对于 $n \leq 3$ 的边界情况，必须拆分出一个 $1$ ，乘积为 $1 \times (n - 1)$ 。
+
+=== "Python"
+
+    ```python title="max_product_cutting.py"
+    def max_product_cutting(n: int) -> int:
+        """最大切分乘积：贪心"""
+        # 当 n <= 3 时，必须切分出一个 1
+        if n <= 3:
+            return 1 * (n - 1)
+        # 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        a, b = n // 3, n % 3
+        if b == 1:
+            # 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return int(math.pow(3, a - 1)) * 2 * 2
+        if b == 2:
+            # 当余数为 2 时，不做处理
+            return int(math.pow(3, a)) * 2
+        # 当余数为 0 时，不做处理
+        return int(math.pow(3, a))
+    ```
+
+=== "C++"
+
+    ```cpp title="max_product_cutting.cpp"
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return (int)pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return (int)pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return (int)pow(3, a);
+    }
+    ```
+
+=== "Java"
+
+    ```java title="max_product_cutting.java"
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return (int) Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return (int) Math.pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return (int) Math.pow(3, a);
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="max_product_cutting.cs"
+    /* 最大切分乘积：贪心 */
+    int MaxProductCutting(int n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return (int)Math.Pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return (int)Math.Pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return (int)Math.Pow(3, a);
+    }
+    ```
+
+=== "Go"
+
+    ```go title="max_product_cutting.go"
+    /* 最大切分乘积：贪心 */
+    func maxProductCutting(n int) int {
+        // 当 n <= 3 时，必须切分出一个 1
+        if n <= 3 {
+            return 1 * (n - 1)
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        a := n / 3
+        b := n % 3
+        if b == 1 {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return int(math.Pow(3, float64(a-1))) * 2 * 2
+        }
+        if b == 2 {
+            // 当余数为 2 时，不做处理
+            return int(math.Pow(3, float64(a))) * 2
+        }
+        // 当余数为 0 时，不做处理
+        return int(math.Pow(3, float64(a)))
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="max_product_cutting.swift"
+    /* 最大切分乘积：贪心 */
+    func maxProductCutting(n: Int) -> Int {
+        // 当 n <= 3 时，必须切分出一个 1
+        if n <= 3 {
+            return 1 * (n - 1)
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        let a = n / 3
+        let b = n % 3
+        if b == 1 {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return pow(3, a - 1) * 2 * 2
+        }
+        if b == 2 {
+            // 当余数为 2 时，不做处理
+            return pow(3, a) * 2
+        }
+        // 当余数为 0 时，不做处理
+        return pow(3, a)
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="max_product_cutting.js"
+    /* 最大切分乘积：贪心 */
+    function maxProductCutting(n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        let a = Math.floor(n / 3);
+        let b = n % 3;
+        if (b === 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b === 2) {
+            // 当余数为 2 时，不做处理
+            return Math.pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return Math.pow(3, a);
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="max_product_cutting.ts"
+    /* 最大切分乘积：贪心 */
+    function maxProductCutting(n: number): number {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        let a: number = Math.floor(n / 3);
+        let b: number = n % 3;
+        if (b === 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b === 2) {
+            // 当余数为 2 时，不做处理
+            return Math.pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return Math.pow(3, a);
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="max_product_cutting.dart"
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+      // 当 n <= 3 时，必须切分出一个 1
+      if (n <= 3) {
+        return 1 * (n - 1);
+      }
+      // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+      int a = n ~/ 3;
+      int b = n % 3;
+      if (b == 1) {
+        // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+        return (pow(3, a - 1) * 2 * 2).toInt();
+      }
+      if (b == 2) {
+        // 当余数为 2 时，不做处理
+        return (pow(3, a) * 2).toInt();
+      }
+      // 当余数为 0 时，不做处理
+      return pow(3, a).toInt();
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="max_product_cutting.rs"
+    /* 最大切分乘积：贪心 */
+    fn max_product_cutting(n: i32) -> i32 {
+        // 当 n <= 3 时，必须切分出一个 1
+        if n <= 3 {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        let a = n / 3;
+        let b = n % 3;
+        if b == 1 {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            3_i32.pow(a as u32 - 1) * 2 * 2
+        } else if b == 2 {
+            // 当余数为 2 时，不做处理
+            3_i32.pow(a as u32) * 2
+        } else {
+            // 当余数为 0 时，不做处理
+            3_i32.pow(a as u32)
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="max_product_cutting.c"
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return pow(3, a);
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="max_product_cutting.zig"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+![最大切分乘积的计算方法](max_product_cutting_problem.assets/max_product_cutting_greedy_calculation.png)
+
+<p align="center"> 图 15-16 &nbsp; 最大切分乘积的计算方法 </p>
+
+**时间复杂度取决于编程语言的幂运算的实现方法**。以 Python 为例，常用的幂计算函数有三种。
+
+- 运算符 `**` 和函数 `pow()` 的时间复杂度均为 $O(\log⁡ a)$ 。
+- 函数 `math.pow()` 内部调用 C 语言库的 `pow()` 函数，其执行浮点取幂，时间复杂度为 $O(1)$ 。
+
+变量 $a$ 和 $b$ 使用常数大小的额外空间，**因此空间复杂度为 $O(1)$** 。
+
+### 3. &nbsp; 正确性证明
+
+使用反证法，只分析 $n \geq 3$ 的情况。
+
+1. **所有因子 $\leq 3$** ：假设最优切分方案中存在 $\geq 4$ 的因子 $x$ ，那么一定可以将其继续划分为 $2(x-2)$ ，从而获得更大的乘积。这与假设矛盾。
+2. **切分方案不包含 $1$** ：假设最优切分方案中存在一个因子 $1$ ，那么它一定可以合并入另外一个因子中，以获取更大乘积。这与假设矛盾。
+3. **切分方案最多包含两个 $2$** ：假设最优切分方案中包含三个 $2$ ，那么一定可以替换为两个 $3$ ，乘积更大。这与假设矛盾。

docs/chapter_greedy/summary.md

@@ -0,0 +1,16 @@
+---
+comments: true
+---
+
+# 15.5   小结
+
+- 贪心算法通常用于解决最优化问题，其原理是在每个决策阶段都做出局部最优的决策，以期望获得全局最优解。
+- 贪心算法会迭代地做出一个又一个的贪心选择，每轮都将问题转化成一个规模更小的子问题，直到问题被解决。
+- 贪心算法不仅实现简单，还具有很高的解题效率。相比于动态规划，贪心算法的时间复杂度通常更低。
+- 在零钱兑换问题中，对于某些硬币组合，贪心算法可以保证找到最优解；对于另外一些硬币组合则不然，贪心算法可能找到很差的解。
+- 适合用贪心算法求解的问题具有两大性质：贪心选择性质和最优子结构。贪心选择性质代表贪心策略的有效性。
+- 对于某些复杂问题，贪心选择性质的证明并不简单。相对来说，证伪更加容易，例如零钱兑换问题。
+- 求解贪心问题主要分为三步：问题分析、贪心策略确定、正确性证明。其中，贪心策略确定是核心步骤，正确性证明往往是难点。
+- 分数背包问题在 0-1 背包的基础上，允许选择物品的一部分，因此可使用贪心算法求解。贪心策略的正确性可以使用反证法来证明。
+- 最大容量问题可使用穷举法求解，时间复杂度为 $O(n^2)$ 。通过设计贪心策略，每轮向内移动短板，可将时间复杂度优化至 $O(n)$ 。
+- 在最大切分乘积问题中，我们先后推理出两个贪心策略：$\geq 4$ 的整数都应该继续切分、最优切分因子为 $3$ 。代码中包含幂运算，时间复杂度取决于幂运算实现方法，通常为 $O(1)$ 或 $O(\log n)$ 。

docs/chapter_hashing/hash_algorithm.md

@@ -0,0 +1,877 @@
+---
+comments: true
+---
+
+# 6.3   哈希算法
+
+在上两节中，我们了解了哈希表的工作原理和哈希冲突的处理方法。然而无论是开放寻址还是链地址法，**它们只能保证哈希表可以在发生冲突时正常工作，但无法减少哈希冲突的发生**。
+
+如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。如图 6-8 所示，对于链地址哈希表，理想情况下键值对平均分布在各个桶中，达到最佳查询效率；最差情况下所有键值对都被存储到同一个桶中，时间复杂度退化至 $O(n)$ 。
+
+![哈希冲突的最佳与最差情况](hash_algorithm.assets/hash_collision_best_worst_condition.png)
+
+<p align="center"> 图 6-8 &nbsp; 哈希冲突的最佳与最差情况 </p>
+
+**键值对的分布情况由哈希函数决定**。回忆哈希函数的计算步骤，先计算哈希值，再对数组长度取模：
+
+```shell
+index = hash(key) % capacity
+```
+
+观察以上公式，当哈希表容量 `capacity` 固定时，**哈希算法 `hash()` 决定了输出值**，进而决定了键值对在哈希表中的分布情况。
+
+这意味着，为了减小哈希冲突的发生概率，我们应当将注意力集中在哈希算法 `hash()` 的设计上。
+
+## 6.3.1 &nbsp; 哈希算法的目标
+
+为了实现“既快又稳”的哈希表数据结构，哈希算法应包含以下特点。
+
+- **确定性**：对于相同的输入，哈希算法应始终产生相同的输出。这样才能确保哈希表是可靠的。
+- **效率高**：计算哈希值的过程应该足够快。计算开销越小，哈希表的实用性越高。
+- **均匀分布**：哈希算法应使得键值对平均分布在哈希表中。分布越平均，哈希冲突的概率就越低。
+
+实际上，哈希算法除了可以用于实现哈希表，还广泛应用于其他领域中。
+
+- **密码存储**：为了保护用户密码的安全，系统通常不会直接存储用户的明文密码，而是存储密码的哈希值。当用户输入密码时，系统会对输入的密码计算哈希值，然后与存储的哈希值进行比较。如果两者匹配，那么密码就被视为正确。
+- **数据完整性检查**：数据发送方可以计算数据的哈希值并将其一同发送；接收方可以重新计算接收到的数据的哈希值，并与接收到的哈希值进行比较。如果两者匹配，那么数据就被视为完整的。
+
+对于密码学的相关应用，为了防止从哈希值推导出原始密码等逆向工程，哈希算法需要具备更高等级的安全特性。
+
+- **单向性**：无法通过哈希值反推出关于输入数据的任何信息。
+- **抗碰撞性**：应当极其困难找到两个不同的输入，使得它们的哈希值相同。
+- **雪崩效应**：输入的微小变化应当导致输出的显著且不可预测的变化。
+
+请注意，**“均匀分布”与“抗碰撞性”是两个独立的概念**，满足均匀分布不一定满足抗碰撞性。例如，在随机输入 `key` 下，哈希函数 `key % 100` 可以产生均匀分布的输出。然而该哈希算法过于简单，所有后两位相等的 `key` 的输出都相同，因此我们可以很容易地从哈希值反推出可用的 `key` ，从而破解密码。
+
+## 6.3.2 &nbsp; 哈希算法的设计
+
+哈希算法的设计是一个需要考虑许多因素的复杂问题。然而对于某些要求不高的场景，我们也能设计一些简单的哈希算法。
+
+- **加法哈希**：对输入的每个字符的 ASCII 码进行相加，将得到的总和作为哈希值。
+- **乘法哈希**：利用了乘法的不相关性，每轮乘以一个常数，将各个字符的 ASCII 码累积到哈希值中。
+- **异或哈希**：将输入数据的每个元素通过异或操作累积到一个哈希值中。
+- **旋转哈希**：将每个字符的 ASCII 码累积到一个哈希值中，每次累积之前都会对哈希值进行旋转操作。
+
+=== "Python"
+
+    ```python title="simple_hash.py"
+    def add_hash(key: str) -> int:
+        """加法哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash += ord(c)
+        return hash % modulus
+
+    def mul_hash(key: str) -> int:
+        """乘法哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash = 31 * hash + ord(c)
+        return hash % modulus
+
+    def xor_hash(key: str) -> int:
+        """异或哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash ^= ord(c)
+        return hash % modulus
+
+    def rot_hash(key: str) -> int:
+        """旋转哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash = (hash << 4) ^ (hash >> 28) ^ ord(c)
+        return hash % modulus
+    ```
+
+=== "C++"
+
+    ```cpp title="simple_hash.cpp"
+    /* 加法哈希 */
+    int addHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = (hash + (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* 乘法哈希 */
+    int mulHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = (31 * hash + (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* 异或哈希 */
+    int xorHash(string key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash ^= (int)c;
+        }
+        return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    int rotHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="simple_hash.java"
+    /* 加法哈希 */
+    int addHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
+
+    /* 乘法哈希 */
+    int mulHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (31 * hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
+
+    /* 异或哈希 */
+    int xorHash(String key) {
+        int hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash ^= (int) c;
+        }
+        return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    int rotHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="simple_hash.cs"
+    /* 加法哈希 */
+    int AddHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = (hash + c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* 乘法哈希 */
+    int MulHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = (31 * hash + c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* 异或哈希 */
+    int XorHash(string key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash ^= c;
+        }
+        return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    int RotHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;
+        }
+        return (int)hash;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="simple_hash.go"
+    /* 加法哈希 */
+    func addHash(key string) int {
+        var hash int64
+        var modulus int64
+
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = (hash + int64(b)) % modulus
+        }
+        return int(hash)
+    }
+
+    /* 乘法哈希 */
+    func mulHash(key string) int {
+        var hash int64
+        var modulus int64
+
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = (31*hash + int64(b)) % modulus
+        }
+        return int(hash)
+    }
+
+    /* 异或哈希 */
+    func xorHash(key string) int {
+        hash := 0
+        modulus := 1000000007
+        for _, b := range []byte(key) {
+            fmt.Println(int(b))
+            hash ^= int(b)
+            hash = (31*hash + int(b)) % modulus
+        }
+        return hash & modulus
+    }
+
+    /* 旋转哈希 */
+    func rotHash(key string) int {
+        var hash int64
+        var modulus int64
+
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus
+        }
+        return int(hash)
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="simple_hash.swift"
+    /* 加法哈希 */
+    func addHash(key: String) -> Int {
+        var hash = 0
+        let MODULUS = 1_000_000_007
+        for c in key {
+            for scalar in c.unicodeScalars {
+                hash = (hash + Int(scalar.value)) % MODULUS
+            }
+        }
+        return hash
+    }
+
+    /* 乘法哈希 */
+    func mulHash(key: String) -> Int {
+        var hash = 0
+        let MODULUS = 1_000_000_007
+        for c in key {
+            for scalar in c.unicodeScalars {
+                hash = (31 * hash + Int(scalar.value)) % MODULUS
+            }
+        }
+        return hash
+    }
+
+    /* 异或哈希 */
+    func xorHash(key: String) -> Int {
+        var hash = 0
+        let MODULUS = 1_000_000_007
+        for c in key {
+            for scalar in c.unicodeScalars {
+                hash ^= Int(scalar.value)
+            }
+        }
+        return hash & MODULUS
+    }
+
+    /* 旋转哈希 */
+    func rotHash(key: String) -> Int {
+        var hash = 0
+        let MODULUS = 1_000_000_007
+        for c in key {
+            for scalar in c.unicodeScalars {
+                hash = ((hash << 4) ^ (hash >> 28) ^ Int(scalar.value)) % MODULUS
+            }
+        }
+        return hash
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="simple_hash.js"
+    /* 加法哈希 */
+    function addHash(key) {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = (hash + c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
+
+    /* 乘法哈希 */
+    function mulHash(key) {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = (31 * hash + c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
+
+    /* 异或哈希 */
+    function xorHash(key) {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash ^= c.charCodeAt(0);
+        }
+        return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    function rotHash(key) {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="simple_hash.ts"
+    /* 加法哈希 */
+    function addHash(key: string): number {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = (hash + c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
+
+    /* 乘法哈希 */
+    function mulHash(key: string): number {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = (31 * hash + c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
+
+    /* 异或哈希 */
+    function xorHash(key: string): number {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash ^= c.charCodeAt(0);
+        }
+        return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    function rotHash(key: string): number {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="simple_hash.dart"
+    /* 加法哈希 */
+    int addHash(String key) {
+      int hash = 0;
+      final int MODULUS = 1000000007;
+      for (int i = 0; i < key.length; i++) {
+        hash = (hash + key.codeUnitAt(i)) % MODULUS;
+      }
+      return hash;
+    }
+
+    /* 乘法哈希 */
+    int mulHash(String key) {
+      int hash = 0;
+      final int MODULUS = 1000000007;
+      for (int i = 0; i < key.length; i++) {
+        hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;
+      }
+      return hash;
+    }
+
+    /* 异或哈希 */
+    int xorHash(String key) {
+      int hash = 0;
+      final int MODULUS = 1000000007;
+      for (int i = 0; i < key.length; i++) {
+        hash ^= key.codeUnitAt(i);
+      }
+      return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    int rotHash(String key) {
+      int hash = 0;
+      final int MODULUS = 1000000007;
+      for (int i = 0; i < key.length; i++) {
+        hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;
+      }
+      return hash;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="simple_hash.rs"
+    /* 加法哈希 */
+    fn add_hash(key: &str) -> i32 {
+        let mut hash = 0_i64;
+        const MODULUS: i64 = 1000000007;
+
+        for c in key.chars() {
+            hash = (hash + c as i64) % MODULUS;
+        }
+
+        hash as i32
+    } 
+
+    /* 乘法哈希 */
+    fn mul_hash(key: &str) -> i32 {
+        let mut hash = 0_i64;
+        const MODULUS: i64 = 1000000007;
+
+        for c in key.chars() {
+            hash = (31 * hash + c as i64) % MODULUS;
+        }
+
+        hash as i32
+    }
+
+    /* 异或哈希 */
+    fn xor_hash(key: &str) -> i32 {
+        let mut hash = 0_i64;
+        const MODULUS: i64 = 1000000007;
+
+        for c in key.chars() {
+            hash ^= c as i64;
+        }
+
+        (hash & MODULUS) as i32
+    }
+
+    /* 旋转哈希 */
+    fn rot_hash(key: &str) -> i32 {
+        let mut hash = 0_i64;
+        const MODULUS: i64 = 1000000007;
+
+        for c in key.chars() {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c as i64) % MODULUS;
+        }
+
+        hash as i32
+    }
+    ```
+
+=== "C"
+
+    ```c title="simple_hash.c"
+    /* 加法哈希 */
+    int addHash(char *key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (int i = 0; i < strlen(key); i++) {
+            hash = (hash + (unsigned char)key[i]) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* 乘法哈希 */
+    int mulHash(char *key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (int i = 0; i < strlen(key); i++) {
+            hash = (31 * hash + (unsigned char)key[i]) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* 异或哈希 */
+    int xorHash(char *key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
+
+        for (int i = 0; i < strlen(key); i++) {
+            hash ^= (unsigned char)key[i];
+        }
+        return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    int rotHash(char *key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (int i = 0; i < strlen(key); i++) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (unsigned char)key[i]) % MODULUS;
+        }
+
+        return (int)hash;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="simple_hash.zig"
+    [class]{}-[func]{addHash}
+
+    [class]{}-[func]{mulHash}
+
+    [class]{}-[func]{xorHash}
+
+    [class]{}-[func]{rotHash}
+    ```
+
+观察发现，每种哈希算法的最后一步都是对大质数 $1000000007$ 取模，以确保哈希值在合适的范围内。值得思考的是，为什么要强调对质数取模，或者说对合数取模的弊端是什么？这是一个有趣的问题。
+
+先抛出结论：**当我们使用大质数作为模数时，可以最大化地保证哈希值的均匀分布**。因为质数不会与其他数字存在公约数，可以减少因取模操作而产生的周期性模式，从而避免哈希冲突。
+
+举个例子，假设我们选择合数 $9$ 作为模数，它可以被 $3$ 整除。那么所有可以被 $3$ 整除的 `key` 都会被映射到 $0$、$3$、$6$ 这三个哈希值。
+
+$$
+\begin{aligned}
+\text{modulus} & = 9 \newline
+\text{key} & = \{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \dots \} \newline
+\text{hash} & = \{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\dots \}
+\end{aligned}
+$$
+
+如果输入 `key` 恰好满足这种等差数列的数据分布，那么哈希值就会出现聚堆，从而加重哈希冲突。现在，假设将 `modulus` 替换为质数 $13$ ，由于 `key` 和 `modulus` 之间不存在公约数，输出的哈希值的均匀性会明显提升。
+
+$$
+\begin{aligned}
+\text{modulus} & = 13 \newline
+\text{key} & = \{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \dots \} \newline
+\text{hash} & = \{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \dots \}
+\end{aligned}
+$$
+
+值得说明的是，如果能够保证 `key` 是随机均匀分布的，那么选择质数或者合数作为模数都是可以的，它们都能输出均匀分布的哈希值。而当 `key` 的分布存在某种周期性时，对合数取模更容易出现聚集现象。
+
+总而言之，我们通常选取质数作为模数，并且这个质数最好足够大，以尽可能消除周期性模式，提升哈希算法的稳健性。
+
+## 6.3.3 &nbsp; 常见哈希算法
+
+不难发现，以上介绍的简单哈希算法都比较“脆弱”，远远没有达到哈希算法的设计目标。例如，由于加法和异或满足交换律，因此加法哈希和异或哈希无法区分内容相同但顺序不同的字符串，这可能会加剧哈希冲突，并引起一些安全问题。
+
+在实际中，我们通常会用一些标准哈希算法，例如 MD5、SHA-1、SHA-2、SHA3 等。它们可以将任意长度的输入数据映射到恒定长度的哈希值。
+
+近一个世纪以来，哈希算法处在不断升级与优化的过程中。一部分研究人员努力提升哈希算法的性能，另一部分研究人员和黑客则致力于寻找哈希算法的安全性问题。表 6-2 展示了在实际应用中常见的哈希算法。
+
+- MD5 和 SHA-1 已多次被成功攻击，因此它们被各类安全应用弃用。
+- SHA-2 系列中的 SHA-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常被用在各类安全应用与协议中。
+- SHA-3 相较 SHA-2 的实现开销更低、计算效率更高，但目前使用覆盖度不如 SHA-2 系列。
+
+<p align="center"> 表 6-2 &nbsp; 常见的哈希算法 </p>
+
+<div class="center-table" markdown>
+
+|          | MD5                            | SHA-1            | SHA-2                        | SHA-3                |
+| -------- | ------------------------------ | ---------------- | ---------------------------- | -------------------- |
+| 推出时间 | 1992                           | 1995             | 2002                         | 2008                 |
+| 输出长度 | 128 bits                       | 160 bits         | 256 / 512 bits               | 224/256/384/512 bits |
+| 哈希冲突 | 较多                           | 较多             | 很少                         | 很少                 |
+| 安全等级 | 低，已被成功攻击               | 低，已被成功攻击 | 高                           | 高                   |
+| 应用     | 已被弃用，仍用于数据完整性检查 | 已被弃用         | 加密货币交易验证、数字签名等 | 可用于替代 SHA-2     |
+
+</div>
+
+## 6.3.4 &nbsp; 数据结构的哈希值
+
+我们知道，哈希表的 `key` 可以是整数、小数或字符串等数据类型。编程语言通常会为这些数据类型提供内置的哈希算法，用于计算哈希表中的桶索引。以 Python 为例，我们可以调用 `hash()` 函数来计算各种数据类型的哈希值。
+
+- 整数和布尔量的哈希值就是其本身。
+- 浮点数和字符串的哈希值计算较为复杂，有兴趣的同学请自行学习。
+- 元组的哈希值是对其中每一个元素进行哈希，然后将这些哈希值组合起来，得到单一的哈希值。
+- 对象的哈希值基于其内存地址生成。通过重写对象的哈希方法，可实现基于内容生成哈希值。
+
+!!! tip
+
+    请注意，不同编程语言的内置哈希值计算函数的定义和方法不同。
+
+=== "Python"
+
+    ```python title="built_in_hash.py"
+    num = 3
+    hash_num = hash(num)
+    # 整数 3 的哈希值为 3
+
+    bol = True
+    hash_bol = hash(bol)
+    # 布尔量 True 的哈希值为 1
+
+    dec = 3.14159
+    hash_dec = hash(dec)
+    # 小数 3.14159 的哈希值为 326484311674566659
+
+    str = "Hello 算法"
+    hash_str = hash(str)
+    # 字符串 Hello 算法 的哈希值为 4617003410720528961
+
+    tup = (12836, "小哈")
+    hash_tup = hash(tup)
+    # 元组 (12836, '小哈') 的哈希值为 1029005403108185979
+
+    obj = ListNode(0)
+    hash_obj = hash(obj)
+    # 节点对象 <ListNode object at 0x1058fd810> 的哈希值为 274267521
+    ```
+
+=== "C++"
+
+    ```cpp title="built_in_hash.cpp"
+    int num = 3;
+    size_t hashNum = hash<int>()(num);
+    // 整数 3 的哈希值为 3
+
+    bool bol = true;
+    size_t hashBol = hash<bool>()(bol);
+    // 布尔量 1 的哈希值为 1
+
+    double dec = 3.14159;
+    size_t hashDec = hash<double>()(dec);
+    // 小数 3.14159 的哈希值为 4614256650576692846
+
+    string str = "Hello 算法";
+    size_t hashStr = hash<string>()(str);
+    // 字符串 Hello 算法 的哈希值为 15466937326284535026
+
+    // 在 C++ 中，内置 std:hash() 仅提供基本数据类型的哈希值计算
+    // 数组、对象的哈希值计算需要自行实现
+    ```
+
+=== "Java"
+
+    ```java title="built_in_hash.java"
+    int num = 3;
+    int hashNum = Integer.hashCode(num);
+    // 整数 3 的哈希值为 3
+
+    boolean bol = true;
+    int hashBol = Boolean.hashCode(bol);
+    // 布尔量 true 的哈希值为 1231
+
+    double dec = 3.14159;
+    int hashDec = Double.hashCode(dec);
+    // 小数 3.14159 的哈希值为 -1340954729
+
+    String str = "Hello 算法";
+    int hashStr = str.hashCode();
+    // 字符串 Hello 算法 的哈希值为 -727081396
+
+    Object[] arr = { 12836, "小哈" };
+    int hashTup = Arrays.hashCode(arr);
+    // 数组 [12836, 小哈] 的哈希值为 1151158
+
+    ListNode obj = new ListNode(0);
+    int hashObj = obj.hashCode();
+    // 节点对象 utils.ListNode@7dc5e7b4 的哈希值为 2110121908
+    ```
+
+=== "C#"
+
+    ```csharp title="built_in_hash.cs"
+    int num = 3;
+    int hashNum = num.GetHashCode();
+    // 整数 3 的哈希值为 3;
+
+    bool bol = true;
+    int hashBol = bol.GetHashCode();
+    // 布尔量 true 的哈希值为 1;
+
+    double dec = 3.14159;
+    int hashDec = dec.GetHashCode();
+    // 小数 3.14159 的哈希值为 -1340954729;
+
+    string str = "Hello 算法";
+    int hashStr = str.GetHashCode();
+    // 字符串 Hello 算法 的哈希值为 -586107568;
+
+    object[] arr = { 12836, "小哈" };
+    int hashTup = arr.GetHashCode();
+    // 数组 [12836, 小哈] 的哈希值为 42931033;
+
+    ListNode obj = new(0);
+    int hashObj = obj.GetHashCode();
+    // 节点对象 0 的哈希值为 39053774;
+    ```
+
+=== "Go"
+
+    ```go title="built_in_hash.go"
+
+    ```
+
+=== "Swift"
+
+    ```swift title="built_in_hash.swift"
+    let num = 3
+    let hashNum = num.hashValue
+    // 整数 3 的哈希值为 9047044699613009734
+
+    let bol = true
+    let hashBol = bol.hashValue
+    // 布尔量 true 的哈希值为 -4431640247352757451
+
+    let dec = 3.14159
+    let hashDec = dec.hashValue
+    // 小数 3.14159 的哈希值为 -2465384235396674631
+
+    let str = "Hello 算法"
+    let hashStr = str.hashValue
+    // 字符串 Hello 算法 的哈希值为 -7850626797806988787
+
+    let arr = [AnyHashable(12836), AnyHashable("小哈")]
+    let hashTup = arr.hashValue
+    // 数组 [AnyHashable(12836), AnyHashable("小哈")] 的哈希值为 -2308633508154532996
+
+    let obj = ListNode(x: 0)
+    let hashObj = obj.hashValue
+    // 节点对象 utils.ListNode 的哈希值为 -2434780518035996159
+    ```
+
+=== "JS"
+
+    ```javascript title="built_in_hash.js"
+    // JavaScript 未提供内置 hash code 函数
+    ```
+
+=== "TS"
+
+    ```typescript title="built_in_hash.ts"
+    // TypeScript 未提供内置 hash code 函数
+    ```
+
+=== "Dart"
+
+    ```dart title="built_in_hash.dart"
+    int num = 3;
+    int hashNum = num.hashCode;
+    // 整数 3 的哈希值为 34803
+
+    bool bol = true;
+    int hashBol = bol.hashCode;
+    // 布尔值 true 的哈希值为 1231
+
+    double dec = 3.14159;
+    int hashDec = dec.hashCode;
+    // 小数 3.14159 的哈希值为 2570631074981783
+
+    String str = "Hello 算法";
+    int hashStr = str.hashCode;
+    // 字符串 Hello 算法 的哈希值为 468167534
+
+    List arr = [12836, "小哈"];
+    int hashArr = arr.hashCode;
+    // 数组 [12836, 小哈] 的哈希值为 976512528
+
+    ListNode obj = new ListNode(0);
+    int hashObj = obj.hashCode;
+    // 节点对象 Instance of 'ListNode' 的哈希值为 1033450432
+    ```
+
+=== "Rust"
+
+    ```rust title="built_in_hash.rs"
+    use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
+    
+    let num = 3;
+    let mut num_hasher = DefaultHasher::new();
+    num.hash(&mut num_hasher);
+    let hash_num = num_hasher.finish();
+    // 整数 3 的哈希值为 568126464209439262
+
+    let bol = true;
+    let mut bol_hasher = DefaultHasher::new();
+    bol.hash(&mut bol_hasher);
+    let hash_bol = bol_hasher.finish();
+    // 布尔量 true 的哈希值为 4952851536318644461
+
+    let dec: f32 = 3.14159;
+    let mut dec_hasher = DefaultHasher::new();
+    dec.to_bits().hash(&mut dec_hasher);
+    let hash_dec = dec_hasher.finish();
+    println!("小数 {} 的哈希值为 {}", dec, hash_dec);
+    // 小数 3.14159 的哈希值为 2566941990314602357
+
+    let str = "Hello 算法";
+    let mut str_hasher = DefaultHasher::new();
+    str.hash(&mut str_hasher);
+    let hash_str = str_hasher.finish();
+    // 字符串 Hello 算法 的哈希值为 16092673739211250988
+
+    let arr = (&12836, &"小哈");
+    let mut tup_hasher = DefaultHasher::new();
+    arr.hash(&mut tup_hasher);
+    let hash_tup = tup_hasher.finish();
+    // 元组 (12836, "小哈") 的哈希值为 1885128010422702749
+
+    let node = ListNode::new(42);
+    let mut hasher = DefaultHasher::new();
+    node.borrow().val.hash(&mut hasher);
+    let hash = hasher.finish();
+    // 节点对象 RefCell { value: ListNode { val: 42, next: None } } 的哈希值为15387811073369036852
+    ```
+
+=== "C"
+
+    ```c title="built_in_hash.c"
+    // C 未提供内置 hash code 函数
+    ```
+
+=== "Zig"
+
+    ```zig title="built_in_hash.zig"
+
+    ```
+
+在许多编程语言中，**只有不可变对象才可作为哈希表的 `key`** 。假如我们将列表（动态数组）作为 `key` ，当列表的内容发生变化时，它的哈希值也随之改变，我们就无法在哈希表中查询到原先的 `value` 了。
+
+虽然自定义对象（比如链表节点）的成员变量是可变的，但它是可哈希的。**这是因为对象的哈希值通常是基于内存地址生成的**，即使对象的内容发生了变化，但它的内存地址不变，哈希值仍然是不变的。
+
+细心的你可能发现在不同控制台中运行程序时，输出的哈希值是不同的。**这是因为 Python 解释器在每次启动时，都会为字符串哈希函数加入一个随机的盐（Salt）值**。这种做法可以有效防止 HashDoS 攻击，提升哈希算法的安全性。

docs/chapter_hashing/index.md

@@ -0,0 +1,25 @@
+---
+comments: true
+icon: material/table-search
+---
+
+# 第 6 章   哈希表
+
+<div class="center-table" markdown>
+
+![哈希表](../assets/covers/chapter_hashing.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    在计算机世界中，哈希表如同一位智能的图书管理员。
+    
+    他知道如何计算索书号，从而可以快速找到目标书籍。
+
+## 本章内容
+
+- [6.1 &nbsp; 哈希表](https://www.hello-algo.com/chapter_hashing/hash_map/)
+- [6.2 &nbsp; 哈希冲突](https://www.hello-algo.com/chapter_hashing/hash_collision/)
+- [6.3 &nbsp; 哈希算法](https://www.hello-algo.com/chapter_hashing/hash_algorithm/)
+- [6.4 &nbsp; 小结](https://www.hello-algo.com/chapter_hashing/summary/)

docs/chapter_hashing/summary.md

@@ -0,0 +1,51 @@
+---
+comments: true
+---
+
+# 6.4   小结
+
+### 1.   重点回顾
+
+- 输入 `key` ，哈希表能够在 $O(1)$ 时间内查询到 `value` ，效率非常高。
+- 常见的哈希表操作包括查询、添加键值对、删除键值对和遍历哈希表等。
+- 哈希函数将 `key` 映射为数组索引，从而访问对应桶并获取 `value` 。
+- 两个不同的 `key` 可能在经过哈希函数后得到相同的数组索引，导致查询结果出错，这种现象被称为哈希冲突。
+- 哈希表容量越大，哈希冲突的概率就越低。因此可以通过扩容哈希表来缓解哈希冲突。与数组扩容类似，哈希表扩容操作的开销很大。
+- 负载因子定义为哈希表中元素数量除以桶数量，反映了哈希冲突的严重程度，常用作触发哈希表扩容的条件。
+- 链式地址通过将单个元素转化为链表，将所有冲突元素存储在同一个链表中。然而，链表过长会降低查询效率，可以进一步将链表转换为红黑树来提高效率。
+- 开放寻址通过多次探测来处理哈希冲突。线性探测使用固定步长，缺点是不能删除元素，且容易产生聚集。多次哈希使用多个哈希函数进行探测，相较线性探测更不易产生聚集，但多个哈希函数增加了计算量。
+- 不同编程语言采取了不同的哈希表实现。例如，Java 的 `HashMap` 使用链式地址，而 Python 的 `Dict` 采用开放寻址。
+- 在哈希表中，我们希望哈希算法具有确定性、高效率和均匀分布的特点。在密码学中，哈希算法还应该具备抗碰撞性和雪崩效应。
+- 哈希算法通常采用大质数作为模数，以最大化地保证哈希值的均匀分布，减少哈希冲突。
+- 常见的哈希算法包括 MD5、SHA-1、SHA-2 和 SHA3 等。MD5 常用于校验文件完整性，SHA-2 常用于安全应用与协议。
+- 编程语言通常会为数据类型提供内置哈希算法，用于计算哈希表中的桶索引。通常情况下，只有不可变对象是可哈希的。
+
+### 2.   Q & A
+
+!!! question "哈希表的时间复杂度为什么不是 $O(n)$ ？"
+
+    当哈希冲突比较严重时，哈希表的时间复杂度会退化至 $O(n)$ 。当哈希函数设计的比较好、容量设置比较合理、冲突比较平均时，时间复杂度是 $O(1)$ 。我们使用编程语言内置的哈希表时，通常认为时间复杂度是 $O(1)$ 。
+
+!!! question "为什么不使用哈希函数 $f(x) = x$ 呢？这样就不会有冲突了"
+
+    在 $f(x) = x$ 哈希函数下，每个元素对应唯一的桶索引，这与数组等价。然而，输入空间通常远大于输出空间（数组长度），因此哈希函数的最后一步往往是对数组长度取模。换句话说，哈希表的目标是将一个较大的状态空间映射到一个较小的空间，并提供 $O(1)$ 的查询效率。
+
+!!! question "哈希表底层实现是数组、链表、二叉树，但为什么效率可以比他们更高呢？"
+
+    首先，哈希表的时间效率变高，但空间效率变低了。哈希表有相当一部分的内存是未使用的，
+    
+    其次，只是在特定使用场景下时间效率变高了。如果一个功能能够在相同的时间复杂度下使用数组或链表实现，那么通常比哈希表更快。这是因为哈希函数计算需要开销，时间复杂度的常数项更大。
+    
+    最后，哈希表的时间复杂度可能发生劣化。例如在链式地址中，我们采取在链表或红黑树中执行查找操作，仍然有退化至 $O(n)$ 时间的风险。
+
+!!! question "多次哈希有不能直接删除元素的缺陷吗？对于标记已删除的空间，这个空间还能再次使用吗？"
+
+    多次哈希是开放寻址的一种，开放寻址法都有不能直接删除元素的缺陷，需要通过标记删除。被标记为已删除的空间是可以再次被使用的。当将新元素插入哈希表，并且通过哈希函数找到了被标记为已删除的位置时，该位置可以被新的元素使用。这样做既能保持哈希表的探测序列不变，又能保证哈希表的空间使用率。
+
+!!! question "为什么在线性探测中，查找元素的时候会出现哈希冲突呢？"
+
+    查找的时候通过哈希函数找到对应的桶和键值对，发现 `key` 不匹配，这就代表有哈希冲突。因此，线性探测法会根据预先设定的步长依次向下查找，直至找到正确的键值对或无法找到跳出为止。
+
+!!! question "为什么哈希表扩容能够缓解哈希冲突？"
+
+    哈希函数的最后一步往往是对数组长度 $n$ 取余，让输出值落入在数组索引范围；在扩容后，数组长度 $n$ 发生变化，而 `key` 对应的索引也可能发生变化。原先落在同一个桶的多个 `key` ，在扩容后可能会被分配到多个桶中，从而实现哈希冲突的缓解。

docs/chapter_heap/build_heap.md

@@ -0,0 +1,251 @@
+---
+comments: true
+---
+
+# 8.2   建堆操作
+
+在某些情况下，我们希望使用一个列表的所有元素来构建一个堆，这个过程被称为“建堆操作”。
+
+## 8.2.1   借助入堆操作实现
+
+我们首先创建一个空堆，然后遍历列表，依次对每个元素执行“入堆操作”，即先将元素添加至堆的尾部，再对该元素执行“从底至顶”堆化。
+
+每当一个元素入堆，堆的长度就加一。由于节点是从顶到底依次被添加进二叉树的，因此堆是“自上而下”地构建的。
+
+设元素数量为 $n$ ，每个元素的入堆操作使用 $O(\log{n})$ 时间，因此该建堆方法的时间复杂度为 $O(n \log n)$ 。
+
+## 8.2.2   通过遍历堆化实现
+
+实际上，我们可以实现一种更为高效的建堆方法，共分为两步。
+
+1. 将列表所有元素原封不动添加到堆中，此时堆的性质尚未得到满足。
+2. 倒序遍历堆（即层序遍历的倒序），依次对每个非叶节点执行“从顶至底堆化”。
+
+**每当堆化一个节点后，以该节点为根节点的子树就形成一个合法的子堆**。而由于是倒序遍历，因此堆是“自下而上”地被构建的。
+
+之所以选择倒序遍历，是因为这样能够保证当前节点之下的子树已经是合法的子堆，这样堆化当前节点才是有效的。
+
+值得说明的是，**叶节点没有子节点，天然就是合法的子堆，因此无需堆化**。如以下代码所示，最后一个非叶节点是最后一个节点的父节点，我们从它开始倒序遍历并执行堆化。
+
+=== "Python"
+
+    ```python title="my_heap.py"
+    def __init__(self, nums: list[int]):
+        """构造方法，根据输入列表建堆"""
+        # 将列表元素原封不动添加进堆
+        self.max_heap = nums
+        # 堆化除叶节点以外的其他所有节点
+        for i in range(self.parent(self.size() - 1), -1, -1):
+            self.sift_down(i)
+    ```
+
+=== "C++"
+
+    ```cpp title="my_heap.cpp"
+    /* 构造方法，根据输入列表建堆 */
+    MaxHeap(vector<int> nums) {
+        // 将列表元素原封不动添加进堆
+        maxHeap = nums;
+        // 堆化除叶节点以外的其他所有节点
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="my_heap.java"
+    /* 构造方法，根据输入列表建堆 */
+    MaxHeap(List<Integer> nums) {
+        // 将列表元素原封不动添加进堆
+        maxHeap = new ArrayList<>(nums);
+        // 堆化除叶节点以外的其他所有节点
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="my_heap.cs"
+    /* 构造函数，根据输入列表建堆 */
+    MaxHeap(IEnumerable<int> nums) {
+        // 将列表元素原封不动添加进堆
+        maxHeap = new List<int>(nums);
+        // 堆化除叶节点以外的其他所有节点
+        var size = Parent(this.Size() - 1);
+        for (int i = size; i >= 0; i--) {
+            SiftDown(i);
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="my_heap.go"
+    /* 构造函数，根据切片建堆 */
+    func newMaxHeap(nums []any) *maxHeap {
+        // 将列表元素原封不动添加进堆
+        h := &maxHeap{data: nums}
+        for i := h.parent(len(h.data) - 1); i >= 0; i-- {
+            // 堆化除叶节点以外的其他所有节点
+            h.siftDown(i)
+        }
+        return h
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="my_heap.swift"
+    /* 构造方法，根据输入列表建堆 */
+    init(nums: [Int]) {
+        // 将列表元素原封不动添加进堆
+        maxHeap = nums
+        // 堆化除叶节点以外的其他所有节点
+        for i in stride(from: parent(i: size() - 1), through: 0, by: -1) {
+            siftDown(i: i)
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="my_heap.js"
+    /* 构造方法，建立空堆或根据输入列表建堆 */
+    constructor(nums) {
+        // 将列表元素原封不动添加进堆
+        this.#maxHeap = nums === undefined ? [] : [...nums];
+        // 堆化除叶节点以外的其他所有节点
+        for (let i = this.#parent(this.size() - 1); i >= 0; i--) {
+            this.#siftDown(i);
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="my_heap.ts"
+    /* 构造方法，建立空堆或根据输入列表建堆 */
+    constructor(nums?: number[]) {
+        // 将列表元素原封不动添加进堆
+        this.maxHeap = nums === undefined ? [] : [...nums];
+        // 堆化除叶节点以外的其他所有节点
+        for (let i = this.parent(this.size() - 1); i >= 0; i--) {
+            this.siftDown(i);
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="my_heap.dart"
+    /* 构造方法，根据输入列表建堆 */
+    MaxHeap(List<int> nums) {
+      // 将列表元素原封不动添加进堆
+      _maxHeap = nums;
+      // 堆化除叶节点以外的其他所有节点
+      for (int i = _parent(size() - 1); i >= 0; i--) {
+        siftDown(i);
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="my_heap.rs"
+    /* 构造方法，根据输入列表建堆 */
+    fn new(nums: Vec<i32>) -> Self {
+        // 将列表元素原封不动添加进堆
+        let mut heap = MaxHeap { max_heap: nums };
+        // 堆化除叶节点以外的其他所有节点
+        for i in (0..=Self::parent(heap.size() - 1)).rev() {
+            heap.sift_down(i);
+        }
+        heap
+    }
+    ```
+
+=== "C"
+
+    ```c title="my_heap.c"
+    /* 构造函数，根据切片建堆 */
+    maxHeap *newMaxHeap(int nums[], int size) {
+        // 所有元素入堆
+        maxHeap *h = (maxHeap *)malloc(sizeof(maxHeap));
+        h->size = size;
+        memcpy(h->data, nums, size * sizeof(int));
+        for (int i = parent(h, size - 1); i >= 0; i--) {
+            // 堆化除叶节点以外的其他所有节点
+            siftDown(h, i);
+        }
+        return h;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="my_heap.zig"
+    // 构造方法，根据输入列表建堆
+    fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
+        if (self.max_heap != null) return;
+        self.max_heap = std.ArrayList(T).init(allocator);
+        // 将列表元素原封不动添加进堆
+        try self.max_heap.?.appendSlice(nums);
+        // 堆化除叶节点以外的其他所有节点
+        var i: usize = parent(self.size() - 1) + 1;
+        while (i > 0) : (i -= 1) {
+            try self.siftDown(i - 1);
+        }
+    }
+    ```
+
+## 8.2.3 &nbsp; 复杂度分析
+
+下面，我们来尝试推算第二种建堆方法的时间复杂度。
+
+- 假设完全二叉树的节点数量为 $n$ ，则叶节点数量为 $(n + 1) / 2$ ，其中 $/$ 为向下整除。因此需要堆化的节点数量为 $(n - 1) / 2$ 。
+- 在从顶至底堆化的过程中，每个节点最多堆化到叶节点，因此最大迭代次数为二叉树高度 $\log n$ 。
+
+将上述两者相乘，可得到建堆过程的时间复杂度为 $O(n \log n)$ 。**但这个估算结果并不准确，因为我们没有考虑到二叉树底层节点数量远多于顶层节点的性质**。
+
+接下来我们来进行更为准确的计算。为了减小计算难度，假设给定一个节点数量为 $n$ ，高度为 $h$ 的“完美二叉树”，该假设不会影响计算结果的正确性。
+
+![完美二叉树的各层节点数量](build_heap.assets/heapify_operations_count.png)
+
+<p align="center"> 图 8-5 &nbsp; 完美二叉树的各层节点数量 </p>
+
+如图 8-5 所示，节点“从顶至底堆化”的最大迭代次数等于该节点到叶节点的距离，而该距离正是“节点高度”。因此，我们可以将各层的“节点数量 $\times$ 节点高度”求和，**从而得到所有节点的堆化迭代次数的总和**。
+
+$$
+T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1
+$$
+
+化简上式需要借助中学的数列知识，先对 $T(h)$ 乘以 $2$ ，得到：
+
+$$
+\begin{aligned}
+T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{h-1}\times1 \newline
+2 T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \dots + 2^{h}\times1 \newline
+\end{aligned}
+$$
+
+使用错位相减法，用下式 $2 T(h)$ 减去上式 $T(h)$ ，可得：
+
+$$
+2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \dots + 2^{h-1} + 2^h
+$$
+
+观察上式，发现 $T(h)$ 是一个等比数列，可直接使用求和公式，得到时间复杂度为：
+
+$$
+\begin{aligned}
+T(h) & = 2 \frac{1 - 2^h}{1 - 2} - h \newline
+& = 2^{h+1} - h - 2 \newline
+& = O(2^h)
+\end{aligned}
+$$
+
+进一步地，高度为 $h$ 的完美二叉树的节点数量为 $n = 2^{h+1} - 1$ ，易得复杂度为 $O(2^h) = O(n)$ 。以上推算表明，**输入列表并建堆的时间复杂度为 $O(n)$ ，非常高效**。

docs/chapter_heap/index.md

@@ -0,0 +1,25 @@
+---
+comments: true
+icon: material/family-tree
+---
+
+# 第 8 章   堆
+
+<div class="center-table" markdown>
+
+![堆](../assets/covers/chapter_heap.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    堆就像是山川的峰峦，它们层叠起伏、形态各异。
+    
+    每一座山峰都有其高低之分，而最高的山峰总是最先映入眼帘。
+
+## 本章内容
+
+- [8.1 &nbsp; 堆](https://www.hello-algo.com/chapter_heap/heap/)
+- [8.2 &nbsp; 建堆操作](https://www.hello-algo.com/chapter_heap/build_heap/)
+- [8.3 &nbsp; Top-K 问题](https://www.hello-algo.com/chapter_heap/top_k/)
+- [8.4 &nbsp; 小结](https://www.hello-algo.com/chapter_heap/summary/)

docs/chapter_heap/summary.md

@@ -0,0 +1,21 @@
+---
+comments: true
+---
+
+# 8.4   小结
+
+### 1.   重点回顾
+
+- 堆是一棵完全二叉树，根据成立条件可分为大顶堆和小顶堆。大（小）顶堆的堆顶元素是最大（小）的。
+- 优先队列的定义是具有出队优先级的队列，通常使用堆来实现。
+- 堆的常用操作及其对应的时间复杂度包括：元素入堆 $O(\log n)$、堆顶元素出堆 $O(\log n)$ 和访问堆顶元素 $O(1)$ 等。
+- 完全二叉树非常适合用数组表示，因此我们通常使用数组来存储堆。
+- 堆化操作用于维护堆的性质，在入堆和出堆操作中都会用到。
+- 输入 $n$ 个元素并建堆的时间复杂度可以优化至 $O(n)$ ，非常高效。
+- Top-K 是一个经典算法问题，可以使用堆数据结构高效解决，时间复杂度为 $O(n \log k)$ 。
+
+### 2.   Q & A
+
+!!! question "数据结构的“堆”与内存管理的“堆”是同一个概念吗？"
+
+    两者不是同一个概念，只是碰巧都叫堆。计算机系统内存中的堆是动态内存分配的一部分，程序在运行时可以使用它来存储数据。程序可以请求一定量的堆内存，用于存储如对象和数组等复杂结构。当这些数据不再需要时，程序需要释放这些内存，以防止内存泄露。相较于栈内存，堆内存的管理和使用需要更谨慎，不恰当的使用可能会导致内存泄露和野指针等问题。

docs/chapter_heap/top_k.md

@@ -0,0 +1,307 @@
+---
+comments: true
+---
+
+# 8.3   Top-K 问题
+
+!!! question
+
+    给定一个长度为 $n$ 无序数组 `nums` ，请返回数组中前 $k$ 大的元素。
+
+对于该问题，我们先介绍两种思路比较直接的解法，再介绍效率更高的堆解法。
+
+## 8.3.1   方法一：遍历选择
+
+我们可以进行图 8-6 所示的 $k$ 轮遍历，分别在每轮中提取第 $1$、$2$、$\dots$、$k$ 大的元素，时间复杂度为 $O(nk)$ 。
+
+此方法只适用于 $k \ll n$ 的情况，因为当 $k$ 与 $n$ 比较接近时，其时间复杂度趋向于 $O(n^2)$ ，非常耗时。
+
+![遍历寻找最大的 k 个元素](top_k.assets/top_k_traversal.png)
+
+<p align="center"> 图 8-6 &nbsp; 遍历寻找最大的 k 个元素 </p>
+
+!!! tip
+
+    当 $k = n$ 时，我们可以得到完整的有序序列，此时等价于“选择排序”算法。
+
+## 8.3.2 &nbsp; 方法二：排序
+
+如图 8-7 所示，我们可以先对数组 `nums` 进行排序，再返回最右边的 $k$ 个元素，时间复杂度为 $O(n \log n)$ 。
+
+显然，该方法“超额”完成任务了，因为我们只需要找出最大的 $k$ 个元素即可，而不需要排序其他元素。
+
+![排序寻找最大的 k 个元素](top_k.assets/top_k_sorting.png)
+
+<p align="center"> 图 8-7 &nbsp; 排序寻找最大的 k 个元素 </p>
+
+## 8.3.3 &nbsp; 方法三：堆
+
+我们可以基于堆更加高效地解决 Top-K 问题，流程如图 8-8 所示。
+
+1. 初始化一个小顶堆，其堆顶元素最小。
+2. 先将数组的前 $k$ 个元素依次入堆。
+3. 从第 $k + 1$ 个元素开始，若当前元素大于堆顶元素，则将堆顶元素出堆，并将当前元素入堆。
+4. 遍历完成后，堆中保存的就是最大的 $k$ 个元素。
+
+=== "<1>"
+    ![基于堆寻找最大的 k 个元素](top_k.assets/top_k_heap_step1.png)
+
+=== "<2>"
+    ![top_k_heap_step2](top_k.assets/top_k_heap_step2.png)
+
+=== "<3>"
+    ![top_k_heap_step3](top_k.assets/top_k_heap_step3.png)
+
+=== "<4>"
+    ![top_k_heap_step4](top_k.assets/top_k_heap_step4.png)
+
+=== "<5>"
+    ![top_k_heap_step5](top_k.assets/top_k_heap_step5.png)
+
+=== "<6>"
+    ![top_k_heap_step6](top_k.assets/top_k_heap_step6.png)
+
+=== "<7>"
+    ![top_k_heap_step7](top_k.assets/top_k_heap_step7.png)
+
+=== "<8>"
+    ![top_k_heap_step8](top_k.assets/top_k_heap_step8.png)
+
+=== "<9>"
+    ![top_k_heap_step9](top_k.assets/top_k_heap_step9.png)
+
+<p align="center"> 图 8-8 &nbsp; 基于堆寻找最大的 k 个元素 </p>
+
+总共执行了 $n$ 轮入堆和出堆，堆的最大长度为 $k$ ，因此时间复杂度为 $O(n \log k)$ 。该方法的效率很高，当 $k$ 较小时，时间复杂度趋向 $O(n)$ ；当 $k$ 较大时，时间复杂度不会超过 $O(n \log n)$ 。
+
+另外，该方法适用于动态数据流的使用场景。在不断加入数据时，我们可以持续维护堆内的元素，从而实现最大 $k$ 个元素的动态更新。
+
+=== "Python"
+
+    ```python title="top_k.py"
+    def top_k_heap(nums: list[int], k: int) -> list[int]:
+        """基于堆查找数组中最大的 k 个元素"""
+        heap = []
+        # 将数组的前 k 个元素入堆
+        for i in range(k):
+            heapq.heappush(heap, nums[i])
+        # 从第 k+1 个元素开始，保持堆的长度为 k
+        for i in range(k, len(nums)):
+            # 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if nums[i] > heap[0]:
+                heapq.heappop(heap)
+                heapq.heappush(heap, nums[i])
+        return heap
+    ```
+
+=== "C++"
+
+    ```cpp title="top_k.cpp"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
+        priority_queue<int, vector<int>, greater<int>> heap;
+        // 将数组的前 k 个元素入堆
+        for (int i = 0; i < k; i++) {
+            heap.push(nums[i]);
+        }
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (int i = k; i < nums.size(); i++) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (nums[i] > heap.top()) {
+                heap.pop();
+                heap.push(nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="top_k.java"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    Queue<Integer> topKHeap(int[] nums, int k) {
+        Queue<Integer> heap = new PriorityQueue<Integer>();
+        // 将数组的前 k 个元素入堆
+        for (int i = 0; i < k; i++) {
+            heap.offer(nums[i]);
+        }
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (int i = k; i < nums.length; i++) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (nums[i] > heap.peek()) {
+                heap.poll();
+                heap.offer(nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="top_k.cs"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    PriorityQueue<int, int> TopKHeap(int[] nums, int k) {
+        PriorityQueue<int, int> heap = new();
+        // 将数组的前 k 个元素入堆
+        for (int i = 0; i < k; i++) {
+            heap.Enqueue(nums[i], nums[i]);
+        }
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (int i = k; i < nums.Length; i++) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (nums[i] > heap.Peek()) {
+                heap.Dequeue();
+                heap.Enqueue(nums[i], nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="top_k.go"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    func topKHeap(nums []int, k int) *minHeap {
+        h := &minHeap{}
+        heap.Init(h)
+        // 将数组的前 k 个元素入堆
+        for i := 0; i < k; i++ {
+            heap.Push(h, nums[i])
+        }
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for i := k; i < len(nums); i++ {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if nums[i] > h.Top().(int) {
+                heap.Pop(h)
+                heap.Push(h, nums[i])
+            }
+        }
+        return h
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="top_k.swift"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    func topKHeap(nums: [Int], k: Int) -> [Int] {
+        // 将数组的前 k 个元素入堆
+        var heap = Array(nums.prefix(k))
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for i in stride(from: k, to: nums.count, by: 1) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if nums[i] > heap.first! {
+                heap.removeFirst()
+                heap.insert(nums[i], at: 0)
+            }
+        }
+        return heap
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="top_k.js"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    function topKHeap(nums, k) {
+        // 使用大顶堆 MaxHeap ，对数组 nums 取相反数
+        const invertedNums = nums.map((num) => -num);
+        // 将数组的前 k 个元素入堆
+        const heap = new MaxHeap(invertedNums.slice(0, k));
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (let i = k; i < invertedNums.length; i++) {
+            // 若当前元素小于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (invertedNums[i] < heap.peek()) {
+                heap.pop();
+                heap.push(invertedNums[i]);
+            }
+        }
+        // 取出堆中元素
+        const maxHeap = heap.getMaxHeap();
+        // 对堆中元素取相反数
+        const invertedMaxHeap = maxHeap.map((num) => -num);
+        return invertedMaxHeap;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="top_k.ts"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    function topKHeap(nums: number[], k: number): number[] {
+        // 将堆中所有元素取反，从而用大顶堆来模拟小顶堆
+        const invertedNums = nums.map((num) => -num);
+        // 将数组的前 k 个元素入堆
+        const heap = new MaxHeap(invertedNums.slice(0, k));
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (let i = k; i < invertedNums.length; i++) {
+            // 若当前元素小于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (invertedNums[i] < heap.peek()) {
+                heap.pop();
+                heap.push(invertedNums[i]);
+            }
+        }
+        // 取出堆中元素
+        const maxHeap = heap.getMaxHeap();
+        // 对堆中元素取相反数
+        const invertedMaxHeap = maxHeap.map((num) => -num);
+        return invertedMaxHeap;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="top_k.dart"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    MinHeap topKHeap(List<int> nums, int k) {
+      // 将数组的前 k 个元素入堆
+      MinHeap heap = MinHeap(nums.sublist(0, k));
+      // 从第 k+1 个元素开始，保持堆的长度为 k
+      for (int i = k; i < nums.length; i++) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if (nums[i] > heap.peek()) {
+          heap.pop();
+          heap.push(nums[i]);
+        }
+      }
+      return heap;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="top_k.rs"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    fn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {
+        // Rust 的 BinaryHeap 是大顶堆，使用 Reverse 将元素大小反转
+        let mut heap = BinaryHeap::<Reverse<i32>>::new();
+        // 将数组的前 k 个元素入堆
+        for &num in nums.iter().take(k) {
+            heap.push(Reverse(num));
+        }
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for &num in nums.iter().skip(k) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if num > heap.peek().unwrap().0 {
+                heap.pop();
+                heap.push(Reverse(num));
+            }
+        }
+        heap
+    }
+    ```
+
+=== "C"
+
+    ```c title="top_k.c"
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "Zig"
+
+    ```zig title="top_k.zig"
+    [class]{}-[func]{topKHeap}
+    ```

docs/chapter_introduction/algorithms_are_everywhere.md

@@ -0,0 +1,66 @@
+---
+comments: true
+---
+
+# 1.1   算法无处不在
+
+当我们听到“算法”这个词时，很自然地会想到数学。然而实际上，许多算法并不涉及复杂数学，而是更多地依赖于基本逻辑，这些逻辑在我们的日常生活中处处可见。
+
+在正式探讨算法之前，有一个有趣的事实值得分享：**你已经在不知不觉中学会了许多算法，并习惯将它们应用到日常生活中了**。下面，我将举几个具体例子来证实这一点。
+
+**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会按照图 1-1 所示的方式实现。
+
+1. 翻开字典约一半的页数，查看该页的首字母是什么，假设首字母为 $m$ 。
+2. 由于在拼音字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。
+3. 不断重复步骤 `1.` 和 步骤 `2.` ，直至找到拼音首字母为 $r$ 的页码为止。
+
+=== "<1>"
+    ![查字典步骤](algorithms_are_everywhere.assets/binary_search_dictionary_step1.png)
+
+=== "<2>"
+    ![binary_search_dictionary_step2](algorithms_are_everywhere.assets/binary_search_dictionary_step2.png)
+
+=== "<3>"
+    ![binary_search_dictionary_step3](algorithms_are_everywhere.assets/binary_search_dictionary_step3.png)
+
+=== "<4>"
+    ![binary_search_dictionary_step4](algorithms_are_everywhere.assets/binary_search_dictionary_step4.png)
+
+=== "<5>"
+    ![binary_search_dictionary_step5](algorithms_are_everywhere.assets/binary_search_dictionary_step5.png)
+
+<p align="center"> 图 1-1 &nbsp; 查字典步骤 </p>
+
+查阅字典这个小学生必备技能，实际上就是著名的二分查找算法。从数据结构的角度，我们可以把字典视为一个已排序的“数组”；从算法的角度，我们可以将上述查字典的一系列操作看作是“二分查找”。
+
+**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如图 1-2 所示。
+
+1. 将扑克牌划分为“有序”和“无序”两部分，并假设初始状态下最左 1 张扑克牌已经有序。
+2. 在无序部分抽出一张扑克牌，插入至有序部分的正确位置；完成后最左 2 张扑克已经有序。
+3. 不断循环步骤 `2.` ，每一轮将一张扑克牌从无序部分插入至有序部分，直至所有扑克牌都有序。
+
+![扑克排序步骤](algorithms_are_everywhere.assets/playing_cards_sorting.png)
+
+<p align="center"> 图 1-2 &nbsp; 扑克排序步骤 </p>
+
+上述整理扑克牌的方法本质上是“插入排序”算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。
+
+**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给了收银员 $100$ 元，则收银员需要找我们 $31$ 元。他会很自然地完成如图 1-3 所示的思考。
+
+1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ 元、$5$ 元、$10$ 元、$20$ 元。
+2. 从可选项中拿出最大的 $20$ 元，剩余 $31 - 20 = 11$ 元。
+3. 从剩余可选项中拿出最大的 $10$ 元，剩余 $11 - 10 = 1$ 元。
+4. 从剩余可选项中拿出最大的 $1$ 元，剩余 $1 - 1 = 0$ 元。
+5. 完成找零，方案为 $20 + 10 + 1 = 31$ 元。
+
+![货币找零过程](algorithms_are_everywhere.assets/greedy_change.png)
+
+<p align="center"> 图 1-3 &nbsp; 货币找零过程 </p>
+
+在以上步骤中，我们每一步都采取当前看来最好的选择（尽可能用大面额的货币），最终得到了可行的找零方案。从数据结构与算法的角度看，这种方法本质上是“贪心”算法。
+
+小到烹饪一道菜，大到星际航行，几乎所有问题的解决都离不开算法。计算机的出现使我们能够通过编程将数据结构存储在内存中，同时编写代码调用 CPU 和 GPU 执行算法。这样一来，我们就能把生活中的问题转移到计算机上，以更高效的方式解决各种复杂问题。
+
+!!! tip
+
+    如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请继续往下阅读，这本书将引导你迈入数据结构与算法的知识殿堂。

docs/chapter_introduction/index.md

@@ -0,0 +1,24 @@
+---
+comments: true
+icon: material/calculator-variant-outline
+---
+
+# 第 1 章   初识算法
+
+<div class="center-table" markdown>
+
+![初识算法](../assets/covers/chapter_introduction.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    一位少女翩翩起舞，与数据交织在一起，裙摆上飘扬着算法的旋律。
+    
+    她邀请你共舞，请紧跟她的步伐，踏入充满逻辑与美感的算法世界。
+
+## 本章内容
+
+- [1.1 &nbsp; 算法无处不在](https://www.hello-algo.com/chapter_introduction/algorithms_are_everywhere/)
+- [1.2 &nbsp; 算法是什么](https://www.hello-algo.com/chapter_introduction/what_is_dsa/)
+- [1.3 &nbsp; 小结](https://www.hello-algo.com/chapter_introduction/summary/)

docs/chapter_introduction/summary.md

@@ -0,0 +1,13 @@
+---
+comments: true
+---
+
+# 1.3   小结
+
+- 算法在日常生活中无处不在，并不是遥不可及的高深知识。实际上，我们已经在不知不觉中学会了许多算法，用以解决生活中的大小问题。
+- 查阅字典的原理与二分查找算法相一致。二分查找算法体现了分而治之的重要算法思想。
+- 整理扑克的过程与插入排序算法非常类似。插入排序算法适合排序小型数据集。
+- 货币找零的步骤本质上是贪心算法，每一步都采取当前看来的最好的选择。
+- 算法是在有限时间内解决特定问题的一组指令或操作步骤，而数据结构是计算机中组织和存储数据的方式。
+- 数据结构与算法紧密相连。数据结构是算法的基石，而算法则是发挥数据结构作用的舞台。
+- 我们可以将数据结构与算法类比为拼装积木，积木代表数据，积木的形状和连接方式代表数据结构，拼装积木的步骤则对应算法。

docs/chapter_introduction/what_is_dsa.md

@@ -0,0 +1,65 @@
+---
+comments: true
+---
+
+# 1.2   算法是什么
+
+## 1.2.1   算法定义
+
+「算法 algorithm」是在有限时间内解决特定问题的一组指令或操作步骤，它具有以下特性。
+
+- 问题是明确的，包含清晰的输入和输出定义。
+- 具有可行性，能够在有限步骤、时间和内存空间下完成。
+- 各步骤都有确定的含义，相同的输入和运行条件下，输出始终相同。
+
+## 1.2.2   数据结构定义
+
+「数据结构 data structure」是计算机中组织和存储数据的方式，具有以下设计目标。
+
+- 空间占用尽量减少，节省计算机内存。
+- 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
+- 提供简洁的数据表示和逻辑信息，以便使得算法高效运行。
+
+**数据结构设计是一个充满权衡的过程**。如果想要在某方面取得提升，往往需要在另一方面作出妥协。下面举两个例子。
+
+- 链表相较于数组，在数据添加和删除操作上更加便捷，但牺牲了数据访问速度。
+- 图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。
+
+## 1.2.3   数据结构与算法的关系
+
+如图 1-4 所示，数据结构与算法高度相关、紧密结合，具体表现以下三个方面。
+
+- 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。
+- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，结合算法才能解决特定问题。
+- 算法通常可以基于不同的数据结构进行实现，但执行效率可能相差很大，选择合适的数据结构是关键。
+
+![数据结构与算法的关系](what_is_dsa.assets/relationship_between_data_structure_and_algorithm.png)
+
+<p align="center"> 图 1-4 &nbsp; 数据结构与算法的关系 </p>
+
+数据结构与算法犹如图 1-5 所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
+
+![拼装积木](what_is_dsa.assets/assembling_blocks.jpg)
+
+<p align="center"> 图 1-5 &nbsp; 拼装积木 </p>
+
+两者的详细对应关系如表 1-1 所示。
+
+<p align="center"> 表 1-1 &nbsp; 将数据结构与算法类比为积木 </p>
+
+<div class="center-table" markdown>
+
+| 数据结构与算法 | 拼装积木                                |
+| -------------- | ---------------------------------------- |
+| 输入数据       | 未拼装的积木                             |
+| 数据结构       | 积木组织形式，包括形状、大小、连接方式等 |
+| 算法           | 把积木拼成目标形态的一系列操作步骤       |
+| 输出数据       | 积木模型                                 |
+
+</div>
+
+值得说明的是，数据结构与算法是独立于编程语言的。正因如此，本书得以提供多种编程语言的实现。
+
+!!! tip "约定俗成的简称"
+
+    在实际讨论时，我们通常会将“数据结构与算法”简称为“算法”。比如众所周知的 LeetCode 算法题目，实际上同时考察了数据结构和算法两方面的知识。

docs/chapter_preface/about_the_book.md

@@ -0,0 +1,51 @@
+---
+comments: true
+---
+
+# 0.1   关于本书
+
+本项目旨在创建一本开源免费、新手友好的数据结构与算法入门教程。
+
+- 全书采用动画图解，结构化地讲解数据结构与算法知识，内容清晰易懂、学习曲线平滑。
+- 算法源代码皆可一键运行，支持 Java、C++、Python、Go、JS、TS、C#、Swift、Rust、Dart、Zig 等语言。
+- 鼓励读者在章节讨论区互帮互助、共同进步，提问与评论通常可在两日内得到回复。
+
+## 0.1.1   读者对象
+
+若您是算法初学者，从未接触过算法，或者已经有一些刷题经验，对数据结构与算法有模糊的认识，在会与不会之间反复横跳，那么这本书正是为您量身定制！
+
+如果您已经积累一定刷题量，熟悉大部分题型，那么本书可助您回顾与梳理算法知识体系，仓库源代码可以被当作“刷题工具库”或“算法字典”来使用。
+
+若您是算法大神，我们期待收到您的宝贵建议，或者[一起参与创作](https://www.hello-algo.com/chapter_appendix/contribution/)。
+
+!!! success "前置条件"
+
+    您需要至少具备任一语言的编程基础，能够阅读和编写简单代码。
+
+## 0.1.2   内容结构
+
+本书主要内容如图 0-1 所示。
+
+- **复杂度分析**：数据结构和算法的评价维度与方法。时间复杂度、空间复杂度的推算方法、常见类型、示例等。
+- **数据结构**：基本数据类型，数据结构的分类方法。数组、链表、栈、队列、哈希表、树、堆、图等数据结构的定义、优缺点、常用操作、常见类型、典型应用、实现方法等。
+- **算法**：搜索、排序、分治、回溯、动态规划、贪心等算法的定义、优缺点、效率、应用场景、解题步骤、示例题目等。
+
+![Hello 算法内容结构](about_the_book.assets/hello_algo_mindmap.jpg)
+
+<p align="center"> 图 0-1 &nbsp; Hello 算法内容结构 </p>
+
+## 0.1.3 &nbsp; 致谢
+
+在本书的创作过程中，我得到了许多人的帮助，包括但不限于：
+
+- 感谢我在公司的导师李汐博士，在一次畅谈中您鼓励我“快行动起来”，坚定了我写这本书的决心。
+- 感谢我的女朋友泡泡作为本书的首位读者，从算法小白的角度提出许多宝贵建议，使得本书更适合新手阅读。
+- 感谢腾宝、琦宝、飞宝为本书起了一个富有创意的名字，唤起大家写下第一行代码 "Hello World!" 的美好回忆。
+- 感谢苏潼为本书设计了精美的封面和 LOGO ，并在我的强迫症下多次耐心修改。
+- 感谢 @squidfunk 提供的写作排版建议，以及他开发的开源文档主题 [Material-for-MkDocs](https://github.com/squidfunk/mkdocs-material/tree/master) 。
+
+在写作过程中，我阅读了许多关于数据结构与算法的教材和文章。这些作品为本书提供了优秀的范本，确保了本书内容的准确性与品质。在此感谢所有老师和前辈们的杰出贡献！
+
+本书倡导手脑并用的学习方式，在这一点上深受[《动手学深度学习》](https://github.com/d2l-ai/d2l-zh)的启发。在此向各位读者强烈推荐这本优秀著作。
+
+衷心感谢我的父母，正是你们一直以来的支持与鼓励，让我有机会做这件富有趣味的事。

docs/chapter_preface/index.md

@@ -0,0 +1,24 @@
+---
+comments: true
+icon: material/book-open-outline
+---
+
+# 第 0 章   前言
+
+<div class="center-table" markdown>
+
+![前言](../assets/covers/chapter_preface.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    算法犹如美妙的交响乐，每一行代码都像韵律般流淌。
+    
+    愿这本书在你的脑海中轻轻响起，留下独特而深刻的旋律。
+
+## 本章内容
+
+- [0.1 &nbsp; 关于本书](https://www.hello-algo.com/chapter_preface/about_the_book/)
+- [0.2 &nbsp; 如何使用本书](https://www.hello-algo.com/chapter_preface/suggestions/)
+- [0.3 &nbsp; 小结](https://www.hello-algo.com/chapter_preface/summary/)

docs/chapter_preface/suggestions.md

@@ -0,0 +1,240 @@
+---
+comments: true
+---
+
+# 0.2   如何使用本书
+
+!!! tip
+
+    为了获得最佳的阅读体验，建议您通读本节内容。
+
+## 0.2.1   行文风格约定
+
+- 标题后标注 `*` 的是选读章节，内容相对困难。如果你的时间有限，建议可以先跳过。
+- 专有名词和有特指含义的词句会使用 `“双引号”` 标注，以避免歧义。
+- 重要专有名词及其英文翻译会用 `「 」` 括号标注，例如 `「数组 array」` 。建议记住它们，以便阅读文献。
+- **加粗的文字** 表示重点内容或总结性语句，这类文字值得特别关注。
+- 当涉及到编程语言之间不一致的名词时，本书均以 Python 为准，例如使用 $\text{None}$ 来表示“空”。
+- 本书部分放弃了编程语言的注释规范，以换取更加紧凑的内容排版。注释主要分为三种类型：标题注释、内容注释、多行注释。
+
+=== "Python"
+
+    ```python title=""
+    """标题注释，用于标注函数、类、测试样例等"""
+    
+    # 内容注释，用于详解代码
+    
+    """
+    多行
+    注释
+    """
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+    // 标题注释，用于标注函数、类、测试样例等
+    
+    // 内容注释，用于详解代码
+    
+    // 多行
+    // 注释
+    ```
+
+## 0.2.2   在动画图解中高效学习
+
+相较于文字，视频和图片具有更高的信息密度和结构化程度，更易于理解。在本书中，**重点和难点知识将主要通过动画和图解形式展示**，而文字则作为动画和图片的解释与补充。
+
+如果你在阅读本书时，发现某段内容提供了图 0-2 所示的动画或图解，**请以图为主、以文字为辅**，综合两者来理解内容。
+
+![动画图解示例](../index.assets/animation.gif)
+
+<p align="center"> 图 0-2 &nbsp; 动画图解示例 </p>
+
+## 0.2.3 &nbsp; 在代码实践中加深理解
+
+本书的配套代码被托管在 [GitHub 仓库](https://github.com/krahets/hello-algo)。如图 0-3 所示，**源代码附有测试样例，可一键运行**。
+
+如果时间允许，**建议你参照代码自行敲一遍**。如果学习时间有限，请至少通读并运行所有代码。
+
+与阅读代码相比，编写代码的过程往往能带来更多收获。**动手学，才是真的学**。
+
+![运行代码示例](../index.assets/running_code.gif)
+
+<p align="center"> 图 0-3 &nbsp; 运行代码示例 </p>
+
+运行代码的前置工作主要分为三步。
+
+**第一步：安装本地编程环境**。请参照[附录教程](https://www.hello-algo.com/chapter_appendix/installation/)进行安装，如果已安装则可跳过此步骤。
+
+**第二步：克隆或下载代码仓**。如果已经安装 [Git](https://git-scm.com/downloads) ，可以通过以下命令克隆本仓库。
+
+```shell
+git clone https://github.com/krahets/hello-algo.git
+```
+
+当然，你也可以在图 0-4 所示的位置，点击“Download ZIP”直接下载代码压缩包，然后在本地解压即可。
+
+![克隆仓库与下载代码](suggestions.assets/download_code.png)
+
+<p align="center"> 图 0-4 &nbsp; 克隆仓库与下载代码 </p>
+
+**第三步：运行源代码**。如图 0-5 所示，对于顶部标有文件名称的代码块，我们可以在仓库的 `codes` 文件夹内找到对应的源代码文件。源代码文件可一键运行，将帮助你节省不必要的调试时间，让你能够专注于学习内容。
+
+![代码块与对应的源代码文件](suggestions.assets/code_md_to_repo.png)
+
+<p align="center"> 图 0-5 &nbsp; 代码块与对应的源代码文件 </p>
+
+## 0.2.4 &nbsp; 在提问讨论中共同成长
+
+在阅读本书时，请不要轻易跳过那些没学明白的知识点。**欢迎在评论区提出你的问题**，我和小伙伴们将竭诚为你解答，一般情况下可在两天内回复。
+
+如图 0-6 所示，每篇文章的底部都配有评论区。希望你能多关注评论区的内容。一方面，你可以了解大家遇到的问题，从而查漏补缺，激发更深入的思考。另一方面，期待你能慷慨地回答其他小伙伴的问题，分享您的见解，帮助他人进步。
+
+![评论区示例](../index.assets/comment.gif)
+
+<p align="center"> 图 0-6 &nbsp; 评论区示例 </p>
+
+## 0.2.5 &nbsp; 算法学习路线
+
+从总体上看，我们可以将学习数据结构与算法的过程划分为三个阶段。
+
+1. **算法入门**。我们需要熟悉各种数据结构的特点和用法，学习不同算法的原理、流程、用途和效率等方面内容。
+2. **刷算法题**。建议从热门题目开刷，如[剑指 Offer](https://leetcode.cn/studyplan/coding-interviews/)和[LeetCode Hot 100](https://leetcode.cn/studyplan/top-100-liked/)，先积累至少 100 道题目，熟悉主流的算法问题。初次刷题时，“知识遗忘”可能是一个挑战，但请放心，这是很正常的。我们可以按照“艾宾浩斯遗忘曲线”来复习题目，通常在进行 3-5 轮的重复后，就能将其牢记在心。
+3. **搭建知识体系**。在学习方面，我们可以阅读算法专栏文章、解题框架和算法教材，以不断丰富知识体系。在刷题方面，可以尝试采用进阶刷题策略，如按专题分类、一题多解、一解多题等，相关的刷题心得可以在各个社区找到。
+
+如图 0-7 所示，本书内容主要涵盖“第一阶段”，旨在帮助你更高效地展开第二和第三阶段的学习。
+
+![算法学习路线](suggestions.assets/learning_route.png)
+
+<p align="center"> 图 0-7 &nbsp; 算法学习路线 </p>

docs/chapter_preface/summary.md

@@ -0,0 +1,12 @@
+---
+comments: true
+---
+
+# 0.3   小结
+
+- 本书的主要受众是算法初学者。如果已有一定基础，本书能帮助您系统回顾算法知识，书内源代码也可作为“刷题工具库”使用。
+- 书中内容主要包括复杂度分析、数据结构、算法三部分，涵盖了该领域的大部分主题。
+- 对于算法新手，在初学阶段阅读一本入门书籍至关重要，可以少走许多弯路。
+- 书内的动画和图解通常用于介绍重点和难点知识。阅读本书时，应给予这些内容更多关注。
+- 实践乃学习编程之最佳途径。强烈建议运行源代码并亲自敲打代码。
+- 本书网页版的每个章节都设有讨论区，欢迎随时分享你的疑惑与见解。

docs/chapter_reference/index.md

@@ -0,0 +1,19 @@
+# 参考文献
+
+[1] Thomas H. Cormen, et al. Introduction to Algorithms (3rd Edition).
+
+[2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1st Edition).
+
+[3] 严蔚敏. 数据结构（C 语言版）.
+
+[4] 邓俊辉. 数据结构（C++ 语言版，第三版）.
+
+[5] 马克 艾伦 维斯著，陈越译. 数据结构与算法分析：Java语言描述（第三版）.
+
+[6] 程杰. 大话数据结构.
+
+[7] 王争. 数据结构与算法之美.
+
+[8] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6th Edition). 
+
+[9] Aston Zhang, et al. Dive into Deep Learning.

docs/chapter_searching/binary_search.md

@@ -0,0 +1,645 @@
+---
+comments: true
+---
+
+# 10.1   二分查找
+
+「二分查找 binary search」是一种基于分治策略的高效搜索算法。它利用数据的有序性，每轮减少一半搜索范围，直至找到目标元素或搜索区间为空为止。
+
+!!! question
+
+    给定一个长度为 $n$ 的数组 `nums` ，元素按从小到大的顺序排列，数组不包含重复元素。请查找并返回元素 `target` 在该数组中的索引。若数组不包含该元素，则返回 $-1$ 。
+
+![二分查找示例数据](binary_search.assets/binary_search_example.png)
+
+<p align="center"> 图 10-1 &nbsp; 二分查找示例数据 </p>
+
+如图 10-2 所示，我们先初始化指针 $i = 0$ 和 $j = n - 1$ ，分别指向数组首元素和尾元素，代表搜索区间 $[0, n - 1]$ 。请注意，中括号表示闭区间，其包含边界值本身。
+
+接下来，循环执行以下两步。
+
+1. 计算中点索引 $m = \lfloor {(i + j) / 2} \rfloor$ ，其中 $\lfloor \: \rfloor$ 表示向下取整操作。
+2. 判断 `nums[m]` 和 `target` 的大小关系，分为以下三种情况。
+    1. 当 `nums[m] < target` 时，说明 `target` 在区间 $[m + 1, j]$ 中，因此执行 $i = m + 1$ 。
+    2. 当 `nums[m] > target` 时，说明 `target` 在区间 $[i, m - 1]$ 中，因此执行 $j = m - 1$ 。
+    3. 当 `nums[m] = target` 时，说明找到 `target` ，因此返回索引 $m$ 。
+
+若数组不包含目标元素，搜索区间最终会缩小为空。此时返回 $-1$ 。
+
+=== "<1>"
+    ![二分查找流程](binary_search.assets/binary_search_step1.png)
+
+=== "<2>"
+    ![binary_search_step2](binary_search.assets/binary_search_step2.png)
+
+=== "<3>"
+    ![binary_search_step3](binary_search.assets/binary_search_step3.png)
+
+=== "<4>"
+    ![binary_search_step4](binary_search.assets/binary_search_step4.png)
+
+=== "<5>"
+    ![binary_search_step5](binary_search.assets/binary_search_step5.png)
+
+=== "<6>"
+    ![binary_search_step6](binary_search.assets/binary_search_step6.png)
+
+=== "<7>"
+    ![binary_search_step7](binary_search.assets/binary_search_step7.png)
+
+<p align="center"> 图 10-2 &nbsp; 二分查找流程 </p>
+
+值得注意的是，由于 $i$ 和 $j$ 都是 `int` 类型，**因此 $i + j$ 可能会超出 `int` 类型的取值范围**。为了避免大数越界，我们通常采用公式 $m = \lfloor {i + (j - i) / 2} \rfloor$ 来计算中点。
+
+=== "Python"
+
+    ```python title="binary_search.py"
+    def binary_search(nums: list[int], target: int) -> int:
+        """二分查找（双闭区间）"""
+        # 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        i, j = 0, len(nums) - 1
+        # 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while i <= j:
+            # 理论上 Python 的数字可以无限大（取决于内存大小），无须考虑大数越界问题
+            m = (i + j) // 2  # 计算中点索引 m
+            if nums[m] < target:
+                i = m + 1  # 此情况说明 target 在区间 [m+1, j] 中
+            elif nums[m] > target:
+                j = m - 1  # 此情况说明 target 在区间 [i, m-1] 中
+            else:
+                return m  # 找到目标元素，返回其索引
+        return -1  # 未找到目标元素，返回 -1
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search.cpp"
+    /* 二分查找（双闭区间） */
+    int binarySearch(vector<int> &nums, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = nums.size() - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_search.java"
+    /* 二分查找（双闭区间） */
+    int binarySearch(int[] nums, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search.cs"
+    /* 二分查找（双闭区间） */
+    int BinarySearch(int[] nums, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = nums.Length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = i + (j - i) / 2;   // 计算中点索引 m
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else                       // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_search.go"
+    /* 二分查找（双闭区间） */
+    func binarySearch(nums []int, target int) int {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        i, j := 0, len(nums)-1
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        for i <= j {
+            m := i + (j-i)/2      // 计算中点索引 m
+            if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1
+            } else { // 找到目标元素，返回其索引
+                return m
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search.swift"
+    /* 二分查找（双闭区间） */
+    func binarySearch(nums: [Int], target: Int) -> Int {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        var i = 0
+        var j = nums.count - 1
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while i <= j {
+            let m = i + (j - i) / 2 // 计算中点索引 m
+            if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1
+            } else { // 找到目标元素，返回其索引
+                return m
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_search.js"
+    /* 二分查找（双闭区间） */
+    function binarySearch(nums, target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let i = 0,
+            j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            // 计算中点索引 m ，使用 parseInt() 向下取整
+            const m = parseInt(i + (j - i) / 2);
+            if (nums[m] < target)
+                // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target)
+                // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else return m; // 找到目标元素，返回其索引
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_search.ts"
+    /* 二分查找（双闭区间） */
+    function binarySearch(nums: number[], target: number): number {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let i = 0,
+            j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            // 计算中点索引 m
+            const m = Math.floor(i + (j - i) / 2);
+            if (nums[m] < target) {
+                // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            } else if (nums[m] > target) {
+                // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {
+                // 找到目标元素，返回其索引
+                return m;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search.dart"
+    /* 二分查找（双闭区间） */
+    int binarySearch(List<int> nums, int target) {
+      // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+      int i = 0, j = nums.length - 1;
+      // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          // 此情况说明 target 在区间 [m+1, j] 中
+          i = m + 1;
+        } else if (nums[m] > target) {
+          // 此情况说明 target 在区间 [i, m-1] 中
+          j = m - 1;
+        } else {
+          // 找到目标元素，返回其索引
+          return m;
+        }
+      }
+      // 未找到目标元素，返回 -1
+      return -1;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_search.rs"
+    /* 二分查找（双闭区间） */
+    fn binary_search(nums: &[i32], target: i32) -> i32 {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let mut i = 0;
+        let mut j = nums.len() as i32 - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while i <= j {
+            let m = i + (j - i) / 2;      // 计算中点索引 m
+            if nums[m as usize] < target {         // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            } else if nums[m as usize] > target {  // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {                      // 找到目标元素，返回其索引
+                return m;
+            }                       
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_search.c"
+    /* 二分查找（双闭区间） */
+    int binarySearch(int *nums, int len, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = len - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search.zig"
+    // 二分查找（双闭区间）
+    fn binarySearch(comptime T: type, nums: std.ArrayList(T), target: T) T {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        var i: usize = 0;
+        var j: usize = nums.items.len - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            var m = i + (j - i) / 2;                // 计算中点索引 m
+            if (nums.items[m] < target) {           // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            } else if (nums.items[m] > target) {    // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {                                // 找到目标元素，返回其索引
+                return @intCast(m);
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+**时间复杂度 $O(\log n)$** ：在二分循环中，区间每轮缩小一半，循环次数为 $\log_2 n$ 。
+
+**空间复杂度 $O(1)$** ：指针 $i$ 和 $j$ 使用常数大小空间。
+
+## 10.1.1 &nbsp; 区间表示方法
+
+除了上述的双闭区间外，常见的区间表示还有“左闭右开”区间，定义为 $[0, n)$ ，即左边界包含自身，右边界不包含自身。在该表示下，区间 $[i, j]$ 在 $i = j$ 时为空。
+
+我们可以基于该表示实现具有相同功能的二分查找算法。
+
+=== "Python"
+
+    ```python title="binary_search.py"
+    def binary_search_lcro(nums: list[int], target: int) -> int:
+        """二分查找（左闭右开）"""
+        # 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        i, j = 0, len(nums)
+        # 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while i < j:
+            m = (i + j) // 2  # 计算中点索引 m
+            if nums[m] < target:
+                i = m + 1  # 此情况说明 target 在区间 [m+1, j) 中
+            elif nums[m] > target:
+                j = m  # 此情况说明 target 在区间 [i, m) 中
+            else:
+                return m  # 找到目标元素，返回其索引
+        return -1  # 未找到目标元素，返回 -1
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search.cpp"
+    /* 二分查找（左闭右开） */
+    int binarySearchLCRO(vector<int> &nums, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = nums.size();
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_search.java"
+    /* 二分查找（左闭右开） */
+    int binarySearchLCRO(int[] nums, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search.cs"
+    /* 二分查找（左闭右开） */
+    int BinarySearchLCRO(int[] nums, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = nums.Length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = i + (j - i) / 2;   // 计算中点索引 m
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else                       // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_search.go"
+    /* 二分查找（左闭右开） */
+    func binarySearchLCRO(nums []int, target int) int {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        i, j := 0, len(nums)
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        for i < j {
+            m := i + (j-i)/2      // 计算中点索引 m
+            if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
+                j = m
+            } else { // 找到目标元素，返回其索引
+                return m
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search.swift"
+    /* 二分查找（左闭右开） */
+    func binarySearchLCRO(nums: [Int], target: Int) -> Int {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        var i = 0
+        var j = nums.count
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while i < j {
+            let m = i + (j - i) / 2 // 计算中点索引 m
+            if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
+                j = m
+            } else { // 找到目标元素，返回其索引
+                return m
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_search.js"
+    /* 二分查找（左闭右开） */
+    function binarySearchLCRO(nums, target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0,
+            j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            // 计算中点索引 m ，使用 parseInt() 向下取整
+            const m = parseInt(i + (j - i) / 2);
+            if (nums[m] < target)
+                // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target)
+                // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            // 找到目标元素，返回其索引
+            else return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_search.ts"
+    /* 二分查找（左闭右开） */
+    function binarySearchLCRO(nums: number[], target: number): number {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0,
+            j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            // 计算中点索引 m
+            const m = Math.floor(i + (j - i) / 2);
+            if (nums[m] < target) {
+                // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if (nums[m] > target) {
+                // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            } else {
+                // 找到目标元素，返回其索引
+                return m;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search.dart"
+    /* 二分查找（左闭右开区间） */
+    int binarySearchLCRO(List<int> nums, int target) {
+      // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+      int i = 0, j = nums.length;
+      // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+      while (i < j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          // 此情况说明 target 在区间 [m+1, j) 中
+          i = m + 1;
+        } else if (nums[m] > target) {
+          // 此情况说明 target 在区间 [i, m) 中
+          j = m;
+        } else {
+          // 找到目标元素，返回其索引
+          return m;
+        }
+      }
+      // 未找到目标元素，返回 -1
+      return -1;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_search.rs"
+    /* 二分查找（左闭右开） */
+    fn binary_search_lcro(nums: &[i32], target: i32) -> i32 {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let mut i = 0;
+        let mut j = nums.len() as i32;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while i < j {
+            let m = i + (j - i) / 2;      // 计算中点索引 m
+            if nums[m as usize] < target {         // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if nums[m as usize] > target {  // 此情况说明 target 在区间 [i, m) 中
+                j = m - 1;
+            } else {                      // 找到目标元素，返回其索引
+                return m;
+            }                       
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_search.c"
+    /* 二分查找（左闭右开） */
+    int binarySearchLCRO(int *nums, int len, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = len;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search.zig"
+    // 二分查找（左闭右开）
+    fn binarySearchLCRO(comptime T: type, nums: std.ArrayList(T), target: T) T {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        var i: usize = 0;
+        var j: usize = nums.items.len;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i <= j) {
+            var m = i + (j - i) / 2;                // 计算中点索引 m
+            if (nums.items[m] < target) {           // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if (nums.items[m] > target) {    // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            } else {                                // 找到目标元素，返回其索引
+                return @intCast(m);
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
+如图 10-3 所示，在两种区间表示下，二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。
+
+由于“双闭区间”表示中的左右边界都被定义为闭区间，因此指针 $i$ 和 $j$ 缩小区间操作也是对称的。这样更不容易出错，**因此一般建议采用“双闭区间”的写法**。
+
+![两种区间定义](binary_search.assets/binary_search_ranges.png)
+
+<p align="center"> 图 10-3 &nbsp; 两种区间定义 </p>
+
+## 10.1.2 &nbsp; 优点与局限性
+
+二分查找在时间和空间方面都有较好的性能。
+
+- 二分查找的时间效率高。在大数据量下，对数阶的时间复杂度具有显著优势。例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需 $\log_2 2^{20} = 20$ 轮循环。
+- 二分查找无须额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。
+
+然而，二分查找并非适用于所有情况，主要有以下原因。
+
+- 二分查找仅适用于有序数据。若输入数据无序，为了使用二分查找而专门进行排序，得不偿失。因为排序算法的时间复杂度通常为 $O(n \log n)$ ，比线性查找和二分查找都更高。对于频繁插入元素的场景，为保持数组有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
+- 二分查找仅适用于数组。二分查找需要跳跃式（非连续地）访问元素，而在链表中执行跳跃式访问的效率较低，因此不适合应用在链表或基于链表实现的数据结构。
+- 小数据量下，线性查找性能更佳。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，当数据量 $n$ 较小时，线性查找反而比二分查找更快。

docs/chapter_searching/binary_search_edge.md

@@ -0,0 +1,438 @@
+---
+comments: true
+---
+
+# 10.3   二分查找边界
+
+## 10.3.1   查找左边界
+
+!!! question
+
+    给定一个长度为 $n$ 的有序数组 `nums` ，数组可能包含重复元素。请返回数组中最左一个元素 `target` 的索引。若数组中不包含该元素，则返回 $-1$ 。
+
+回忆二分查找插入点的方法，搜索完成后 $i$ 指向最左一个 `target` ，**因此查找插入点本质上是在查找最左一个 `target` 的索引**。
+
+考虑通过查找插入点的函数实现查找左边界。请注意，数组中可能不包含 `target` ，这种情况可能导致以下两种结果。
+
+- 插入点的索引 $i$ 越界。
+- 元素 `nums[i]` 与 `target` 不相等。
+
+当遇到以上两种情况时，直接返回 $-1$ 即可。
+
+=== "Python"
+
+    ```python title="binary_search_edge.py"
+    def binary_search_left_edge(nums: list[int], target: int) -> int:
+        """二分查找最左一个 target"""
+        # 等价于查找 target 的插入点
+        i = binary_search_insertion(nums, target)
+        # 未找到 target ，返回 -1
+        if i == len(nums) or nums[i] != target:
+            return -1
+        # 找到 target ，返回索引 i
+        return i
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search_edge.cpp"
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(vector<int> &nums, int target) {
+        // 等价于查找 target 的插入点
+        int i = binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i == nums.size() || nums[i] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_search_edge.java"
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(int[] nums, int target) {
+        // 等价于查找 target 的插入点
+        int i = binary_search_insertion.binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i == nums.length || nums[i] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search_edge.cs"
+    /* 二分查找最左一个 target */
+    int BinarySearchLeftEdge(int[] nums, int target) {
+        // 等价于查找 target 的插入点
+        int i = binary_search_insertion.BinarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i == nums.Length || nums[i] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_edge.go"
+    /* 二分查找最左一个 target */
+    func binarySearchLeftEdge(nums []int, target int) int {
+        // 等价于查找 target 的插入点
+        i := binarySearchInsertion(nums, target)
+        // 未找到 target ，返回 -1
+        if i == len(nums) || nums[i] != target {
+            return -1
+        }
+        // 找到 target ，返回索引 i
+        return i
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search_edge.swift"
+    /* 二分查找最左一个 target */
+    func binarySearchLeftEdge(nums: [Int], target: Int) -> Int {
+        // 等价于查找 target 的插入点
+        let i = binarySearchInsertion(nums: nums, target: target)
+        // 未找到 target ，返回 -1
+        if i == nums.count || nums[i] != target {
+            return -1
+        }
+        // 找到 target ，返回索引 i
+        return i
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_search_edge.js"
+    /* 二分查找最左一个 target */
+    function binarySearchLeftEdge(nums, target) {
+        // 等价于查找 target 的插入点
+        const i = binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i === nums.length || nums[i] !== target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_search_edge.ts"
+    /* 二分查找最左一个 target */
+    function binarySearchLeftEdge(nums: Array<number>, target: number): number {
+        // 等价于查找 target 的插入点
+        const i = binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i === nums.length || nums[i] !== target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search_edge.dart"
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(List<int> nums, int target) {
+      // 等价于查找 target 的插入点
+      int i = binarySearchInsertion(nums, target);
+      // 未找到 target ，返回 -1
+      if (i == nums.length || nums[i] != target) {
+        return -1;
+      }
+      // 找到 target ，返回索引 i
+      return i;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_search_edge.rs"
+    /* 二分查找最左一个 target */
+    fn binary_search_left_edge(nums: &[i32], target: i32) -> i32 {
+        // 等价于查找 target 的插入点
+        let i = binary_search_insertion(nums, target);
+        // 未找到 target ，返回 -1
+        if i == nums.len() as i32 || nums[i as usize] != target {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        i
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_search_edge.c"
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(int *nums, int numSize, int target) {
+        // 等价于查找 target 的插入点
+        int i = binarySearchInsertion(nums, numSize, target);
+        // 未找到 target ，返回 -1
+        if (i == numSize || nums[i] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_edge.zig"
+    [class]{}-[func]{binarySearchLeftEdge}
+    ```
+
+## 10.3.2 &nbsp; 查找右边界
+
+那么如何查找最右一个 `target` 呢？最直接的方式是修改代码，替换在 `nums[m] == target` 情况下的指针收缩操作。代码在此省略，有兴趣的同学可以自行实现。
+
+下面我们介绍两种更加取巧的方法。
+
+### 1. &nbsp; 复用查找左边界
+
+实际上，我们可以利用查找最左元素的函数来查找最右元素，具体方法为：**将查找最右一个 `target` 转化为查找最左一个 `target + 1`**。
+
+如图 10-7 所示，查找完成后，指针 $i$ 指向最左一个 `target + 1`（如果存在），而 $j$ 指向最右一个 `target` ，**因此返回 $j$ 即可**。
+
+![将查找右边界转化为查找左边界](binary_search_edge.assets/binary_search_right_edge_by_left_edge.png)
+
+<p align="center"> 图 10-7 &nbsp; 将查找右边界转化为查找左边界 </p>
+
+请注意，返回的插入点是 $i$ ，因此需要将其减 $1$ ，从而获得 $j$ 。
+
+=== "Python"
+
+    ```python title="binary_search_edge.py"
+    def binary_search_right_edge(nums: list[int], target: int) -> int:
+        """二分查找最右一个 target"""
+        # 转化为查找最左一个 target + 1
+        i = binary_search_insertion(nums, target + 1)
+        # j 指向最右一个 target ，i 指向首个大于 target 的元素
+        j = i - 1
+        # 未找到 target ，返回 -1
+        if j == -1 or nums[j] != target:
+            return -1
+        # 找到 target ，返回索引 j
+        return j
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search_edge.cpp"
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(vector<int> &nums, int target) {
+        // 转化为查找最左一个 target + 1
+        int i = binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        int j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_search_edge.java"
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(int[] nums, int target) {
+        // 转化为查找最左一个 target + 1
+        int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        int j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search_edge.cs"
+    /* 二分查找最右一个 target */
+    int BinarySearchRightEdge(int[] nums, int target) {
+        // 转化为查找最左一个 target + 1
+        int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        int j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_edge.go"
+    /* 二分查找最右一个 target */
+    func binarySearchRightEdge(nums []int, target int) int {
+        // 转化为查找最左一个 target + 1
+        i := binarySearchInsertion(nums, target+1)
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        j := i - 1
+        // 未找到 target ，返回 -1
+        if j == -1 || nums[j] != target {
+            return -1
+        }
+        // 找到 target ，返回索引 j
+        return j
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search_edge.swift"
+    /* 二分查找最右一个 target */
+    func binarySearchRightEdge(nums: [Int], target: Int) -> Int {
+        // 转化为查找最左一个 target + 1
+        let i = binarySearchInsertion(nums: nums, target: target + 1)
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        let j = i - 1
+        // 未找到 target ，返回 -1
+        if j == -1 || nums[j] != target {
+            return -1
+        }
+        // 找到 target ，返回索引 j
+        return j
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_search_edge.js"
+    /* 二分查找最右一个 target */
+    function binarySearchRightEdge(nums, target) {
+        // 转化为查找最左一个 target + 1
+        const i = binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        const j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j === -1 || nums[j] !== target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_search_edge.ts"
+    /* 二分查找最右一个 target */
+    function binarySearchRightEdge(nums: Array<number>, target: number): number {
+        // 转化为查找最左一个 target + 1
+        const i = binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        const j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j === -1 || nums[j] !== target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search_edge.dart"
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(List<int> nums, int target) {
+      // 转化为查找最左一个 target + 1
+      int i = binarySearchInsertion(nums, target + 1);
+      // j 指向最右一个 target ，i 指向首个大于 target 的元素
+      int j = i - 1;
+      // 未找到 target ，返回 -1
+      if (j == -1 || nums[j] != target) {
+        return -1;
+      }
+      // 找到 target ，返回索引 j
+      return j;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_search_edge.rs"
+    /* 二分查找最右一个 target */
+    fn binary_search_right_edge(nums: &[i32], target: i32) -> i32 {
+        // 转化为查找最左一个 target + 1
+        let i = binary_search_insertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        let j = i - 1;
+        // 未找到 target ，返回 -1
+        if j == -1 || nums[j as usize] != target {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        j
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_search_edge.c"
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(int *nums, int numSize, int target) {
+        // 转化为查找最左一个 target + 1
+        int i = binarySearchInsertion(nums, numSize, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        int j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_edge.zig"
+    [class]{}-[func]{binarySearchRightEdge}
+    ```
+
+### 2. &nbsp; 转化为查找元素
+
+我们知道，当数组不包含 `target` 时，最终 $i$ 和 $j$ 会分别指向首个大于、小于 `target` 的元素。
+
+因此，如图 10-8 所示，我们可以构造一个数组中不存在的元素，用于查找左右边界。
+
+- 查找最左一个 `target` ：可以转化为查找 `target - 0.5` ，并返回指针 $i$ 。
+- 查找最右一个 `target` ：可以转化为查找 `target + 0.5` ，并返回指针 $j$ 。
+
+![将查找边界转化为查找元素](binary_search_edge.assets/binary_search_edge_by_element.png)
+
+<p align="center"> 图 10-8 &nbsp; 将查找边界转化为查找元素 </p>
+
+代码在此省略，值得注意以下两点。
+
+- 给定数组不包含小数，这意味着我们无须关心如何处理相等的情况。
+- 因为该方法引入了小数，所以需要将函数中的变量 `target` 改为浮点数类型。

docs/chapter_searching/binary_search_insertion.md

@@ -0,0 +1,578 @@
+---
+comments: true
+---
+
+# 10.2   二分查找插入点
+
+二分查找不仅可用于搜索目标元素，还具有许多变种问题，比如搜索目标元素的插入位置。
+
+## 10.2.1   无重复元素的情况
+
+!!! question
+
+    给定一个长度为 $n$ 的有序数组 `nums` 和一个元素 `target` ，数组不存在重复元素。现将 `target` 插入到数组 `nums` 中，并保持其有序性。若数组中已存在元素 `target` ，则插入到其左方。请返回插入后 `target` 在数组中的索引。
+
+![二分查找插入点示例数据](binary_search_insertion.assets/binary_search_insertion_example.png)
+
+<p align="center"> 图 10-4 &nbsp; 二分查找插入点示例数据 </p>
+
+如果想要复用上节的二分查找代码，则需要回答以下两个问题。
+
+**问题一**：当数组中包含 `target` 时，插入点的索引是否是该元素的索引？
+
+题目要求将 `target` 插入到相等元素的左边，这意味着新插入的 `target` 替换了原来 `target` 的位置。也就是说，**当数组包含 `target` 时，插入点的索引就是该 `target` 的索引**。
+
+**问题二**：当数组中不存在 `target` 时，插入点是哪个元素的索引？
+
+进一步思考二分查找过程：当 `nums[m] < target` 时 $i$ 移动，这意味着指针 $i$ 在向大于等于 `target` 的元素靠近。同理，指针 $j$ 始终在向小于等于 `target` 的元素靠近。
+
+因此二分结束时一定有：$i$ 指向首个大于 `target` 的元素，$j$ 指向首个小于 `target` 的元素。**易得当数组不包含 `target` 时，插入索引为 $i$** 。
+
+=== "Python"
+
+    ```python title="binary_search_insertion.py"
+    def binary_search_insertion_simple(nums: list[int], target: int) -> int:
+        """二分查找插入点（无重复元素）"""
+        i, j = 0, len(nums) - 1  # 初始化双闭区间 [0, n-1]
+        while i <= j:
+            m = (i + j) // 2  # 计算中点索引 m
+            if nums[m] < target:
+                i = m + 1  # target 在区间 [m+1, j] 中
+            elif nums[m] > target:
+                j = m - 1  # target 在区间 [i, m-1] 中
+            else:
+                return m  # 找到 target ，返回插入点 m
+        # 未找到 target ，返回插入点 i
+        return i
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search_insertion.cpp"
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(vector<int> &nums, int target) {
+        int i = 0, j = nums.size() - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_search_insertion.java"
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(int[] nums, int target) {
+        int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search_insertion.cs"
+    /* 二分查找插入点（无重复元素） */
+    int BinarySearchInsertionSimple(int[] nums, int target) {
+        int i = 0, j = nums.Length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_insertion.go"
+    /* 二分查找插入点（无重复元素） */
+    func binarySearchInsertionSimple(nums []int, target int) int {
+        // 初始化双闭区间 [0, n-1]
+        i, j := 0, len(nums)-1
+        for i <= j {
+            // 计算中点索引 m
+            m := i + (j-i)/2
+            if nums[m] < target {
+                // target 在区间 [m+1, j] 中
+                i = m + 1
+            } else if nums[m] > target {
+                // target 在区间 [i, m-1] 中
+                j = m - 1
+            } else {
+                // 找到 target ，返回插入点 m
+                return m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search_insertion.swift"
+    /* 二分查找插入点（无重复元素） */
+    func binarySearchInsertionSimple(nums: [Int], target: Int) -> Int {
+        var i = 0, j = nums.count - 1 // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2 // 计算中点索引 m
+            if nums[m] < target {
+                i = m + 1 // target 在区间 [m+1, j] 中
+            } else if nums[m] > target {
+                j = m - 1 // target 在区间 [i, m-1] 中
+            } else {
+                return m // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_search_insertion.js"
+    /* 二分查找插入点（无重复元素） */
+    function binarySearchInsertionSimple(nums, target) {
+        let i = 0,
+            j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_search_insertion.ts"
+    /* 二分查找插入点（无重复元素） */
+    function binarySearchInsertionSimple(
+        nums: Array<number>,
+        target: number
+    ): number {
+        let i = 0,
+            j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search_insertion.dart"
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(List<int> nums, int target) {
+      int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          i = m + 1; // target 在区间 [m+1, j] 中
+        } else if (nums[m] > target) {
+          j = m - 1; // target 在区间 [i, m-1] 中
+        } else {
+          return m; // 找到 target ，返回插入点 m
+        }
+      }
+      // 未找到 target ，返回插入点 i
+      return i;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_search_insertion.rs"
+    /* 二分查找插入点（存在重复元素） */
+    pub fn binary_search_insertion(nums: &[i32], target: i32) -> i32 {
+        let (mut i, mut j) = (0, nums.len() as i32 - 1);    // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2;    // 计算中点索引 m
+            if nums[m as usize] < target {
+                i = m + 1;  // target 在区间 [m+1, j] 中
+            } else if nums[m as usize] > target {
+                j = m - 1;  // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1;  // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        i
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_search_insertion.c"
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(int *nums, int numSize, int target) {
+        int i = 0, j = numSize - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_insertion.zig"
+    [class]{}-[func]{binarySearchInsertionSimple}
+    ```
+
+## 10.2.2 &nbsp; 存在重复元素的情况
+
+!!! question
+
+    在上一题的基础上，规定数组可能包含重复元素，其余不变。
+
+假设数组中存在多个 `target` ，则普通二分查找只能返回其中一个 `target` 的索引，**而无法确定该元素的左边和右边还有多少 `target`**。
+
+题目要求将目标元素插入到最左边，**所以我们需要查找数组中最左一个 `target` 的索引**。初步考虑通过图 10-5 所示的步骤实现。
+
+1. 执行二分查找，得到任意一个 `target` 的索引，记为 $k$ 。
+2. 从索引 $k$ 开始，向左进行线性遍历，当找到最左边的 `target` 时返回。
+
+![线性查找重复元素的插入点](binary_search_insertion.assets/binary_search_insertion_naive.png)
+
+<p align="center"> 图 10-5 &nbsp; 线性查找重复元素的插入点 </p>
+
+此方法虽然可用，但其包含线性查找，因此时间复杂度为 $O(n)$ 。当数组中存在很多重复的 `target` 时，该方法效率很低。
+
+现考虑拓展二分查找代码。如图 10-6 所示，整体流程保持不变，每轮先计算中点索引 $m$ ，再判断 `target` 和 `nums[m]` 大小关系，分为以下几种情况。
+
+- 当 `nums[m] < target` 或 `nums[m] > target` 时，说明还没有找到 `target` ，因此采用普通二分查找的缩小区间操作，**从而使指针 $i$ 和 $j$ 向 `target` 靠近**。
+- 当 `nums[m] == target` 时，说明小于 `target` 的元素在区间 $[i, m - 1]$ 中，因此采用 $j = m - 1$ 来缩小区间，**从而使指针 $j$ 向小于 `target` 的元素靠近**。
+
+循环完成后，$i$ 指向最左边的 `target` ，$j$ 指向首个小于 `target` 的元素，**因此索引 $i$ 就是插入点**。
+
+=== "<1>"
+    ![二分查找重复元素的插入点的步骤](binary_search_insertion.assets/binary_search_insertion_step1.png)
+
+=== "<2>"
+    ![binary_search_insertion_step2](binary_search_insertion.assets/binary_search_insertion_step2.png)
+
+=== "<3>"
+    ![binary_search_insertion_step3](binary_search_insertion.assets/binary_search_insertion_step3.png)
+
+=== "<4>"
+    ![binary_search_insertion_step4](binary_search_insertion.assets/binary_search_insertion_step4.png)
+
+=== "<5>"
+    ![binary_search_insertion_step5](binary_search_insertion.assets/binary_search_insertion_step5.png)
+
+=== "<6>"
+    ![binary_search_insertion_step6](binary_search_insertion.assets/binary_search_insertion_step6.png)
+
+=== "<7>"
+    ![binary_search_insertion_step7](binary_search_insertion.assets/binary_search_insertion_step7.png)
+
+=== "<8>"
+    ![binary_search_insertion_step8](binary_search_insertion.assets/binary_search_insertion_step8.png)
+
+<p align="center"> 图 10-6 &nbsp; 二分查找重复元素的插入点的步骤 </p>
+
+观察以下代码，判断分支 `nums[m] > target` 和 `nums[m] == target` 的操作相同，因此两者可以合并。
+
+即便如此，我们仍然可以将判断条件保持展开，因为其逻辑更加清晰、可读性更好。
+
+=== "Python"
+
+    ```python title="binary_search_insertion.py"
+    def binary_search_insertion(nums: list[int], target: int) -> int:
+        """二分查找插入点（存在重复元素）"""
+        i, j = 0, len(nums) - 1  # 初始化双闭区间 [0, n-1]
+        while i <= j:
+            m = (i + j) // 2  # 计算中点索引 m
+            if nums[m] < target:
+                i = m + 1  # target 在区间 [m+1, j] 中
+            elif nums[m] > target:
+                j = m - 1  # target 在区间 [i, m-1] 中
+            else:
+                j = m - 1  # 首个小于 target 的元素在区间 [i, m-1] 中
+        # 返回插入点 i
+        return i
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search_insertion.cpp"
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(vector<int> &nums, int target) {
+        int i = 0, j = nums.size() - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_search_insertion.java"
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(int[] nums, int target) {
+        int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search_insertion.cs"
+    /* 二分查找插入点（存在重复元素） */
+    int BinarySearchInsertion(int[] nums, int target) {
+        int i = 0, j = nums.Length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_insertion.go"
+    /* 二分查找插入点（存在重复元素） */
+    func binarySearchInsertion(nums []int, target int) int {
+        // 初始化双闭区间 [0, n-1]
+        i, j := 0, len(nums)-1
+        for i <= j {
+            // 计算中点索引 m
+            m := i + (j-i)/2
+            if nums[m] < target {
+                // target 在区间 [m+1, j] 中
+                i = m + 1
+            } else if nums[m] > target {
+                // target 在区间 [i, m-1] 中
+                j = m - 1
+            } else {
+                // 首个小于 target 的元素在区间 [i, m-1] 中
+                j = m - 1
+            }
+        }
+        // 返回插入点 i
+        return i
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search_insertion.swift"
+    /* 二分查找插入点（存在重复元素） */
+    func binarySearchInsertion(nums: [Int], target: Int) -> Int {
+        var i = 0, j = nums.count - 1 // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2 // 计算中点索引 m
+            if nums[m] < target {
+                i = m + 1 // target 在区间 [m+1, j] 中
+            } else if nums[m] > target {
+                j = m - 1 // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1 // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_search_insertion.js"
+    /* 二分查找插入点（存在重复元素） */
+    function binarySearchInsertion(nums, target) {
+        let i = 0,
+            j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_search_insertion.ts"
+    /* 二分查找插入点（存在重复元素） */
+    function binarySearchInsertion(nums: Array<number>, target: number): number {
+        let i = 0,
+            j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search_insertion.dart"
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(List<int> nums, int target) {
+      int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          i = m + 1; // target 在区间 [m+1, j] 中
+        } else if (nums[m] > target) {
+          j = m - 1; // target 在区间 [i, m-1] 中
+        } else {
+          j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+        }
+      }
+      // 返回插入点 i
+      return i;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_search_insertion.rs"
+    /* 二分查找插入点（存在重复元素） */
+    pub fn binary_search_insertion(nums: &[i32], target: i32) -> i32 {
+        let (mut i, mut j) = (0, nums.len() as i32 - 1);    // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2;    // 计算中点索引 m
+            if nums[m as usize] < target {
+                i = m + 1;  // target 在区间 [m+1, j] 中
+            } else if nums[m as usize] > target {
+                j = m - 1;  // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1;  // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        i
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_search_insertion.c"
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(int *nums, int numSize, int target) {
+        int i = 0, j = numSize - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_insertion.zig"
+    [class]{}-[func]{binarySearchInsertion}
+    ```
+
+!!! tip
+
+    本节的代码都是“双闭区间”写法。有兴趣的读者可以自行实现“左闭右开”写法。
+
+总的来看，二分查找无非就是给指针 $i$ 和 $j$ 分别设定搜索目标，目标可能是一个具体的元素（例如 `target` ），也可能是一个元素范围（例如小于 `target` 的元素）。
+
+在不断的循环二分中，指针 $i$ 和 $j$ 都逐渐逼近预先设定的目标。最终，它们或是成功找到答案，或是越过边界后停止。

docs/chapter_searching/index.md

@@ -0,0 +1,27 @@
+---
+comments: true
+icon: material/text-search
+---
+
+# 第 10 章   搜索
+
+<div class="center-table" markdown>
+
+![搜索](../assets/covers/chapter_searching.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    搜索是一场未知的冒险，我们或许需要走遍神秘空间的每个角落，又或许可以快速锁定目标。
+    
+    在这场寻觅之旅中，每一次探索都可能得到一个未曾料想的答案。
+
+## 本章内容
+
+- [10.1 &nbsp; 二分查找](https://www.hello-algo.com/chapter_searching/binary_search/)
+- [10.2 &nbsp; 二分查找插入点](https://www.hello-algo.com/chapter_searching/binary_search_insertion/)
+- [10.3 &nbsp; 二分查找边界](https://www.hello-algo.com/chapter_searching/binary_search_edge/)
+- [10.4 &nbsp; 哈希优化策略](https://www.hello-algo.com/chapter_searching/replace_linear_by_hashing/)
+- [10.5 &nbsp; 重识搜索算法](https://www.hello-algo.com/chapter_searching/searching_algorithm_revisited/)
+- [10.6 &nbsp; 小结](https://www.hello-algo.com/chapter_searching/summary/)

docs/chapter_searching/replace_linear_by_hashing.md

@@ -0,0 +1,508 @@
+---
+comments: true
+---
+
+# 10.4   哈希优化策略
+
+在算法题中，**我们常通过将线性查找替换为哈希查找来降低算法的时间复杂度**。我们借助一个算法题来加深理解。
+
+!!! question
+
+    给定一个整数数组 `nums` 和一个目标元素 `target` ，请在数组中搜索“和”为 `target` 的两个元素，并返回它们的数组索引。返回任意一个解即可。
+
+## 10.4.1   线性查找：以时间换空间
+
+考虑直接遍历所有可能的组合。如图 10-9 所示，我们开启一个两层循环，在每轮中判断两个整数的和是否为 `target` ，若是则返回它们的索引。
+
+![线性查找求解两数之和](replace_linear_by_hashing.assets/two_sum_brute_force.png)
+
+<p align="center"> 图 10-9 &nbsp; 线性查找求解两数之和 </p>
+
+=== "Python"
+
+    ```python title="two_sum.py"
+    def two_sum_brute_force(nums: list[int], target: int) -> list[int]:
+        """方法一：暴力枚举"""
+        # 两层循环，时间复杂度 O(n^2)
+        for i in range(len(nums) - 1):
+            for j in range(i + 1, len(nums)):
+                if nums[i] + nums[j] == target:
+                    return [i, j]
+        return []
+    ```
+
+=== "C++"
+
+    ```cpp title="two_sum.cpp"
+    /* 方法一：暴力枚举 */
+    vector<int> twoSumBruteForce(vector<int> &nums, int target) {
+        int size = nums.size();
+        // 两层循环，时间复杂度 O(n^2)
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target)
+                    return {i, j};
+            }
+        }
+        return {};
+    }
+    ```
+
+=== "Java"
+
+    ```java title="two_sum.java"
+    /* 方法一：暴力枚举 */
+    int[] twoSumBruteForce(int[] nums, int target) {
+        int size = nums.length;
+        // 两层循环，时间复杂度 O(n^2)
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target)
+                    return new int[] { i, j };
+            }
+        }
+        return new int[0];
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="two_sum.cs"
+    /* 方法一：暴力枚举 */
+    int[] TwoSumBruteForce(int[] nums, int target) {
+        int size = nums.Length;
+        // 两层循环，时间复杂度 O(n^2)
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target)
+                    return new int[] { i, j };
+            }
+        }
+        return Array.Empty<int>();
+    }
+    ```
+
+=== "Go"
+
+    ```go title="two_sum.go"
+    /* 方法一：暴力枚举 */
+    func twoSumBruteForce(nums []int, target int) []int {
+        size := len(nums)
+        // 两层循环，时间复杂度 O(n^2)
+        for i := 0; i < size-1; i++ {
+            for j := i + 1; i < size; j++ {
+                if nums[i]+nums[j] == target {
+                    return []int{i, j}
+                }
+            }
+        }
+        return nil
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="two_sum.swift"
+    /* 方法一：暴力枚举 */
+    func twoSumBruteForce(nums: [Int], target: Int) -> [Int] {
+        // 两层循环，时间复杂度 O(n^2)
+        for i in nums.indices.dropLast() {
+            for j in nums.indices.dropFirst(i + 1) {
+                if nums[i] + nums[j] == target {
+                    return [i, j]
+                }
+            }
+        }
+        return [0]
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="two_sum.js"
+    /* 方法一：暴力枚举 */
+    function twoSumBruteForce(nums, target) {
+        const n = nums.length;
+        // 两层循环，时间复杂度 O(n^2)
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                if (nums[i] + nums[j] === target) {
+                    return [i, j];
+                }
+            }
+        }
+        return [];
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="two_sum.ts"
+    /* 方法一：暴力枚举 */
+    function twoSumBruteForce(nums: number[], target: number): number[] {
+        const n = nums.length;
+        // 两层循环，时间复杂度 O(n^2)
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                if (nums[i] + nums[j] === target) {
+                    return [i, j];
+                }
+            }
+        }
+        return [];
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="two_sum.dart"
+    /* 方法一： 暴力枚举 */
+    List<int> twoSumBruteForce(List<int> nums, int target) {
+      int size = nums.length;
+      // 两层循环，时间复杂度 O(n^2)
+      for (var i = 0; i < size - 1; i++) {
+        for (var j = i + 1; j < size; j++) {
+          if (nums[i] + nums[j] == target) return [i, j];
+        }
+      }
+      return [0];
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="two_sum.rs"
+    /* 方法一：暴力枚举 */
+    pub fn two_sum_brute_force(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {
+        let size = nums.len();
+        // 两层循环，时间复杂度 O(n^2)
+        for i in 0..size - 1 {
+            for j in i + 1..size {
+                if nums[i] + nums[j] == target {
+                    return Some(vec![i as i32, j as i32]);
+                }
+            }
+        }
+        None
+    }
+    ```
+
+=== "C"
+
+    ```c title="two_sum.c"
+    /* 方法一：暴力枚举 */
+    int *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {
+        for (int i = 0; i < numsSize; ++i) {
+            for (int j = i + 1; j < numsSize; ++j) {
+                if (nums[i] + nums[j] == target) {
+                    int *res = malloc(sizeof(int) * 2);
+                    res[0] = i, res[1] = j;
+                    *returnSize = 2;
+                    return res;
+                }
+            }
+        }
+        *returnSize = 0;
+        return NULL;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="two_sum.zig"
+    // 方法一：暴力枚举
+    fn twoSumBruteForce(nums: []i32, target: i32) ?[2]i32 {
+        var size: usize = nums.len;
+        var i: usize = 0;
+        // 两层循环，时间复杂度 O(n^2)
+        while (i < size - 1) : (i += 1) {
+            var j = i + 1;
+            while (j < size) : (j += 1) {
+                if (nums[i] + nums[j] == target) {
+                    return [_]i32{@intCast(i), @intCast(j)};
+                }
+            }
+        }
+        return null;
+    }
+    ```
+
+此方法的时间复杂度为 $O(n^2)$ ，空间复杂度为 $O(1)$ ，在大数据量下非常耗时。
+
+## 10.4.2 &nbsp; 哈希查找：以空间换时间
+
+考虑借助一个哈希表，键值对分别为数组元素和元素索引。循环遍历数组，每轮执行图 10-10 所示的步骤。
+
+1. 判断数字 `target - nums[i]` 是否在哈希表中，若是则直接返回这两个元素的索引。
+2. 将键值对 `nums[i]` 和索引 `i` 添加进哈希表。
+
+=== "<1>"
+    ![辅助哈希表求解两数之和](replace_linear_by_hashing.assets/two_sum_hashtable_step1.png)
+
+=== "<2>"
+    ![two_sum_hashtable_step2](replace_linear_by_hashing.assets/two_sum_hashtable_step2.png)
+
+=== "<3>"
+    ![two_sum_hashtable_step3](replace_linear_by_hashing.assets/two_sum_hashtable_step3.png)
+
+<p align="center"> 图 10-10 &nbsp; 辅助哈希表求解两数之和 </p>
+
+实现代码如下所示，仅需单层循环即可。
+
+=== "Python"
+
+    ```python title="two_sum.py"
+    def two_sum_hash_table(nums: list[int], target: int) -> list[int]:
+        """方法二：辅助哈希表"""
+        # 辅助哈希表，空间复杂度 O(n)
+        dic = {}
+        # 单层循环，时间复杂度 O(n)
+        for i in range(len(nums)):
+            if target - nums[i] in dic:
+                return [dic[target - nums[i]], i]
+            dic[nums[i]] = i
+        return []
+    ```
+
+=== "C++"
+
+    ```cpp title="two_sum.cpp"
+    /* 方法二：辅助哈希表 */
+    vector<int> twoSumHashTable(vector<int> &nums, int target) {
+        int size = nums.size();
+        // 辅助哈希表，空间复杂度 O(n)
+        unordered_map<int, int> dic;
+        // 单层循环，时间复杂度 O(n)
+        for (int i = 0; i < size; i++) {
+            if (dic.find(target - nums[i]) != dic.end()) {
+                return {dic[target - nums[i]], i};
+            }
+            dic.emplace(nums[i], i);
+        }
+        return {};
+    }
+    ```
+
+=== "Java"
+
+    ```java title="two_sum.java"
+    /* 方法二：辅助哈希表 */
+    int[] twoSumHashTable(int[] nums, int target) {
+        int size = nums.length;
+        // 辅助哈希表，空间复杂度 O(n)
+        Map<Integer, Integer> dic = new HashMap<>();
+        // 单层循环，时间复杂度 O(n)
+        for (int i = 0; i < size; i++) {
+            if (dic.containsKey(target - nums[i])) {
+                return new int[] { dic.get(target - nums[i]), i };
+            }
+            dic.put(nums[i], i);
+        }
+        return new int[0];
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="two_sum.cs"
+    /* 方法二：辅助哈希表 */
+    int[] TwoSumHashTable(int[] nums, int target) {
+        int size = nums.Length;
+        // 辅助哈希表，空间复杂度 O(n)
+        Dictionary<int, int> dic = new();
+        // 单层循环，时间复杂度 O(n)
+        for (int i = 0; i < size; i++) {
+            if (dic.ContainsKey(target - nums[i])) {
+                return new int[] { dic[target - nums[i]], i };
+            }
+            dic.Add(nums[i], i);
+        }
+        return Array.Empty<int>();
+    }
+    ```
+
+=== "Go"
+
+    ```go title="two_sum.go"
+    /* 方法二：辅助哈希表 */
+    func twoSumHashTable(nums []int, target int) []int {
+        // 辅助哈希表，空间复杂度 O(n)
+        hashTable := map[int]int{}
+        // 单层循环，时间复杂度 O(n)
+        for idx, val := range nums {
+            if preIdx, ok := hashTable[target-val]; ok {
+                return []int{preIdx, idx}
+            }
+            hashTable[val] = idx
+        }
+        return nil
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="two_sum.swift"
+    /* 方法二：辅助哈希表 */
+    func twoSumHashTable(nums: [Int], target: Int) -> [Int] {
+        // 辅助哈希表，空间复杂度 O(n)
+        var dic: [Int: Int] = [:]
+        // 单层循环，时间复杂度 O(n)
+        for i in nums.indices {
+            if let j = dic[target - nums[i]] {
+                return [j, i]
+            }
+            dic[nums[i]] = i
+        }
+        return [0]
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="two_sum.js"
+    /* 方法二：辅助哈希表 */
+    function twoSumHashTable(nums, target) {
+        // 辅助哈希表，空间复杂度 O(n)
+        let m = {};
+        // 单层循环，时间复杂度 O(n)
+        for (let i = 0; i < nums.length; i++) {
+            if (m[target - nums[i]] !== undefined) {
+                return [m[target - nums[i]], i];
+            } else {
+                m[nums[i]] = i;
+            }
+        }
+        return [];
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="two_sum.ts"
+    /* 方法二：辅助哈希表 */
+    function twoSumHashTable(nums: number[], target: number): number[] {
+        // 辅助哈希表，空间复杂度 O(n)
+        let m: Map<number, number> = new Map();
+        // 单层循环，时间复杂度 O(n)
+        for (let i = 0; i < nums.length; i++) {
+            let index = m.get(target - nums[i]);
+            if (index !== undefined) {
+                return [index, i];
+            } else {
+                m.set(nums[i], i);
+            }
+        }
+        return [];
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="two_sum.dart"
+    /* 方法二： 辅助哈希表 */
+    List<int> twoSumHashTable(List<int> nums, int target) {
+      int size = nums.length;
+      // 辅助哈希表，空间复杂度 O(n)
+      Map<int, int> dic = HashMap();
+      // 单层循环，时间复杂度 O(n)
+      for (var i = 0; i < size; i++) {
+        if (dic.containsKey(target - nums[i])) {
+          return [dic[target - nums[i]]!, i];
+        }
+        dic.putIfAbsent(nums[i], () => i);
+      }
+      return [0];
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="two_sum.rs"
+    /* 方法二：辅助哈希表 */
+    pub fn two_sum_hash_table(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {
+        // 辅助哈希表，空间复杂度 O(n)
+        let mut dic = HashMap::new();
+        // 单层循环，时间复杂度 O(n)
+        for (i, num) in nums.iter().enumerate() {
+            match dic.get(&(target - num)) {
+                Some(v) => return Some(vec![*v as i32, i as i32]),
+                None => dic.insert(num, i as i32)
+            };
+        }
+        None
+    }
+    ```
+
+=== "C"
+
+    ```c title="two_sum.c"
+    /* 哈希表 */
+    struct hashTable {
+        int key;
+        int val;
+        UT_hash_handle hh; // 基于 uthash.h 实现
+    };
+
+    typedef struct hashTable hashTable;
+
+    /* 哈希表查询 */
+    hashTable *find(hashTable *h, int key) {
+        hashTable *tmp;
+        HASH_FIND_INT(h, &key, tmp);
+        return tmp;
+    }
+
+    /* 哈希表元素插入 */
+    void insert(hashTable *h, int key, int val) {
+        hashTable *t = find(h, key);
+        if (t == NULL) {
+            hashTable *tmp = malloc(sizeof(hashTable));
+            tmp->key = key, tmp->val = val;
+            HASH_ADD_INT(h, key, tmp);
+        } else {
+            t->val = val;
+        }
+    }
+
+    /* 方法二：辅助哈希表 */
+    int *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {
+        hashTable *hashtable = NULL;
+        for (int i = 0; i < numsSize; i++) {
+            hashTable *t = find(hashtable, target - nums[i]);
+            if (t != NULL) {
+                int *res = malloc(sizeof(int) * 2);
+                res[0] = t->val, res[1] = i;
+                *returnSize = 2;
+                return res;
+            }
+            insert(hashtable, nums[i], i);
+        }
+        *returnSize = 0;
+        return NULL;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="two_sum.zig"
+    // 方法二：辅助哈希表
+    fn twoSumHashTable(nums: []i32, target: i32) !?[2]i32 {
+        var size: usize = nums.len;
+        // 辅助哈希表，空间复杂度 O(n)
+        var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
+        defer dic.deinit();
+        var i: usize = 0;
+        // 单层循环，时间复杂度 O(n)
+        while (i < size) : (i += 1) {
+            if (dic.contains(target - nums[i])) {
+                return [_]i32{dic.get(target - nums[i]).?, @intCast(i)};
+            }
+            try dic.put(nums[i], @intCast(i));
+        }
+        return null;
+    }
+    ```
+
+此方法通过哈希查找将时间复杂度从 $O(n^2)$ 降低至 $O(n)$ ，大幅提升运行效率。
+
+由于需要维护一个额外的哈希表，因此空间复杂度为 $O(n)$ 。**尽管如此，该方法的整体时空效率更为均衡，因此它是本题的最优解法**。

docs/chapter_searching/searching_algorithm_revisited.md

@@ -0,0 +1,94 @@
+---
+comments: true
+---
+
+# 10.5   重识搜索算法
+
+「搜索算法 searching algorithm」用于在数据结构（例如数组、链表、树或图）中搜索一个或一组满足特定条件的元素。
+
+搜索算法可根据实现思路分为以下两类。
+
+- **通过遍历数据结构来定位目标元素**，例如数组、链表、树和图的遍历等。
+- **利用数据组织结构或数据包含的先验信息，实现高效元素查找**，例如二分查找、哈希查找和二叉搜索树查找等。
+
+不难发现，这些知识点都已在前面的章节中介绍过，因此搜索算法对于我们来说并不陌生。在本节中，我们将从更加系统的视角切入，重新审视搜索算法。
+
+## 10.5.1   暴力搜索
+
+暴力搜索通过遍历数据结构的每个元素来定位目标元素。
+
+- “线性搜索”适用于数组和链表等线性数据结构。它从数据结构的一端开始，逐个访问元素，直到找到目标元素或到达另一端仍没有找到目标元素为止。
+- “广度优先搜索”和“深度优先搜索”是图和树的两种遍历策略。广度优先搜索从初始节点开始逐层搜索，由近及远地访问各个节点。深度优先搜索是从初始节点开始，沿着一条路径走到头为止，再回溯并尝试其他路径，直到遍历完整个数据结构。
+
+暴力搜索的优点是简单且通用性好，**无须对数据做预处理和借助额外的数据结构**。
+
+然而，**此类算法的时间复杂度为 $O(n)$** ，其中 $n$ 为元素数量，因此在数据量较大的情况下性能较差。
+
+## 10.5.2   自适应搜索
+
+自适应搜索利用数据的特有属性（例如有序性）来优化搜索过程，从而更高效地定位目标元素。
+
+- “二分查找”利用数据的有序性实现高效查找，仅适用于数组。
+- “哈希查找”利用哈希表将搜索数据和目标数据建立为键值对映射，从而实现查询操作。
+- “树查找”在特定的树结构（例如二叉搜索树）中，基于比较节点值来快速排除节点，从而定位目标元素。
+
+此类算法的优点是效率高，**时间复杂度可达到 $O(\log n)$ 甚至 $O(1)$** 。
+
+然而，**使用这些算法往往需要对数据进行预处理**。例如，二分查找需要预先对数组进行排序，哈希查找和树查找都需要借助额外的数据结构，维护这些数据结构也需要额外的时间和空间开支。
+
+!!! note
+
+    自适应搜索算法常被称为查找算法，**主要关注在特定数据结构中快速检索目标元素**。
+
+## 10.5.3   搜索方法选取
+
+给定大小为 $n$ 的一组数据，我们可以使用线性搜索、二分查找、树查找、哈希查找等多种方法在该数据中搜索目标元素。各个方法的工作原理如图 10-11 所示。
+
+![多种搜索策略](searching_algorithm_revisited.assets/searching_algorithms.png)
+
+<p align="center"> 图 10-11 &nbsp; 多种搜索策略 </p>
+
+上述几种方法的操作效率与特性如表 10-1 所示。
+
+<p align="center"> 表 10-1 &nbsp; 查找算法效率对比 </p>
+
+<div class="center-table" markdown>
+
+|              | 线性搜索 | 二分查找           | 树查找             | 哈希查找        |
+| ------------ | -------- | ------------------ | ------------------ | --------------- |
+| 查找元素     | $O(n)$   | $O(\log n)$        | $O(\log n)$        | $O(1)$          |
+| 插入元素     | $O(1)$   | $O(n)$             | $O(\log n)$        | $O(1)$          |
+| 删除元素     | $O(n)$   | $O(n)$             | $O(\log n)$        | $O(1)$          |
+| 额外空间     | $O(1)$   | $O(1)$             | $O(n)$             | $O(n)$          |
+| 数据预处理   | /        | 排序 $O(n \log n)$ | 建树 $O(n \log n)$ | 建哈希表 $O(n)$ |
+| 数据是否有序 | 无序     | 有序               | 有序               | 无序            |
+
+</div>
+
+搜索算法的选择还取决于数据体量、搜索性能要求、数据查询与更新频率等。
+
+**线性搜索**
+
+- 通用性较好，无须任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
+- 适用于体量较小的数据，此情况下时间复杂度对效率影响较小。
+- 适用于数据更新频率较高的场景，因为该方法不需要对数据进行任何额外维护。
+
+**二分查找**
+
+- 适用于大数据量的情况，效率表现稳定，最差时间复杂度为 $O(\log n)$ 。
+- 数据量不能过大，因为存储数组需要连续的内存空间。
+- 不适用于高频增删数据的场景，因为维护有序数组的开销较大。
+
+**哈希查找**
+
+- 适合对查询性能要求很高的场景，平均时间复杂度为 $O(1)$ 。
+- 不适合需要有序数据或范围查找的场景，因为哈希表无法维护数据的有序性。
+- 对哈希函数和哈希冲突处理策略的依赖性较高，具有较大的性能劣化风险。
+- 不适合数据量过大的情况，因为哈希表需要额外空间来最大程度地减少冲突，从而提供良好的查询性能。
+
+**树查找**
+
+- 适用于海量数据，因为树节点在内存中是分散存储的。
+- 适合需要维护有序数据或范围查找的场景。
+- 在持续增删节点的过程中，二叉搜索树可能产生倾斜，时间复杂度劣化至 $O(n)$ 。
+- 若使用 AVL 树或红黑树，则各项操作可在 $O(\log n)$ 效率下稳定运行，但维护树平衡的操作会增加额外开销。

docs/chapter_searching/summary.md

@@ -0,0 +1,12 @@
+---
+comments: true
+---
+
+# 10.6   小结
+
+- 二分查找依赖于数据的有序性，通过循环逐步缩减一半搜索区间来实现查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。
+- 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无须对数据预处理，但时间复杂度 $O(n)$ 较高。
+- 哈希查找、树查找和二分查找属于高效搜索方法，可在特定数据结构中快速定位目标元素。此类算法效率高，时间复杂度可达 $O(\log n)$ 甚至 $O(1)$ ，但通常需要借助额外数据结构。
+- 实际中，我们需要对数据体量、搜索性能要求、数据查询和更新频率等因素进行具体分析，从而选择合适的搜索方法。
+- 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无须范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。
+- 用哈希查找替换线性查找是一种常用的优化运行时间的策略，可将时间复杂度从 $O(n)$ 降低至 $O(1)$ 。

docs/chapter_sorting/bubble_sort.md

@@ -0,0 +1,562 @@
+---
+comments: true
+---
+
+# 11.3   冒泡排序
+
+「冒泡排序 bubble sort」通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样，因此得名冒泡排序。
+
+如图 11-4 所示，冒泡过程可以利用元素交换操作来模拟：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。
+
+=== "<1>"
+    ![利用元素交换操作模拟冒泡](bubble_sort.assets/bubble_operation_step1.png)
+
+=== "<2>"
+    ![bubble_operation_step2](bubble_sort.assets/bubble_operation_step2.png)
+
+=== "<3>"
+    ![bubble_operation_step3](bubble_sort.assets/bubble_operation_step3.png)
+
+=== "<4>"
+    ![bubble_operation_step4](bubble_sort.assets/bubble_operation_step4.png)
+
+=== "<5>"
+    ![bubble_operation_step5](bubble_sort.assets/bubble_operation_step5.png)
+
+=== "<6>"
+    ![bubble_operation_step6](bubble_sort.assets/bubble_operation_step6.png)
+
+=== "<7>"
+    ![bubble_operation_step7](bubble_sort.assets/bubble_operation_step7.png)
+
+<p align="center"> 图 11-4 &nbsp; 利用元素交换操作模拟冒泡 </p>
+
+## 11.3.1 &nbsp; 算法流程
+
+设数组的长度为 $n$ ，冒泡排序的步骤如图 11-5 所示。
+
+1. 首先，对 $n$ 个元素执行“冒泡”，**将数组的最大元素交换至正确位置**，
+2. 接下来，对剩余 $n - 1$ 个元素执行“冒泡”，**将第二大元素交换至正确位置**。
+3. 以此类推，经过 $n - 1$ 轮“冒泡”后，**前 $n - 1$ 大的元素都被交换至正确位置**。
+4. 仅剩的一个元素必定是最小元素，无须排序，因此数组排序完成。
+
+![冒泡排序流程](bubble_sort.assets/bubble_sort_overview.png)
+
+<p align="center"> 图 11-5 &nbsp; 冒泡排序流程 </p>
+
+=== "Python"
+
+    ```python title="bubble_sort.py"
+    def bubble_sort(nums: list[int]):
+        """冒泡排序"""
+        n = len(nums)
+        # 外循环：未排序区间为 [0, i]
+        for i in range(n - 1, 0, -1):
+            # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for j in range(i):
+                if nums[j] > nums[j + 1]:
+                    # 交换 nums[j] 与 nums[j + 1]
+                    nums[j], nums[j + 1] = nums[j + 1], nums[j]
+    ```
+
+=== "C++"
+
+    ```cpp title="bubble_sort.cpp"
+    /* 冒泡排序 */
+    void bubbleSort(vector<int> &nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.size() - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    // 这里使用了 std::swap() 函数
+                    swap(nums[j], nums[j + 1]);
+                }
+            }
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="bubble_sort.java"
+    /* 冒泡排序 */
+    void bubbleSort(int[] nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.length - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="bubble_sort.cs"
+    /* 冒泡排序 */
+    void BubbleSort(int[] nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.Length - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);
+                }
+            }
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="bubble_sort.go"
+    /* 冒泡排序 */
+    func bubbleSort(nums []int) {
+        // 外循环：未排序区间为 [0, i]
+        for i := len(nums) - 1; i > 0; i-- {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for j := 0; j < i; j++ {
+                if nums[j] > nums[j+1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    nums[j], nums[j+1] = nums[j+1], nums[j]
+                }
+            }
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="bubble_sort.swift"
+    /* 冒泡排序 */
+    func bubbleSort(nums: inout [Int]) {
+        // 外循环：未排序区间为 [0, i]
+        for i in stride(from: nums.count - 1, to: 0, by: -1) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for j in stride(from: 0, to: i, by: 1) {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j]
+                    nums[j] = nums[j + 1]
+                    nums[j + 1] = tmp
+                }
+            }
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="bubble_sort.js"
+    /* 冒泡排序 */
+    function bubbleSort(nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="bubble_sort.ts"
+    /* 冒泡排序 */
+    function bubbleSort(nums: number[]): void {
+        // 外循环：未排序区间为 [0, i]
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="bubble_sort.dart"
+    /* 冒泡排序 */
+    void bubbleSort(List<int> nums) {
+      // 外循环：未排序区间为 [0, i]
+      for (int i = nums.length - 1; i > 0; i--) {
+        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+        for (int j = 0; j < i; j++) {
+          if (nums[j] > nums[j + 1]) {
+            // 交换 nums[j] 与 nums[j + 1]
+            int tmp = nums[j];
+            nums[j] = nums[j + 1];
+            nums[j + 1] = tmp;
+          }
+        }
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="bubble_sort.rs"
+    /* 冒泡排序 */
+    fn bubble_sort(nums: &mut [i32]) {
+        // 外循环：未排序区间为 [0, i]
+        for i in (1..nums.len()).rev() {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for j in 0..i {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="bubble_sort.c"
+    /* 冒泡排序 */
+    void bubbleSort(int nums[], int size) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = 0; i < size - 1; i++) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < size - 1 - i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    int temp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = temp;
+                }
+            }
+        }
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="bubble_sort.zig"
+    // 冒泡排序
+    fn bubbleSort(nums: []i32) void {
+        // 外循环：未排序区间为 [0, i]
+        var i: usize = nums.len - 1;
+        while (i > 0) : (i -= 1) {
+            var j: usize = 0;
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            while (j < i) : (j += 1) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    var tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
+    ```
+
+## 11.3.2 &nbsp; 效率优化
+
+我们发现，如果某轮“冒泡”中没有执行任何交换操作，说明数组已经完成排序，可直接返回结果。因此，可以增加一个标志位 `flag` 来监测这种情况，一旦出现就立即返回。
+
+经过优化，冒泡排序的最差和平均时间复杂度仍为 $O(n^2)$ ；但当输入数组完全有序时，可达到最佳时间复杂度 $O(n)$ 。
+
+=== "Python"
+
+    ```python title="bubble_sort.py"
+    def bubble_sort_with_flag(nums: list[int]):
+        """冒泡排序（标志优化）"""
+        n = len(nums)
+        # 外循环：未排序区间为 [0, i]
+        for i in range(n - 1, 0, -1):
+            flag = False  # 初始化标志位
+            # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for j in range(i):
+                if nums[j] > nums[j + 1]:
+                    # 交换 nums[j] 与 nums[j + 1]
+                    nums[j], nums[j + 1] = nums[j + 1], nums[j]
+                    flag = True  # 记录交换元素
+            if not flag:
+                break  # 此轮冒泡未交换任何元素，直接跳出
+    ```
+
+=== "C++"
+
+    ```cpp title="bubble_sort.cpp"
+    /* 冒泡排序（标志优化）*/
+    void bubbleSortWithFlag(vector<int> &nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.size() - 1; i > 0; i--) {
+            bool flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    // 这里使用了 std::swap() 函数
+                    swap(nums[j], nums[j + 1]);
+                    flag = true; // 记录交换元素
+                }
+            }
+            if (!flag)
+                break; // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="bubble_sort.java"
+    /* 冒泡排序（标志优化） */
+    void bubbleSortWithFlag(int[] nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.length - 1; i > 0; i--) {
+            boolean flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true; // 记录交换元素
+                }
+            }
+            if (!flag)
+                break; // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="bubble_sort.cs"
+    /* 冒泡排序（标志优化）*/
+    void BubbleSortWithFlag(int[] nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.Length - 1; i > 0; i--) {
+            bool flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);
+                    flag = true;  // 记录交换元素
+                }
+            }
+            if (!flag) break;     // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="bubble_sort.go"
+    /* 冒泡排序（标志优化）*/
+    func bubbleSortWithFlag(nums []int) {
+        // 外循环：未排序区间为 [0, i]
+        for i := len(nums) - 1; i > 0; i-- {
+            flag := false // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for j := 0; j < i; j++ {
+                if nums[j] > nums[j+1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    nums[j], nums[j+1] = nums[j+1], nums[j]
+                    flag = true // 记录交换元素
+                }
+            }
+            if flag == false { // 此轮冒泡未交换任何元素，直接跳出
+                break
+            }
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="bubble_sort.swift"
+    /* 冒泡排序（标志优化）*/
+    func bubbleSortWithFlag(nums: inout [Int]) {
+        // 外循环：未排序区间为 [0, i]
+        for i in stride(from: nums.count - 1, to: 0, by: -1) {
+            var flag = false // 初始化标志位
+            for j in stride(from: 0, to: i, by: 1) {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j]
+                    nums[j] = nums[j + 1]
+                    nums[j + 1] = tmp
+                    flag = true // 记录交换元素
+                }
+            }
+            if !flag { // 此轮冒泡未交换任何元素，直接跳出
+                break
+            }
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="bubble_sort.js"
+    /* 冒泡排序（标志优化）*/
+    function bubbleSortWithFlag(nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (let i = nums.length - 1; i > 0; i--) {
+            let flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true; // 记录交换元素
+                }
+            }
+            if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="bubble_sort.ts"
+    /* 冒泡排序（标志优化）*/
+    function bubbleSortWithFlag(nums: number[]): void {
+        // 外循环：未排序区间为 [0, i]
+        for (let i = nums.length - 1; i > 0; i--) {
+            let flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true; // 记录交换元素
+                }
+            }
+            if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="bubble_sort.dart"
+    /* 冒泡排序（标志优化）*/
+    void bubbleSortWithFlag(List<int> nums) {
+      // 外循环：未排序区间为 [0, i]
+      for (int i = nums.length - 1; i > 0; i--) {
+        bool flag = false; // 初始化标志位
+        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+        for (int j = 0; j < i; j++) {
+          if (nums[j] > nums[j + 1]) {
+            // 交换 nums[j] 与 nums[j + 1]
+            int tmp = nums[j];
+            nums[j] = nums[j + 1];
+            nums[j + 1] = tmp;
+            flag = true; // 记录交换元素
+          }
+        }
+        if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="bubble_sort.rs"
+    /* 冒泡排序（标志优化） */
+    fn bubble_sort_with_flag(nums: &mut [i32]) {
+        // 外循环：未排序区间为 [0, i]
+        for i in (1..nums.len()).rev() {
+            let mut flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for j in 0..i {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true;  // 记录交换元素
+                }
+            }
+            if !flag {break};  // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="bubble_sort.c"
+    /* 冒泡排序（标志优化）*/
+    void bubbleSortWithFlag(int nums[], int size) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = 0; i < size - 1; i++) {
+            bool flag = false;
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < size - 1 - i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    int temp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = temp;
+                    flag = true;
+                }
+            }
+            if (!flag)
+                break;
+        }
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="bubble_sort.zig"
+    // 冒泡排序（标志优化）
+    fn bubbleSortWithFlag(nums: []i32) void {
+        // 外循环：未排序区间为 [0, i]
+        var i: usize = nums.len - 1;
+        while (i > 0) : (i -= 1) {
+            var flag = false;   // 初始化标志位
+            var j: usize = 0;
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            while (j < i) : (j += 1) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    var tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true;
+                }
+            }
+            if (!flag) break;   // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
+    ```
+
+## 11.3.3 &nbsp; 算法特性
+
+- **时间复杂度为 $O(n^2)$、自适应排序**：各轮“冒泡”遍历的数组长度依次为 $n - 1$、$n - 2$、$\dots$、$2$、$1$ ，总和为 $(n - 1) n / 2$ 。在引入 `flag` 优化后，最佳时间复杂度可达到 $O(n)$ 。
+- **空间复杂度为 $O(1)$、原地排序**：指针 $i$ 和 $j$ 使用常数大小的额外空间。
+- **稳定排序**：由于在“冒泡”中遇到相等元素不交换。

docs/chapter_sorting/bucket_sort.md

@@ -0,0 +1,422 @@
+---
+comments: true
+---
+
+# 11.8   桶排序
+
+前述的几种排序算法都属于“基于比较的排序算法”，它们通过比较元素间的大小来实现排序。此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将探讨几种“非比较排序算法”，它们的时间复杂度可以达到线性阶。
+
+「桶排序 bucket sort」是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
+
+## 11.8.1   算法流程
+
+考虑一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数。桶排序的流程如图 11-13 所示。
+
+1. 初始化 $k$ 个桶，将 $n$ 个元素分配到 $k$ 个桶中。
+2. 对每个桶分别执行排序（本文采用编程语言的内置排序函数）。
+3. 按照桶的从小到大的顺序，合并结果。
+
+![桶排序算法流程](bucket_sort.assets/bucket_sort_overview.png)
+
+<p align="center"> 图 11-13 &nbsp; 桶排序算法流程 </p>
+
+=== "Python"
+
+    ```python title="bucket_sort.py"
+    def bucket_sort(nums: list[float]):
+        """桶排序"""
+        # 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        k = len(nums) // 2
+        buckets = [[] for _ in range(k)]
+        # 1. 将数组元素分配到各个桶中
+        for num in nums:
+            # 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            i = int(num * k)
+            # 将 num 添加进桶 i
+            buckets[i].append(num)
+        # 2. 对各个桶执行排序
+        for bucket in buckets:
+            # 使用内置排序函数，也可以替换成其他排序算法
+            bucket.sort()
+        # 3. 遍历桶合并结果
+        i = 0
+        for bucket in buckets:
+            for num in bucket:
+                nums[i] = num
+                i += 1
+    ```
+
+=== "C++"
+
+    ```cpp title="bucket_sort.cpp"
+    /* 桶排序 */
+    void bucketSort(vector<float> &nums) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = nums.size() / 2;
+        vector<vector<float>> buckets(k);
+        // 1. 将数组元素分配到各个桶中
+        for (float num : nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int i = num * k;
+            // 将 num 添加进桶 bucket_idx
+            buckets[i].push_back(num);
+        }
+        // 2. 对各个桶执行排序
+        for (vector<float> &bucket : buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            sort(bucket.begin(), bucket.end());
+        }
+        // 3. 遍历桶合并结果
+        int i = 0;
+        for (vector<float> &bucket : buckets) {
+            for (float num : bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="bucket_sort.java"
+    /* 桶排序 */
+    void bucketSort(float[] nums) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = nums.length / 2;
+        List<List<Float>> buckets = new ArrayList<>();
+        for (int i = 0; i < k; i++) {
+            buckets.add(new ArrayList<>());
+        }
+        // 1. 将数组元素分配到各个桶中
+        for (float num : nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int i = (int) (num * k);
+            // 将 num 添加进桶 i
+            buckets.get(i).add(num);
+        }
+        // 2. 对各个桶执行排序
+        for (List<Float> bucket : buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            Collections.sort(bucket);
+        }
+        // 3. 遍历桶合并结果
+        int i = 0;
+        for (List<Float> bucket : buckets) {
+            for (float num : bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="bucket_sort.cs"
+    /* 桶排序 */
+    void BucketSort(float[] nums) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = nums.Length / 2;
+        List<List<float>> buckets = new();
+        for (int i = 0; i < k; i++) {
+            buckets.Add(new List<float>());
+        }
+        // 1. 将数组元素分配到各个桶中
+        foreach (float num in nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int i = (int)(num * k);
+            // 将 num 添加进桶 i
+            buckets[i].Add(num);
+        }
+        // 2. 对各个桶执行排序
+        foreach (List<float> bucket in buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            bucket.Sort();
+        }
+        // 3. 遍历桶合并结果
+        int j = 0;
+        foreach (List<float> bucket in buckets) {
+            foreach (float num in bucket) {
+                nums[j++] = num;
+            }
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="bucket_sort.go"
+    /* 桶排序 */
+    func bucketSort(nums []float64) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        k := len(nums) / 2
+        buckets := make([][]float64, k)
+        for i := 0; i < k; i++ {
+            buckets[i] = make([]float64, 0)
+        }
+        // 1. 将数组元素分配到各个桶中
+        for _, num := range nums {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            i := int(num * float64(k))
+            // 将 num 添加进桶 i
+            buckets[i] = append(buckets[i], num)
+        }
+        // 2. 对各个桶执行排序
+        for i := 0; i < k; i++ {
+            // 使用内置切片排序函数，也可以替换成其他排序算法
+            sort.Float64s(buckets[i])
+        }
+        // 3. 遍历桶合并结果
+        i := 0
+        for _, bucket := range buckets {
+            for _, num := range bucket {
+                nums[i] = num
+                i++
+            }
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="bucket_sort.swift"
+    /* 桶排序 */
+    func bucketSort(nums: inout [Double]) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        let k = nums.count / 2
+        var buckets = (0 ..< k).map { _ in [Double]() }
+        // 1. 将数组元素分配到各个桶中
+        for num in nums {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            let i = Int(num * Double(k))
+            // 将 num 添加进桶 i
+            buckets[i].append(num)
+        }
+        // 2. 对各个桶执行排序
+        for i in buckets.indices {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            buckets[i].sort()
+        }
+        // 3. 遍历桶合并结果
+        var i = nums.startIndex
+        for bucket in buckets {
+            for num in bucket {
+                nums[i] = num
+                nums.formIndex(after: &i)
+            }
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="bucket_sort.js"
+    /* 桶排序 */
+    function bucketSort(nums) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        const k = nums.length / 2;
+        const buckets = [];
+        for (let i = 0; i < k; i++) {
+            buckets.push([]);
+        }
+        // 1. 将数组元素分配到各个桶中
+        for (const num of nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            const i = Math.floor(num * k);
+            // 将 num 添加进桶 i
+            buckets[i].push(num);
+        }
+        // 2. 对各个桶执行排序
+        for (const bucket of buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            bucket.sort((a, b) => a - b);
+        }
+        // 3. 遍历桶合并结果
+        let i = 0;
+        for (const bucket of buckets) {
+            for (const num of bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="bucket_sort.ts"
+    /* 桶排序 */
+    function bucketSort(nums: number[]): void {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        const k = nums.length / 2;
+        const buckets: number[][] = [];
+        for (let i = 0; i < k; i++) {
+            buckets.push([]);
+        }
+        // 1. 将数组元素分配到各个桶中
+        for (const num of nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            const i = Math.floor(num * k);
+            // 将 num 添加进桶 i
+            buckets[i].push(num);
+        }
+        // 2. 对各个桶执行排序
+        for (const bucket of buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            bucket.sort((a, b) => a - b);
+        }
+        // 3. 遍历桶合并结果
+        let i = 0;
+        for (const bucket of buckets) {
+            for (const num of bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="bucket_sort.dart"
+    /* 桶排序 */
+    void bucketSort(List<double> nums) {
+      // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+      int k = nums.length ~/ 2;
+      List<List<double>> buckets = List.generate(k, (index) => []);
+
+      // 1. 将数组元素分配到各个桶中
+      for (double num in nums) {
+        // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+        int i = (num * k).toInt();
+        // 将 num 添加进桶 bucket_idx
+        buckets[i].add(num);
+      }
+      // 2. 对各个桶执行排序
+      for (List<double> bucket in buckets) {
+        bucket.sort();
+      }
+      // 3. 遍历桶合并结果
+      int i = 0;
+      for (List<double> bucket in buckets) {
+        for (double num in bucket) {
+          nums[i++] = num;
+        }
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="bucket_sort.rs"
+    /* 桶排序 */
+    fn bucket_sort(nums: &mut [f64]) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        let k = nums.len() / 2;
+        let mut buckets = vec![vec![]; k];
+        // 1. 将数组元素分配到各个桶中
+        for &mut num in &mut *nums {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            let i = (num * k as f64) as usize;
+            // 将 num 添加进桶 i
+            buckets[i].push(num);
+        }
+        // 2. 对各个桶执行排序
+        for bucket in &mut buckets {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());
+        }
+        // 3. 遍历桶合并结果
+        let mut i = 0;
+        for bucket in &mut buckets {
+            for &mut num in bucket {
+                nums[i] = num;
+                i += 1;
+            }
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="bucket_sort.c"
+    /* 桶排序 */
+    void bucketSort(float nums[], int size) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = size / 2;
+        float **buckets = calloc(k, sizeof(float *));
+        for (int i = 0; i < k; i++) {
+            // 每个桶最多可以分配 k 个元素
+            buckets[i] = calloc(ARRAY_SIZE, sizeof(float));
+        }
+
+        // 1. 将数组元素分配到各个桶中
+        for (int i = 0; i < size; i++) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int bucket_idx = nums[i] * k;
+            int j = 0;
+            // 如果桶中有数据且数据小于当前值 nums[i], 要将其放到当前桶的后面，相当于 cpp 中的 push_back
+            while (buckets[bucket_idx][j] > 0 && buckets[bucket_idx][j] < nums[i]) {
+                j++;
+            }
+            float temp = nums[i];
+            while (j < ARRAY_SIZE && buckets[bucket_idx][j] > 0) {
+                swap(&temp, &buckets[bucket_idx][j]);
+                j++;
+            }
+            buckets[bucket_idx][j] = temp;
+        }
+
+        // 2. 对各个桶执行排序
+        for (int i = 0; i < k; i++) {
+            qsort(buckets[i], ARRAY_SIZE, sizeof(float), compare_float);
+        }
+
+        // 3. 遍历桶合并结果
+        for (int i = 0, j = 0; j < k; j++) {
+            for (int l = 0; l < ARRAY_SIZE; l++) {
+                if (buckets[j][l] > 0) {
+                    nums[i++] = buckets[j][l];
+                }
+            }
+        }
+
+        // 释放上述分配的内存
+        for (int i = 0; i < k; i++) {
+            free(buckets[i]);
+        }
+        free(buckets);
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="bucket_sort.zig"
+    [class]{}-[func]{bucketSort}
+    ```
+
+## 11.8.2 &nbsp; 算法特性
+
+桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。
+
+- **时间复杂度 $O(n + k)$** ：假设元素在各个桶内平均分布，那么每个桶内的元素数量为 $\frac{n}{k}$ 。假设排序单个桶使用 $O(\frac{n}{k} \log\frac{n}{k})$ 时间，则排序所有桶使用 $O(n \log\frac{n}{k})$ 时间。**当桶数量 $k$ 比较大时，时间复杂度则趋向于 $O(n)$** 。合并结果时需要遍历所有桶和元素，花费 $O(n + k)$ 时间。
+- **自适应排序**：在最坏情况下，所有数据被分配到一个桶中，且排序该桶使用 $O(n^2)$ 时间。
+- **空间复杂度 $O(n + k)$、非原地排序**：需要借助 $k$ 个桶和总共 $n$ 个元素的额外空间。
+- 桶排序是否稳定取决于排序桶内元素的算法是否稳定。
+
+## 11.8.3 &nbsp; 如何实现平均分配
+
+桶排序的时间复杂度理论上可以达到 $O(n)$ ，**关键在于将元素均匀分配到各个桶中**，因为实际数据往往不是均匀分布的。例如，我们想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。
+
+为实现平均分配，我们可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。**分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等**。
+
+如图 11-14 所示，这种方法本质上是创建一个递归树，目标是让叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。
+
+![递归划分桶](bucket_sort.assets/scatter_in_buckets_recursively.png)
+
+<p align="center"> 图 11-14 &nbsp; 递归划分桶 </p>
+
+如果我们提前知道商品价格的概率分布，**则可以根据数据概率分布设置每个桶的价格分界线**。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。
+
+如图 11-15 所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。
+
+![根据概率分布划分桶](bucket_sort.assets/scatter_in_buckets_distribution.png)
+
+<p align="center"> 图 11-15 &nbsp; 根据概率分布划分桶 </p>

docs/chapter_sorting/counting_sort.md

@@ -0,0 +1,787 @@
+---
+comments: true
+---
+
+# 11.9   计数排序
+
+「计数排序 counting sort」通过统计元素数量来实现排序，通常应用于整数数组。
+
+## 11.9.1   简单实现
+
+先来看一个简单的例子。给定一个长度为 $n$ 的数组 `nums` ，其中的元素都是“非负整数”，计数排序的整体流程如图 11-16 所示。
+
+1. 遍历数组，找出数组中的最大数字，记为 $m$ ，然后创建一个长度为 $m + 1$ 的辅助数组 `counter` 。
+2. **借助 `counter` 统计 `nums` 中各数字的出现次数**，其中 `counter[num]` 对应数字 `num` 的出现次数。统计方法很简单，只需遍历 `nums`（设当前数字为 `num`），每轮将 `counter[num]` 增加 $1$ 即可。
+3. **由于 `counter` 的各个索引天然有序，因此相当于所有数字已经被排序好了**。接下来，我们遍历 `counter` ，根据各数字的出现次数，将它们按从小到大的顺序填入 `nums` 即可。
+
+![计数排序流程](counting_sort.assets/counting_sort_overview.png)
+
+<p align="center"> 图 11-16 &nbsp; 计数排序流程 </p>
+
+=== "Python"
+
+    ```python title="counting_sort.py"
+    def counting_sort_naive(nums: list[int]):
+        """计数排序"""
+        # 简单实现，无法用于排序对象
+        # 1. 统计数组最大元素 m
+        m = 0
+        for num in nums:
+            m = max(m, num)
+        # 2. 统计各数字的出现次数
+        # counter[num] 代表 num 的出现次数
+        counter = [0] * (m + 1)
+        for num in nums:
+            counter[num] += 1
+        # 3. 遍历 counter ，将各元素填入原数组 nums
+        i = 0
+        for num in range(m + 1):
+            for _ in range(counter[num]):
+                nums[i] = num
+                i += 1
+    ```
+
+=== "C++"
+
+    ```cpp title="counting_sort.cpp"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(vector<int> &nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int num : nums) {
+            m = max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        vector<int> counter(m + 1, 0);
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="counting_sort.java"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(int[] nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int num : nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int[] counter = new int[m + 1];
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="counting_sort.cs"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void CountingSortNaive(int[] nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        foreach (int num in nums) {
+            m = Math.Max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int[] counter = new int[m + 1];
+        foreach (int num in nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="counting_sort.go"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    func countingSortNaive(nums []int) {
+        // 1. 统计数组最大元素 m
+        m := 0
+        for _, num := range nums {
+            if num > m {
+                m = num
+            }
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        counter := make([]int, m+1)
+        for _, num := range nums {
+            counter[num]++
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        for i, num := 0, 0; num < m+1; num++ {
+            for j := 0; j < counter[num]; j++ {
+                nums[i] = num
+                i++
+            }
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="counting_sort.swift"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    func countingSortNaive(nums: inout [Int]) {
+        // 1. 统计数组最大元素 m
+        let m = nums.max()!
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        var counter = Array(repeating: 0, count: m + 1)
+        for num in nums {
+            counter[num] += 1
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        var i = 0
+        for num in stride(from: 0, to: m + 1, by: 1) {
+            for _ in stride(from: 0, to: counter[num], by: 1) {
+                nums[i] = num
+                i += 1
+            }
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="counting_sort.js"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    function countingSortNaive(nums) {
+        // 1. 统计数组最大元素 m
+        let m = 0;
+        for (const num of nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        const counter = new Array(m + 1).fill(0);
+        for (const num of nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        let i = 0;
+        for (let num = 0; num < m + 1; num++) {
+            for (let j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="counting_sort.ts"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    function countingSortNaive(nums: number[]): void {
+        // 1. 统计数组最大元素 m
+        let m = 0;
+        for (const num of nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        const counter: number[] = new Array<number>(m + 1).fill(0);
+        for (const num of nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        let i = 0;
+        for (let num = 0; num < m + 1; num++) {
+            for (let j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="counting_sort.dart"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(List<int> nums) {
+      // 1. 统计数组最大元素 m
+      int m = 0;
+      for (int num in nums) {
+        m = max(m, num);
+      }
+      // 2. 统计各数字的出现次数
+      // counter[num] 代表 num 的出现次数
+      List<int> counter = List.filled(m + 1, 0);
+      for (int num in nums) {
+        counter[num]++;
+      }
+      // 3. 遍历 counter ，将各元素填入原数组 nums
+      int i = 0;
+      for (int num = 0; num < m + 1; num++) {
+        for (int j = 0; j < counter[num]; j++, i++) {
+          nums[i] = num;
+        }
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="counting_sort.rs"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    fn counting_sort_naive(nums: &mut [i32]) {
+        // 1. 统计数组最大元素 m
+        let m = *nums.into_iter().max().unwrap();
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        let mut counter = vec![0; m as usize + 1];
+        for &num in &*nums {
+            counter[num as usize] += 1;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        let mut i = 0;
+        for num in 0..m + 1 {
+            for _ in 0..counter[num as usize] {
+                nums[i] = num;
+                i += 1;
+            }
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="counting_sort.c"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(int nums[], int size) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int i = 0; i < size; i++) {
+            if (nums[i] > m) {
+                m = nums[i];
+            }
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int *counter = malloc(sizeof(int) * m);
+        for (int i = 0; i < size; i++) {
+            counter[nums[i]]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="counting_sort.zig"
+    [class]{}-[func]{countingSortNaive}
+    ```
+
+!!! note "计数排序与桶排序的联系"
+
+    从桶排序的角度看，我们可以将计数排序中的计数数组 `counter` 的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
+
+## 11.9.2 &nbsp; 完整实现
+
+细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。假设输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
+
+那么如何才能得到原数据的排序结果呢？我们首先计算 `counter` 的“前缀和”。顾名思义，索引 `i` 处的前缀和 `prefix[i]` 等于数组前 `i` 个元素之和：
+
+$$
+\text{prefix}[i] = \sum_{j=0}^i \text{counter[j]}
+$$
+
+**前缀和具有明确的意义，`prefix[num] - 1` 代表元素 `num` 在结果数组 `res` 中最后一次出现的索引**。这个信息非常关键，因为它告诉我们各个元素应该出现在结果数组的哪个位置。接下来，我们倒序遍历原数组 `nums` 的每个元素 `num` ，在每轮迭代中执行以下两步。
+
+1. 将 `num` 填入数组 `res` 的索引 `prefix[num] - 1` 处。
+2. 令前缀和 `prefix[num]` 减小 $1$ ，从而得到下次放置 `num` 的索引。
+
+遍历完成后，数组 `res` 中就是排序好的结果，最后使用 `res` 覆盖原数组 `nums` 即可。图 11-17 展示了完整的计数排序流程。
+
+=== "<1>"
+    ![计数排序步骤](counting_sort.assets/counting_sort_step1.png)
+
+=== "<2>"
+    ![counting_sort_step2](counting_sort.assets/counting_sort_step2.png)
+
+=== "<3>"
+    ![counting_sort_step3](counting_sort.assets/counting_sort_step3.png)
+
+=== "<4>"
+    ![counting_sort_step4](counting_sort.assets/counting_sort_step4.png)
+
+=== "<5>"
+    ![counting_sort_step5](counting_sort.assets/counting_sort_step5.png)
+
+=== "<6>"
+    ![counting_sort_step6](counting_sort.assets/counting_sort_step6.png)
+
+=== "<7>"
+    ![counting_sort_step7](counting_sort.assets/counting_sort_step7.png)
+
+=== "<8>"
+    ![counting_sort_step8](counting_sort.assets/counting_sort_step8.png)
+
+<p align="center"> 图 11-17 &nbsp; 计数排序步骤 </p>
+
+计数排序的实现代码如下所示。
+
+=== "Python"
+
+    ```python title="counting_sort.py"
+    def counting_sort(nums: list[int]):
+        """计数排序"""
+        # 完整实现，可排序对象，并且是稳定排序
+        # 1. 统计数组最大元素 m
+        m = max(nums)
+        # 2. 统计各数字的出现次数
+        # counter[num] 代表 num 的出现次数
+        counter = [0] * (m + 1)
+        for num in nums:
+            counter[num] += 1
+        # 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        # 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for i in range(m):
+            counter[i + 1] += counter[i]
+        # 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        # 初始化数组 res 用于记录结果
+        n = len(nums)
+        res = [0] * n
+        for i in range(n - 1, -1, -1):
+            num = nums[i]
+            res[counter[num] - 1] = num  # 将 num 放置到对应索引处
+            counter[num] -= 1  # 令前缀和自减 1 ，得到下次放置 num 的索引
+        # 使用结果数组 res 覆盖原数组 nums
+        for i in range(n):
+            nums[i] = res[i]
+    ```
+
+=== "C++"
+
+    ```cpp title="counting_sort.cpp"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(vector<int> &nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int num : nums) {
+            m = max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        vector<int> counter(m + 1, 0);
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        int n = nums.size();
+        vector<int> res(n);
+        for (int i = n - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--;              // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        nums = res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="counting_sort.java"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(int[] nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int num : nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int[] counter = new int[m + 1];
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        int n = nums.length;
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="counting_sort.cs"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void CountingSort(int[] nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        foreach (int num in nums) {
+            m = Math.Max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int[] counter = new int[m + 1];
+        foreach (int num in nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        int n = nums.Length;
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="counting_sort.go"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    func countingSort(nums []int) {
+        // 1. 统计数组最大元素 m
+        m := 0
+        for _, num := range nums {
+            if num > m {
+                m = num
+            }
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        counter := make([]int, m+1)
+        for _, num := range nums {
+            counter[num]++
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for i := 0; i < m; i++ {
+            counter[i+1] += counter[i]
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        n := len(nums)
+        res := make([]int, n)
+        for i := n - 1; i >= 0; i-- {
+            num := nums[i]
+            // 将 num 放置到对应索引处
+            res[counter[num]-1] = num
+            // 令前缀和自减 1 ，得到下次放置 num 的索引
+            counter[num]--
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        copy(nums, res)
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="counting_sort.swift"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    func countingSort(nums: inout [Int]) {
+        // 1. 统计数组最大元素 m
+        let m = nums.max()!
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        var counter = Array(repeating: 0, count: m + 1)
+        for num in nums {
+            counter[num] += 1
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for i in stride(from: 0, to: m, by: 1) {
+            counter[i + 1] += counter[i]
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        var res = Array(repeating: 0, count: nums.count)
+        for i in stride(from: nums.count - 1, through: 0, by: -1) {
+            let num = nums[i]
+            res[counter[num] - 1] = num // 将 num 放置到对应索引处
+            counter[num] -= 1 // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for i in stride(from: 0, to: nums.count, by: 1) {
+            nums[i] = res[i]
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="counting_sort.js"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    function countingSort(nums) {
+        // 1. 统计数组最大元素 m
+        let m = 0;
+        for (const num of nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        const counter = new Array(m + 1).fill(0);
+        for (const num of nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (let i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        const n = nums.length;
+        const res = new Array(n);
+        for (let i = n - 1; i >= 0; i--) {
+            const num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for (let i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="counting_sort.ts"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    function countingSort(nums: number[]): void {
+        // 1. 统计数组最大元素 m
+        let m = 0;
+        for (const num of nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        const counter: number[] = new Array<number>(m + 1).fill(0);
+        for (const num of nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (let i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        const n = nums.length;
+        const res: number[] = new Array<number>(n);
+        for (let i = n - 1; i >= 0; i--) {
+            const num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for (let i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="counting_sort.dart"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(List<int> nums) {
+      // 1. 统计数组最大元素 m
+      int m = 0;
+      for (int num in nums) {
+        m = max(m, num);
+      }
+      // 2. 统计各数字的出现次数
+      // counter[num] 代表 num 的出现次数
+      List<int> counter = List.filled(m + 1, 0);
+      for (int num in nums) {
+        counter[num]++;
+      }
+      // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+      // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+      for (int i = 0; i < m; i++) {
+        counter[i + 1] += counter[i];
+      }
+      // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+      // 初始化数组 res 用于记录结果
+      int n = nums.length;
+      List<int> res = List.filled(n, 0);
+      for (int i = n - 1; i >= 0; i--) {
+        int num = nums[i];
+        res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+        counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+      }
+      // 使用结果数组 res 覆盖原数组 nums
+      nums.setAll(0, res);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="counting_sort.rs"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    fn counting_sort(nums: &mut [i32]) {
+        // 1. 统计数组最大元素 m
+        let m = *nums.into_iter().max().unwrap();
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        let mut counter = vec![0; m as usize + 1];
+        for &num in &*nums {
+            counter[num as usize] += 1;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for i in 0..m as usize {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        let n = nums.len();
+        let mut res = vec![0; n];
+        for i in (0..n).rev() {
+            let num = nums[i];
+            res[counter[num as usize] - 1] = num; // 将 num 放置到对应索引处
+            counter[num as usize] -= 1; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for i in 0..n {
+            nums[i] = res[i];
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="counting_sort.c"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(int nums[], int size) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int i = 0; i < size; i++) {
+            if (nums[i] > m) {
+                m = nums[i];
+            }
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int *counter = malloc(sizeof(int) * m);
+        for (int i = 0; i < size; i++) {
+            counter[nums[i]]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        int *res = malloc(sizeof(int) * size);
+        for (int i = size - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--;              // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        memcpy(nums, res, size * sizeof(int));
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="counting_sort.zig"
+    [class]{}-[func]{countingSort}
+    ```
+
+## 11.9.3 &nbsp; 算法特性
+
+- **时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，时间复杂度趋于 $O(n)$ 。
+- **空间复杂度 $O(n + m)$、非原地排序**：借助了长度分别为 $n$ 和 $m$ 的数组 `res` 和 `counter` 。
+- **稳定排序**：由于向 `res` 中填充元素的顺序是“从右向左”的，因此倒序遍历 `nums` 可以避免改变相等元素之间的相对位置，从而实现稳定排序。实际上，正序遍历 `nums` 也可以得到正确的排序结果，但结果是非稳定的。
+
+## 11.9.4 &nbsp; 局限性
+
+看到这里，你也许会觉得计数排序非常巧妙，仅通过统计数量就可以实现高效的排序工作。然而，使用计数排序的前置条件相对较为严格。
+
+**计数排序只适用于非负整数**。若想要将其用于其他类型的数据，需要确保这些数据可以被转换为非负整数，并且在转换过程中不能改变各个元素之间的相对大小关系。例如，对于包含负数的整数数组，可以先给所有数字加上一个常数，将全部数字转化为正数，排序完成后再转换回去即可。
+
+**计数排序适用于数据量大但数据范围较小的情况**。比如，在上述示例中 $m$ 不能太大，否则会占用过多空间。而当 $n \ll m$ 时，计数排序使用 $O(m)$ 时间，可能比 $O(n \log n)$ 的排序算法还要慢。

docs/chapter_sorting/heap_sort.md

@@ -0,0 +1,549 @@
+---
+comments: true
+---
+
+# 11.7   堆排序
+
+!!! tip
+
+    阅读本节前，请确保已学完“堆“章节。
+
+「堆排序 heap sort」是一种基于堆数据结构实现的高效排序算法。我们可以利用已经学过的“建堆操作”和“元素出堆操作”实现堆排序。
+
+1. 输入数组并建立小顶堆，此时最小元素位于堆顶。
+2. 不断执行出堆操作，依次记录出堆元素，即可得到从小到大排序的序列。
+
+以上方法虽然可行，但需要借助一个额外数组来保存弹出的元素，比较浪费空间。在实际中，我们通常使用一种更加优雅的实现方式。
+
+## 11.7.1   算法流程
+
+设数组的长度为 $n$ ，堆排序的流程如图 11-12 所示。
+
+1. 输入数组并建立大顶堆。完成后，最大元素位于堆顶。
+2. 将堆顶元素（第一个元素）与堆底元素（最后一个元素）交换。完成交换后，堆的长度减 $1$ ，已排序元素数量加 $1$ 。
+3. 从堆顶元素开始，从顶到底执行堆化操作（Sift Down）。完成堆化后，堆的性质得到修复。
+4. 循环执行第 `2.` 和 `3.` 步。循环 $n - 1$ 轮后，即可完成数组排序。
+
+!!! tip
+
+    实际上，元素出堆操作中也包含第 `2.` 和 `3.` 步，只是多了一个弹出元素的步骤。
+
+=== "<1>"
+    ![堆排序步骤](heap_sort.assets/heap_sort_step1.png)
+
+=== "<2>"
+    ![heap_sort_step2](heap_sort.assets/heap_sort_step2.png)
+
+=== "<3>"
+    ![heap_sort_step3](heap_sort.assets/heap_sort_step3.png)
+
+=== "<4>"
+    ![heap_sort_step4](heap_sort.assets/heap_sort_step4.png)
+
+=== "<5>"
+    ![heap_sort_step5](heap_sort.assets/heap_sort_step5.png)
+
+=== "<6>"
+    ![heap_sort_step6](heap_sort.assets/heap_sort_step6.png)
+
+=== "<7>"
+    ![heap_sort_step7](heap_sort.assets/heap_sort_step7.png)
+
+=== "<8>"
+    ![heap_sort_step8](heap_sort.assets/heap_sort_step8.png)
+
+=== "<9>"
+    ![heap_sort_step9](heap_sort.assets/heap_sort_step9.png)
+
+=== "<10>"
+    ![heap_sort_step10](heap_sort.assets/heap_sort_step10.png)
+
+=== "<11>"
+    ![heap_sort_step11](heap_sort.assets/heap_sort_step11.png)
+
+=== "<12>"
+    ![heap_sort_step12](heap_sort.assets/heap_sort_step12.png)
+
+<p align="center"> 图 11-12 &nbsp; 堆排序步骤 </p>
+
+在代码实现中，我们使用了与堆章节相同的从顶至底堆化 `sift_down()` 函数。值得注意的是，由于堆的长度会随着提取最大元素而减小，因此我们需要给 `sift_down()` 函数添加一个长度参数 $n$ ，用于指定堆的当前有效长度。
+
+=== "Python"
+
+    ```python title="heap_sort.py"
+    def sift_down(nums: list[int], n: int, i: int):
+        """堆的长度为 n ，从节点 i 开始，从顶至底堆化"""
+        while True:
+            # 判断节点 i, l, r 中值最大的节点，记为 ma
+            l = 2 * i + 1
+            r = 2 * i + 2
+            ma = i
+            if l < n and nums[l] > nums[ma]:
+                ma = l
+            if r < n and nums[r] > nums[ma]:
+                ma = r
+            # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if ma == i:
+                break
+            # 交换两节点
+            nums[i], nums[ma] = nums[ma], nums[i]
+            # 循环向下堆化
+            i = ma
+
+    def heap_sort(nums: list[int]):
+        """堆排序"""
+        # 建堆操作：堆化除叶节点以外的其他所有节点
+        for i in range(len(nums) // 2 - 1, -1, -1):
+            sift_down(nums, len(nums), i)
+        # 从堆中提取最大元素，循环 n-1 轮
+        for i in range(len(nums) - 1, 0, -1):
+            # 交换根节点与最右叶节点（即交换首元素与尾元素）
+            nums[0], nums[i] = nums[i], nums[0]
+            # 以根节点为起点，从顶至底进行堆化
+            sift_down(nums, i, 0)
+    ```
+
+=== "C++"
+
+    ```cpp title="heap_sort.cpp"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(vector<int> &nums, int n, int i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i) {
+                break;
+            }
+            // 交换两节点
+            swap(nums[i], nums[ma]);
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+
+    /* 堆排序 */
+    void heapSort(vector<int> &nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = nums.size() / 2 - 1; i >= 0; --i) {
+            siftDown(nums, nums.size(), i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = nums.size() - 1; i > 0; --i) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            swap(nums[0], nums[i]);
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="heap_sort.java"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(int[] nums, int n, int i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i)
+                break;
+            // 交换两节点
+            int temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+
+    /* 堆排序 */
+    void heapSort(int[] nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = nums.length / 2 - 1; i >= 0; i--) {
+            siftDown(nums, nums.length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = nums.length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            int tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="heap_sort.cs"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void SiftDown(int[] nums, int n, int i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i)
+                break;
+            // 交换两节点
+            (nums[ma], nums[i]) = (nums[i], nums[ma]);
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+
+    /* 堆排序 */
+    void HeapSort(int[] nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = nums.Length / 2 - 1; i >= 0; i--) {
+            SiftDown(nums, nums.Length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = nums.Length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            (nums[i], nums[0]) = (nums[0], nums[i]);
+            // 以根节点为起点，从顶至底进行堆化
+            SiftDown(nums, i, 0);
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="heap_sort.go"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    func siftDown(nums *[]int, n, i int) {
+        for true {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            l := 2*i + 1
+            r := 2*i + 2
+            ma := i
+            if l < n && (*nums)[l] > (*nums)[ma] {
+                ma = l
+            }
+            if r < n && (*nums)[r] > (*nums)[ma] {
+                ma = r
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if ma == i {
+                break
+            }
+            // 交换两节点
+            (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]
+            // 循环向下堆化
+            i = ma
+        }
+    }
+
+    /* 堆排序 */
+    func heapSort(nums *[]int) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for i := len(*nums)/2 - 1; i >= 0; i-- {
+            siftDown(nums, len(*nums), i)
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for i := len(*nums) - 1; i > 0; i-- {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0)
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="heap_sort.swift"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    func siftDown(nums: inout [Int], n: Int, i: Int) {
+        var i = i
+        while true {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let l = 2 * i + 1
+            let r = 2 * i + 2
+            var ma = i
+            if l < n, nums[l] > nums[ma] {
+                ma = l
+            }
+            if r < n, nums[r] > nums[ma] {
+                ma = r
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if ma == i {
+                break
+            }
+            // 交换两节点
+            nums.swapAt(i, ma)
+            // 循环向下堆化
+            i = ma
+        }
+    }
+
+    /* 堆排序 */
+    func heapSort(nums: inout [Int]) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {
+            siftDown(nums: &nums, n: nums.count, i: i)
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for i in stride(from: nums.count - 1, to: 0, by: -1) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            nums.swapAt(0, i)
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums: &nums, n: i, i: 0)
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="heap_sort.js"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    function siftDown(nums, n, i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let l = 2 * i + 1;
+            let r = 2 * i + 2;
+            let ma = i;
+            if (l < n && nums[l] > nums[ma]) {
+                ma = l;
+            }
+            if (r < n && nums[r] > nums[ma]) {
+                ma = r;
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma === i) {
+                break;
+            }
+            // 交换两节点
+            [nums[i], nums[ma]] = [nums[ma], nums[i]];
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+
+    /* 堆排序 */
+    function heapSort(nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
+            siftDown(nums, nums.length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            [nums[0], nums[i]] = [nums[i], nums[0]];
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="heap_sort.ts"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    function siftDown(nums: number[], n: number, i: number): void {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let l = 2 * i + 1;
+            let r = 2 * i + 2;
+            let ma = i;
+            if (l < n && nums[l] > nums[ma]) {
+                ma = l;
+            }
+            if (r < n && nums[r] > nums[ma]) {
+                ma = r;
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma === i) {
+                break;
+            }
+            // 交换两节点
+            [nums[i], nums[ma]] = [nums[ma], nums[i]];
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+
+    /* 堆排序 */
+    function heapSort(nums: number[]): void {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
+            siftDown(nums, nums.length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            [nums[0], nums[i]] = [nums[i], nums[0]];
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="heap_sort.dart"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(List<int> nums, int n, int i) {
+      while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        int l = 2 * i + 1;
+        int r = 2 * i + 2;
+        int ma = i;
+        if (l < n && nums[l] > nums[ma]) ma = l;
+        if (r < n && nums[r] > nums[ma]) ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (ma == i) break;
+        // 交换两节点
+        int temp = nums[i];
+        nums[i] = nums[ma];
+        nums[ma] = temp;
+        // 循环向下堆化
+        i = ma;
+      }
+    }
+
+    /* 堆排序 */
+    void heapSort(List<int> nums) {
+      // 建堆操作：堆化除叶节点以外的其他所有节点
+      for (int i = nums.length ~/ 2 - 1; i >= 0; i--) {
+        siftDown(nums, nums.length, i);
+      }
+      // 从堆中提取最大元素，循环 n-1 轮
+      for (int i = nums.length - 1; i > 0; i--) {
+        // 交换根节点与最右叶节点（即交换首元素与尾元素）
+        int tmp = nums[0];
+        nums[0] = nums[i];
+        nums[i] = tmp;
+        // 以根节点为起点，从顶至底进行堆化
+        siftDown(nums, i, 0);
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="heap_sort.rs"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    fn sift_down(nums: &mut [i32], n: usize, mut i: usize) {
+        loop {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let l = 2 * i + 1;
+            let r = 2 * i + 2;
+            let mut ma = i;
+            if l < n && nums[l] > nums[ma] {
+                ma = l;
+            }
+            if r < n && nums[r] > nums[ma] {
+                ma = r;
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if ma == i {
+                break;
+            }
+            // 交换两节点
+            let temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+
+    /* 堆排序 */
+    fn heap_sort(nums: &mut [i32]) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for i in (0..=nums.len() / 2 - 1).rev() {
+            sift_down(nums, nums.len(), i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for i in (1..=nums.len() - 1).rev() {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            let tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // 以根节点为起点，从顶至底进行堆化
+            sift_down(nums, i, 0);
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="heap_sort.c"
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(int nums[], int n, int i) {
+        while (1) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i) {
+                break;
+            }
+            // 交换两节点
+            int temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+
+    /* 堆排序 */
+    void heapSort(int nums[], int n) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = n / 2 - 1; i >= 0; --i) {
+            siftDown(nums, n, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = n - 1; i > 0; --i) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            int tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="heap_sort.zig"
+    [class]{}-[func]{siftDown}
+
+    [class]{}-[func]{heapSort}
+    ```
+
+## 11.7.2 &nbsp; 算法特性
+
+- **时间复杂度 $O(n \log n)$、非自适应排序**：建堆操作使用 $O(n)$ 时间。从堆中提取最大元素的时间复杂度为 $O(\log n)$ ，共循环 $n - 1$ 轮。
+- **空间复杂度 $O(1)$、原地排序**：几个指针变量使用 $O(1)$ 空间。元素交换和堆化操作都是在原数组上进行的。
+- **非稳定排序**：在交换堆顶元素和堆底元素时，相等元素的相对位置可能发生变化。

docs/chapter_sorting/index.md

@@ -0,0 +1,32 @@
+---
+comments: true
+icon: material/sort-ascending
+---
+
+# 第 11 章   排序
+
+<div class="center-table" markdown>
+
+![排序](../assets/covers/chapter_sorting.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    排序犹如一把将混乱变为秩序的魔法钥匙，使我们能以更高效的方式理解与处理数据。
+
+    无论是简单的升序，还是复杂的分类排列，排序都向我们展示了数据的和谐美感。
+
+## 本章内容
+
+- [11.1 &nbsp; 排序算法](https://www.hello-algo.com/chapter_sorting/sorting_algorithm/)
+- [11.2 &nbsp; 选择排序](https://www.hello-algo.com/chapter_sorting/selection_sort/)
+- [11.3 &nbsp; 冒泡排序](https://www.hello-algo.com/chapter_sorting/bubble_sort/)
+- [11.4 &nbsp; 插入排序](https://www.hello-algo.com/chapter_sorting/insertion_sort/)
+- [11.5 &nbsp; 快速排序](https://www.hello-algo.com/chapter_sorting/quick_sort/)
+- [11.6 &nbsp; 归并排序](https://www.hello-algo.com/chapter_sorting/merge_sort/)
+- [11.7 &nbsp; 堆排序](https://www.hello-algo.com/chapter_sorting/heap_sort/)
+- [11.8 &nbsp; 桶排序](https://www.hello-algo.com/chapter_sorting/bucket_sort/)
+- [11.9 &nbsp; 计数排序](https://www.hello-algo.com/chapter_sorting/counting_sort/)
+- [11.10 &nbsp; 基数排序](https://www.hello-algo.com/chapter_sorting/radix_sort/)
+- [11.11 &nbsp; 小结](https://www.hello-algo.com/chapter_sorting/summary/)

docs/chapter_sorting/insertion_sort.md

@@ -0,0 +1,269 @@
+---
+comments: true
+---
+
+# 11.4   插入排序
+
+「插入排序 insertion sort」是一种简单的排序算法，它的工作原理与手动整理一副牌的过程非常相似。
+
+具体来说，我们在未排序区间选择一个基准元素，将该元素与其左侧已排序区间的元素逐一比较大小，并将该元素插入到正确的位置。
+
+图 11-6 展示了数组插入元素的操作流程。设基准元素为 `base` ，我们需要将从目标索引到 `base` 之间的所有元素向右移动一位，然后再将 `base` 赋值给目标索引。
+
+![单次插入操作](insertion_sort.assets/insertion_operation.png)
+
+<p align="center"> 图 11-6 &nbsp; 单次插入操作 </p>
+
+## 11.4.1 &nbsp; 算法流程
+
+插入排序的整体流程如图 11-7 所示。
+
+1. 初始状态下，数组的第 1 个元素已完成排序。
+2. 选取数组的第 2 个元素作为 `base` ，将其插入到正确位置后，**数组的前 2 个元素已排序**。
+3. 选取第 3 个元素作为 `base` ，将其插入到正确位置后，**数组的前 3 个元素已排序**。
+4. 以此类推，在最后一轮中，选取最后一个元素作为 `base` ，将其插入到正确位置后，**所有元素均已排序**。
+
+![插入排序流程](insertion_sort.assets/insertion_sort_overview.png)
+
+<p align="center"> 图 11-7 &nbsp; 插入排序流程 </p>
+
+=== "Python"
+
+    ```python title="insertion_sort.py"
+    def insertion_sort(nums: list[int]):
+        """插入排序"""
+        # 外循环：已排序区间为 [0, i-1]
+        for i in range(1, len(nums)):
+            base = nums[i]
+            j = i - 1
+            # 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
+            while j >= 0 and nums[j] > base:
+                nums[j + 1] = nums[j]  # 将 nums[j] 向右移动一位
+                j -= 1
+            nums[j + 1] = base  # 将 base 赋值到正确位置
+    ```
+
+=== "C++"
+
+    ```cpp title="insertion_sort.cpp"
+    /* 插入排序 */
+    void insertionSort(vector<int> &nums) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (int i = 1; i < nums.size(); i++) {
+            int base = nums[i], j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base; // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="insertion_sort.java"
+    /* 插入排序 */
+    void insertionSort(int[] nums) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (int i = 1; i < nums.length; i++) {
+            int base = nums[i], j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base;        // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="insertion_sort.cs"
+    /* 插入排序 */
+    void InsertionSort(int[] nums) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (int i = 1; i < nums.Length; i++) {
+            int bas = nums[i], j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > bas) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = bas;         // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="insertion_sort.go"
+    /* 插入排序 */
+    func insertionSort(nums []int) {
+        // 外循环：未排序区间为 [0, i]
+        for i := 1; i < len(nums); i++ {
+            base := nums[i]
+            j := i - 1
+            // 内循环：将 base 插入到已排序部分的正确位置
+            for j >= 0 && nums[j] > base {
+                nums[j+1] = nums[j] // 将 nums[j] 向右移动一位
+                j--
+            }
+            nums[j+1] = base // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="insertion_sort.swift"
+    /* 插入排序 */
+    func insertionSort(nums: inout [Int]) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for i in stride(from: 1, to: nums.count, by: 1) {
+            let base = nums[i]
+            var j = i - 1
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while j >= 0, nums[j] > base {
+                nums[j + 1] = nums[j] // 将 nums[j] 向右移动一位
+                j -= 1
+            }
+            nums[j + 1] = base // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="insertion_sort.js"
+    /* 插入排序 */
+    function insertionSort(nums) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (let i = 1; i < nums.length; i++) {
+            let base = nums[i],
+                j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base; // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="insertion_sort.ts"
+    /* 插入排序 */
+    function insertionSort(nums: number[]): void {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (let i = 1; i < nums.length; i++) {
+            const base = nums[i];
+            let j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base; // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="insertion_sort.dart"
+    /* 插入排序 */
+    void insertionSort(List<int> nums) {
+      // 外循环：已排序元素数量为 1, 2, ..., n
+      for (int i = 1; i < nums.length; i++) {
+        int base = nums[i], j = i - 1;
+        // 内循环：将 base 插入到已排序部分的正确位置
+        while (j >= 0 && nums[j] > base) {
+          nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+          j--;
+        }
+        nums[j + 1] = base; // 将 base 赋值到正确位置
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="insertion_sort.rs"
+    /* 插入排序 */
+    fn insertion_sort(nums: &mut [i32]) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for i in 1..nums.len() {
+            let (base, mut j) = (nums[i],  (i - 1) as i32);
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while j >= 0 && nums[j as usize] > base {
+                nums[(j + 1) as usize] = nums[j as usize]; // 将 nums[j] 向右移动一位
+                j -= 1;
+            }
+            nums[(j + 1) as usize] = base;  // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="insertion_sort.c"
+    /* 插入排序 */
+    void insertionSort(int nums[], int size) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (int i = 1; i < size; i++) {
+            int base = nums[i], j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                // 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j];
+                j--;
+            }
+            // 将 base 赋值到正确位置
+            nums[j + 1] = base;
+        }
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="insertion_sort.zig"
+    // 插入排序
+    fn insertionSort(nums: []i32) void {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        var i: usize = 1;
+        while (i < nums.len) : (i += 1) {
+            var base = nums[i];
+            var j: usize = i;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
+                nums[j] = nums[j - 1];  // 将 nums[j] 向右移动一位
+            }
+            nums[j] = base;             // 将 base 赋值到正确位置
+        }
+    }
+    ```
+
+## 11.4.2 &nbsp; 算法特性
+
+- **时间复杂度 $O(n^2)$、自适应排序**：最差情况下，每次插入操作分别需要循环 $n - 1$、$n-2$、$\dots$、$2$、$1$ 次，求和得到 $(n - 1) n / 2$ ，因此时间复杂度为 $O(n^2)$ 。在遇到有序数据时，插入操作会提前终止。当输入数组完全有序时，插入排序达到最佳时间复杂度 $O(n)$ 。
+- **空间复杂度 $O(1)$、原地排序**：指针 $i$ 和 $j$ 使用常数大小的额外空间。
+- **稳定排序**：在插入操作过程中，我们会将元素插入到相等元素的右侧，不会改变它们的顺序。
+
+## 11.4.3 &nbsp; 插入排序优势
+
+插入排序的时间复杂度为 $O(n^2)$ ，而我们即将学习的快速排序的时间复杂度为 $O(n \log n)$ 。尽管插入排序的时间复杂度相比快速排序更高，**但在数据量较小的情况下，插入排序通常更快**。
+
+这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元操作数量起到决定性因素。
+
+实际上，许多编程语言（例如 Java）的内置排序函数都采用了插入排序，大致思路为：对于长数组，采用基于分治的排序算法，例如快速排序；对于短数组，直接使用插入排序。
+
+虽然冒泡排序、选择排序和插入排序的时间复杂度都为 $O(n^2)$ ，但在实际情况中，**插入排序的使用频率显著高于冒泡排序和选择排序**，主要有以下原因。
+
+- 冒泡排序基于元素交换实现，需要借助一个临时变量，共涉及 3 个单元操作；插入排序基于元素赋值实现，仅需 1 个单元操作。因此，**冒泡排序的计算开销通常比插入排序更高**。
+- 选择排序在任何情况下的时间复杂度都为 $O(n^2)$ 。**如果给定一组部分有序的数据，插入排序通常比选择排序效率更高**。
+- 选择排序不稳定，无法应用于多级排序。

docs/chapter_sorting/merge_sort.md

@@ -0,0 +1,641 @@
+---
+comments: true
+---
+
+# 11.6   归并排序
+
+「归并排序 merge sort」是一种基于分治策略的排序算法，包含图 11-10 所示的“划分”和“合并”阶段。
+
+1. **划分阶段**：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题。
+2. **合并阶段**：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束。
+
+![归并排序的划分与合并阶段](merge_sort.assets/merge_sort_overview.png)
+
+<p align="center"> 图 11-10 &nbsp; 归并排序的划分与合并阶段 </p>
+
+## 11.6.1 &nbsp; 算法流程
+
+如图 11-11 所示，“划分阶段”从顶至底递归地将数组从中点切分为两个子数组。
+
+1. 计算数组中点 `mid` ，递归划分左子数组（区间 `[left, mid]` ）和右子数组（区间 `[mid + 1, right]` ）。
+2. 递归执行步骤 `1.` ，直至子数组区间长度为 1 时，终止递归划分。
+
+“合并阶段”从底至顶地将左子数组和右子数组合并为一个有序数组。需要注意的是，从长度为 1 的子数组开始合并，合并阶段中的每个子数组都是有序的。
+
+=== "<1>"
+    ![归并排序步骤](merge_sort.assets/merge_sort_step1.png)
+
+=== "<2>"
+    ![merge_sort_step2](merge_sort.assets/merge_sort_step2.png)
+
+=== "<3>"
+    ![merge_sort_step3](merge_sort.assets/merge_sort_step3.png)
+
+=== "<4>"
+    ![merge_sort_step4](merge_sort.assets/merge_sort_step4.png)
+
+=== "<5>"
+    ![merge_sort_step5](merge_sort.assets/merge_sort_step5.png)
+
+=== "<6>"
+    ![merge_sort_step6](merge_sort.assets/merge_sort_step6.png)
+
+=== "<7>"
+    ![merge_sort_step7](merge_sort.assets/merge_sort_step7.png)
+
+=== "<8>"
+    ![merge_sort_step8](merge_sort.assets/merge_sort_step8.png)
+
+=== "<9>"
+    ![merge_sort_step9](merge_sort.assets/merge_sort_step9.png)
+
+=== "<10>"
+    ![merge_sort_step10](merge_sort.assets/merge_sort_step10.png)
+
+<p align="center"> 图 11-11 &nbsp; 归并排序步骤 </p>
+
+观察发现，归并排序与二叉树后序遍历的递归顺序是一致的。
+
+- **后序遍历**：先递归左子树，再递归右子树，最后处理根节点。
+- **归并排序**：先递归左子数组，再递归右子数组，最后处理合并。
+
+=== "Python"
+
+    ```python title="merge_sort.py"
+    def merge(nums: list[int], left: int, mid: int, right: int):
+        """合并左子数组和右子数组"""
+        # 左子数组区间 [left, mid]
+        # 右子数组区间 [mid + 1, right]
+        # 初始化辅助数组
+        tmp = list(nums[left : right + 1])
+        # 左子数组的起始索引和结束索引
+        left_start = 0
+        left_end = mid - left
+        # 右子数组的起始索引和结束索引
+        right_start = mid + 1 - left
+        right_end = right - left
+        # i, j 分别指向左子数组、右子数组的首元素
+        i = left_start
+        j = right_start
+        # 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k in range(left, right + 1):
+            # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if i > left_end:
+                nums[k] = tmp[j]
+                j += 1
+            # 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            elif j > right_end or tmp[i] <= tmp[j]:
+                nums[k] = tmp[i]
+                i += 1
+            # 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else:
+                nums[k] = tmp[j]
+                j += 1
+
+    def merge_sort(nums: list[int], left: int, right: int):
+        """归并排序"""
+        # 终止条件
+        if left >= right:
+            return  # 当子数组长度为 1 时终止递归
+        # 划分阶段
+        mid = (left + right) // 2  # 计算中点
+        merge_sort(nums, left, mid)  # 递归左子数组
+        merge_sort(nums, mid + 1, right)  # 递归右子数组
+        # 合并阶段
+        merge(nums, left, mid, right)
+    ```
+
+=== "C++"
+
+    ```cpp title="merge_sort.cpp"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(vector<int> &nums, int left, int mid, int right) {
+        // 初始化辅助数组
+        vector<int> tmp(nums.begin() + left, nums.begin() + right + 1);
+        // 左子数组的起始索引和结束索引
+        int leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        int rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        int i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (int k = left; k <= right; k++) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd)
+                nums[k] = tmp[j++];
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if (j > rightEnd || tmp[i] <= tmp[j])
+                nums[k] = tmp[i++];
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else
+                nums[k] = tmp[j++];
+        }
+    }
+
+    /* 归并排序 */
+    void mergeSort(vector<int> &nums, int left, int right) {
+        // 终止条件
+        if (left >= right)
+            return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
+        mergeSort(nums, left, mid);      // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
+    ```
+
+=== "Java"
+
+    ```java title="merge_sort.java"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(int[] nums, int left, int mid, int right) {
+        // 初始化辅助数组
+        int[] tmp = Arrays.copyOfRange(nums, left, right + 1);
+        // 左子数组的起始索引和结束索引
+        int leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        int rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        int i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (int k = left; k <= right; k++) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd)
+                nums[k] = tmp[j++];
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if (j > rightEnd || tmp[i] <= tmp[j])
+                nums[k] = tmp[i++];
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else
+                nums[k] = tmp[j++];
+        }
+    }
+
+    /* 归并排序 */
+    void mergeSort(int[] nums, int left, int right) {
+        // 终止条件
+        if (left >= right)
+            return;                      // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
+        mergeSort(nums, left, mid);      // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="merge_sort.cs"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void Merge(int[] nums, int left, int mid, int right) {
+        // 初始化辅助数组
+        int[] tmp = nums[left..(right + 1)];
+        // 左子数组的起始索引和结束索引  
+        int leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引       
+        int rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        int i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (int k = left; k <= right; k++) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd)
+                nums[k] = tmp[j++];
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if (j > rightEnd || tmp[i] <= tmp[j])
+                nums[k] = tmp[i++];
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else
+                nums[k] = tmp[j++];
+        }
+    }
+
+    /* 归并排序 */
+    void MergeSort(int[] nums, int left, int right) {
+        // 终止条件
+        if (left >= right) return;       // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
+        MergeSort(nums, left, mid);      // 递归左子数组
+        MergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        Merge(nums, left, mid, right);
+    }
+    ```
+
+=== "Go"
+
+    ```go title="merge_sort.go"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    func merge(nums []int, left, mid, right int) {
+        // 初始化辅助数组 借助 copy 模块
+        tmp := make([]int, right-left+1)
+        for i := left; i <= right; i++ {
+            tmp[i-left] = nums[i]
+        }
+        // 左子数组的起始索引和结束索引
+        leftStart, leftEnd := left-left, mid-left
+        // 右子数组的起始索引和结束索引
+        rightStart, rightEnd := mid+1-left, right-left
+        // i, j 分别指向左子数组、右子数组的首元素
+        i, j := leftStart, rightStart
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k := left; k <= right; k++ {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if i > leftEnd {
+                nums[k] = tmp[j]
+                j++
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if j > rightEnd || tmp[i] <= tmp[j] {
+                nums[k] = tmp[i]
+                i++
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            } else {
+                nums[k] = tmp[j]
+                j++
+            }
+        }
+    }
+
+    /* 归并排序 */
+    func mergeSort(nums []int, left, right int) {
+        // 终止条件
+        if left >= right {
+            return
+        }
+        // 划分阶段
+        mid := (left + right) / 2
+        mergeSort(nums, left, mid)
+        mergeSort(nums, mid+1, right)
+        // 合并阶段
+        merge(nums, left, mid, right)
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="merge_sort.swift"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    func merge(nums: inout [Int], left: Int, mid: Int, right: Int) {
+        // 初始化辅助数组
+        let tmp = Array(nums[left ..< (right + 1)])
+        // 左子数组的起始索引和结束索引
+        let leftStart = left - left
+        let leftEnd = mid - left
+        // 右子数组的起始索引和结束索引
+        let rightStart = mid + 1 - left
+        let rightEnd = right - left
+        // i, j 分别指向左子数组、右子数组的首元素
+        var i = leftStart
+        var j = rightStart
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k in left ... right {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if i > leftEnd {
+                nums[k] = tmp[j]
+                j += 1
+            }
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if j > rightEnd || tmp[i] <= tmp[j] {
+                nums[k] = tmp[i]
+                i += 1
+            }
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else {
+                nums[k] = tmp[j]
+                j += 1
+            }
+        }
+    }
+
+    /* 归并排序 */
+    func mergeSort(nums: inout [Int], left: Int, right: Int) {
+        // 终止条件
+        if left >= right { // 当子数组长度为 1 时终止递归
+            return
+        }
+        // 划分阶段
+        let mid = (left + right) / 2 // 计算中点
+        mergeSort(nums: &nums, left: left, right: mid) // 递归左子数组
+        mergeSort(nums: &nums, left: mid + 1, right: right) // 递归右子数组
+        // 合并阶段
+        merge(nums: &nums, left: left, mid: mid, right: right)
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="merge_sort.js"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    function merge(nums, left, mid, right) {
+        // 初始化辅助数组
+        let tmp = nums.slice(left, right + 1);
+        // 左子数组的起始索引和结束索引
+        let leftStart = left - left,
+            leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        let rightStart = mid + 1 - left,
+            rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        let i = leftStart,
+            j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (let k = left; k <= right; k++) {
+            if (i > leftEnd) {
+                // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+                nums[k] = tmp[j++];
+            } else if (j > rightEnd || tmp[i] <= tmp[j]) {
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+                nums[k] = tmp[i++];
+            } else {
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+                nums[k] = tmp[j++];
+            }
+        }
+    }
+
+    /* 归并排序 */
+    function mergeSort(nums, left, right) {
+        // 终止条件
+        if (left >= right) return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        let mid = Math.floor((left + right) / 2); // 计算中点
+        mergeSort(nums, left, mid); // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="merge_sort.ts"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    function merge(nums: number[], left: number, mid: number, right: number): void {
+        // 初始化辅助数组
+        let tmp = nums.slice(left, right + 1);
+        // 左子数组的起始索引和结束索引
+        let leftStart = left - left,
+            leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        let rightStart = mid + 1 - left,
+            rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        let i = leftStart,
+            j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (let k = left; k <= right; k++) {
+            if (i > leftEnd) {
+                // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+                nums[k] = tmp[j++];
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if (j > rightEnd || tmp[i] <= tmp[j]) {
+                nums[k] = tmp[i++];
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            } else {
+                nums[k] = tmp[j++];
+            }
+        }
+    }
+
+    /* 归并排序 */
+    function mergeSort(nums: number[], left: number, right: number): void {
+        // 终止条件
+        if (left >= right) return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        let mid = Math.floor((left + right) / 2); // 计算中点
+        mergeSort(nums, left, mid); // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="merge_sort.dart"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(List<int> nums, int left, int mid, int right) {
+      // 初始化辅助数组
+      List<int> tmp = nums.sublist(left, right + 1);
+      // 左子数组的起始索引和结束索引
+      int leftStart = left - left, leftEnd = mid - left;
+      // 右子数组的起始索引和结束索引
+      int rightStart = mid + 1 - left, rightEnd = right - left;
+      // i, j 分别指向左子数组、右子数组的首元素
+      int i = leftStart, j = rightStart;
+      // 通过覆盖原数组 nums 来合并左子数组和右子数组
+      for (int k = left; k <= right; k++) {
+        // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+        if (i > leftEnd)
+          nums[k] = tmp[j++];
+        // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+        else if (j > rightEnd || tmp[i] <= tmp[j])
+          nums[k] = tmp[i++];
+        // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        else
+          nums[k] = tmp[j++];
+      }
+    }
+
+    /* 归并排序 */
+    void mergeSort(List<int> nums, int left, int right) {
+      // 终止条件
+      if (left >= right) return; // 当子数组长度为 1 时终止递归
+      // 划分阶段
+      int mid = (left + right) ~/ 2; // 计算中点
+      mergeSort(nums, left, mid); // 递归左子数组
+      mergeSort(nums, mid + 1, right); // 递归右子数组
+      // 合并阶段
+      merge(nums, left, mid, right);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="merge_sort.rs"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    fn merge(nums: &mut [i32], left: usize, mid: usize, right: usize) {
+        // 初始化辅助数组
+        let tmp: Vec<i32> = nums[left..right + 1].to_vec();
+        // 左子数组的起始索引和结束索引
+        let (left_start, left_end) = (left - left, mid - left);
+        // 右子数组的起始索引和结束索引
+        let (right_start, right_end) = (mid + 1 - left, right-left);
+        // i, j 分别指向左子数组、右子数组的首元素
+        let (mut l_corrent, mut r_corrent) = (left_start, right_start);
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k in left..right + 1 {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if l_corrent > left_end {
+                nums[k] = tmp[r_corrent];
+                r_corrent += 1;
+            }
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if r_corrent > right_end || tmp[l_corrent] <= tmp[r_corrent] {
+                nums[k] = tmp[l_corrent];
+                l_corrent += 1;
+            }
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else {
+                nums[k] = tmp[r_corrent];
+                r_corrent += 1;
+            }
+        }
+    }
+
+    /* 归并排序 */
+    fn merge_sort(left: usize, right: usize, nums: &mut [i32]) {
+        // 终止条件
+        if left >= right { return; }       // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        let mid = (left + right) / 2;     // 计算中点
+        merge_sort(left, mid, nums);      // 递归左子数组
+        merge_sort(mid + 1, right, nums);  // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
+    ```
+
+=== "C"
+
+    ```c title="merge_sort.c"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(int *nums, int left, int mid, int right) {
+        int index;
+        // 初始化辅助数组
+        int tmp[right + 1 - left];
+        for (index = left; index < right + 1; index++) {
+            tmp[index - left] = nums[index];
+        }
+        // 左子数组的起始索引和结束索引
+        int leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        int rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        int i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (int k = left; k <= right; k++) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd)
+                nums[k] = tmp[j++];
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if (j > rightEnd || tmp[i] <= tmp[j])
+                nums[k] = tmp[i++];
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else
+                nums[k] = tmp[j++];
+        }
+    }
+
+    /* 归并排序 */
+    void mergeSort(int *nums, int left, int right) {
+        // 终止条件
+        if (left >= right)
+            return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
+        mergeSort(nums, left, mid);      // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="merge_sort.zig"
+    // 合并左子数组和右子数组
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    fn merge(nums: []i32, left: usize, mid: usize, right: usize) !void {
+        // 初始化辅助数组
+        var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+        defer mem_arena.deinit();
+        const mem_allocator = mem_arena.allocator();
+        var tmp = try mem_allocator.alloc(i32, right + 1 - left);
+        std.mem.copy(i32, tmp, nums[left..right+1]);
+        // 左子数组的起始索引和结束索引  
+        var leftStart = left - left;
+        var leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引       
+        var rightStart = mid + 1 - left;
+        var rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        var i = leftStart;
+        var j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        var k = left;
+        while (k <= right) : (k += 1) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd) {
+                nums[k] = tmp[j];
+                j += 1;
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if  (j > rightEnd or tmp[i] <= tmp[j]) {
+                nums[k] = tmp[i];
+                i += 1;
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            } else {
+                nums[k] = tmp[j];
+                j += 1;
+            }
+        }
+    }
+
+    // 归并排序
+    fn mergeSort(nums: []i32, left: usize, right: usize) !void {
+        // 终止条件
+        if (left >= right) return;              // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        var mid = (left + right) / 2;           // 计算中点
+        try mergeSort(nums, left, mid);         // 递归左子数组
+        try mergeSort(nums, mid + 1, right);    // 递归右子数组
+        // 合并阶段
+        try merge(nums, left, mid, right);
+    }
+    ```
+
+实现合并函数 `merge()` 存在以下难点。
+
+- **需要特别注意各个变量的含义**。`nums` 的待合并区间为 `[left, right]` ，但由于 `tmp` 仅复制了 `nums` 该区间的元素，因此 `tmp` 对应区间为 `[0, right - left]` 。
+- 在比较 `tmp[i]` 和 `tmp[j]` 的大小时，**还需考虑子数组遍历完成后的索引越界问题**，即 `i > leftEnd` 和 `j > rightEnd` 的情况。索引越界的优先级是最高的，如果左子数组已经被合并完了，那么不需要继续比较，直接合并右子数组元素即可。
+
+## 11.6.2 &nbsp; 算法特性
+
+- **时间复杂度 $O(n \log n)$、非自适应排序**：划分产生高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，因此总体时间复杂度为 $O(n \log n)$ 。
+- **空间复杂度 $O(n)$、非原地排序**：递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间。合并操作需要借助辅助数组实现，使用 $O(n)$ 大小的额外空间。
+- **稳定排序**：在合并过程中，相等元素的次序保持不变。
+
+## 11.6.3 &nbsp; 链表排序 *
+
+对于链表，归并排序相较于其他排序算法具有显著优势，**可以将链表排序任务的空间复杂度优化至 $O(1)$** 。
+
+- **划分阶段**：可以通过使用“迭代”替代“递归”来实现链表划分工作，从而省去递归使用的栈帧空间。
+- **合并阶段**：在链表中，节点增删操作仅需改变引用（指针）即可实现，因此合并阶段（将两个短有序链表合并为一个长有序链表）无须创建额外链表。
+
+具体实现细节比较复杂，有兴趣的同学可以查阅相关资料进行学习。

docs/chapter_sorting/radix_sort.md

@@ -0,0 +1,697 @@
+---
+comments: true
+---
+
+# 11.10   基数排序
+
+上一节我们介绍了计数排序，它适用于数据量 $n$ 较大但数据范围 $m$ 较小的情况。假设我们需要对 $n = 10^6$ 个学号进行排序，而学号是一个 $8$ 位数字，这意味着数据范围 $m = 10^8$ 非常大，使用计数排序需要分配大量内存空间，而基数排序可以避免这种情况。
+
+「基数排序 radix sort」的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。
+
+## 11.10.1   算法流程
+
+以学号数据为例，假设数字的最低位是第 $1$ 位，最高位是第 $8$ 位，基数排序的流程如图 11-18 所示。
+
+1. 初始化位数 $k = 1$ 。
+2. 对学号的第 $k$ 位执行“计数排序”。完成后，数据会根据第 $k$ 位从小到大排序。
+3. 将 $k$ 增加 $1$ ，然后返回步骤 `2.` 继续迭代，直到所有位都排序完成后结束。
+
+![基数排序算法流程](radix_sort.assets/radix_sort_overview.png)
+
+<p align="center"> 图 11-18 &nbsp; 基数排序算法流程 </p>
+
+下面来剖析代码实现。对于一个 $d$ 进制的数字 $x$ ，要获取其第 $k$ 位 $x_k$ ，可以使用以下计算公式：
+
+$$
+x_k = \lfloor\frac{x}{d^{k-1}}\rfloor \bmod d
+$$
+
+其中 $\lfloor a \rfloor$ 表示对浮点数 $a$ 向下取整，而 $\bmod \: d$ 表示对 $d$ 取余。对于学号数据，$d = 10$ 且 $k \in [1, 8]$ 。
+
+此外，我们需要小幅改动计数排序代码，使之可以根据数字的第 $k$ 位进行排序。
+
+=== "Python"
+
+    ```python title="radix_sort.py"
+    def digit(num: int, exp: int) -> int:
+        """获取元素 num 的第 k 位，其中 exp = 10^(k-1)"""
+        # 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num // exp) % 10
+
+    def counting_sort_digit(nums: list[int], exp: int):
+        """计数排序（根据 nums 第 k 位排序）"""
+        # 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        counter = [0] * 10
+        n = len(nums)
+        # 统计 0~9 各数字的出现次数
+        for i in range(n):
+            d = digit(nums[i], exp)  # 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1  # 统计数字 d 的出现次数
+        # 求前缀和，将“出现个数”转换为“数组索引”
+        for i in range(1, 10):
+            counter[i] += counter[i - 1]
+        # 倒序遍历，根据桶内统计结果，将各元素填入 res
+        res = [0] * n
+        for i in range(n - 1, -1, -1):
+            d = digit(nums[i], exp)
+            j = counter[d] - 1  # 获取 d 在数组中的索引 j
+            res[j] = nums[i]  # 将当前元素填入索引 j
+            counter[d] -= 1  # 将 d 的数量减 1
+        # 使用结果覆盖原数组 nums
+        for i in range(n):
+            nums[i] = res[i]
+
+    def radix_sort(nums: list[int]):
+        """基数排序"""
+        # 获取数组的最大元素，用于判断最大位数
+        m = max(nums)
+        # 按照从低位到高位的顺序遍历
+        exp = 1
+        while exp <= m:
+            # 对数组元素的第 k 位执行计数排序
+            # k = 1 -> exp = 1
+            # k = 2 -> exp = 10
+            # 即 exp = 10^(k-1)
+            counting_sort_digit(nums, exp)
+            exp *= 10
+    ```
+
+=== "C++"
+
+    ```cpp title="radix_sort.cpp"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(vector<int> &nums, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        vector<int> counter(10, 0);
+        int n = nums.size();
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < n; i++) {
+            int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++;                // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        vector<int> res(n, 0);
+        for (int i = n - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < n; i++)
+            nums[i] = res[i];
+    }
+
+    /* 基数排序 */
+    void radixSort(vector<int> &nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        int m = *max_element(nums.begin(), nums.end());
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; exp <= m; exp *= 10)
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+    }
+    ```
+
+=== "Java"
+
+    ```java title="radix_sort.java"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(int[] nums, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        int[] counter = new int[10];
+        int n = nums.length;
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < n; i++) {
+            int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++;                // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < n; i++)
+            nums[i] = res[i];
+    }
+
+    /* 基数排序 */
+    void radixSort(int[] nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        int m = Integer.MIN_VALUE;
+        for (int num : nums)
+            if (num > m)
+                m = num;
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; exp <= m; exp *= 10)
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="radix_sort.cs"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int Digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void CountingSortDigit(int[] nums, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        int[] counter = new int[10];
+        int n = nums.Length;
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < n; i++) {
+            int d = Digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++;                // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int d = Digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+
+    /* 基数排序 */
+    void RadixSort(int[] nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        int m = int.MinValue;
+        foreach (int num in nums) {
+            if (num > m) m = num;
+        }
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; exp <= m; exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            CountingSortDigit(nums, exp);
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="radix_sort.go"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    func digit(num, exp int) int {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    func countingSortDigit(nums []int, exp int) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        counter := make([]int, 10)
+        n := len(nums)
+        // 统计 0~9 各数字的出现次数
+        for i := 0; i < n; i++ {
+            d := digit(nums[i], exp) // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++             // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for i := 1; i < 10; i++ {
+            counter[i] += counter[i-1]
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        res := make([]int, n)
+        for i := n - 1; i >= 0; i-- {
+            d := digit(nums[i], exp)
+            j := counter[d] - 1 // 获取 d 在数组中的索引 j
+            res[j] = nums[i]    // 将当前元素填入索引 j
+            counter[d]--        // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for i := 0; i < n; i++ {
+            nums[i] = res[i]
+        }
+    }
+
+    /* 基数排序 */
+    func radixSort(nums []int) {
+        // 获取数组的最大元素，用于判断最大位数
+        max := math.MinInt
+        for _, num := range nums {
+            if num > max {
+                max = num
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for exp := 1; max >= exp; exp *= 10 {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp)
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="radix_sort.swift"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    func digit(num: Int, exp: Int) -> Int {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        (num / exp) % 10
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    func countingSortDigit(nums: inout [Int], exp: Int) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        var counter = Array(repeating: 0, count: 10)
+        let n = nums.count
+        // 统计 0~9 各数字的出现次数
+        for i in nums.indices {
+            let d = digit(num: nums[i], exp: exp) // 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1 // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for i in 1 ..< 10 {
+            counter[i] += counter[i - 1]
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        var res = Array(repeating: 0, count: n)
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            let d = digit(num: nums[i], exp: exp)
+            let j = counter[d] - 1 // 获取 d 在数组中的索引 j
+            res[j] = nums[i] // 将当前元素填入索引 j
+            counter[d] -= 1 // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for i in nums.indices {
+            nums[i] = res[i]
+        }
+    }
+
+    /* 基数排序 */
+    func radixSort(nums: inout [Int]) {
+        // 获取数组的最大元素，用于判断最大位数
+        var m = Int.min
+        for num in nums {
+            if num > m {
+                m = num
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for exp in sequence(first: 1, next: { m >= ($0 * 10) ? $0 * 10 : nil }) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums: &nums, exp: exp)
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="radix_sort.js"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    function digit(num, exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return Math.floor(num / exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    function countingSortDigit(nums, exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        const counter = new Array(10).fill(0);
+        const n = nums.length;
+        // 统计 0~9 各数字的出现次数
+        for (let i = 0; i < n; i++) {
+            const d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (let i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        const res = new Array(n).fill(0);
+        for (let i = n - 1; i >= 0; i--) {
+            const d = digit(nums[i], exp);
+            const j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i]; // 将当前元素填入索引 j
+            counter[d]--; // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (let i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+
+    /* 基数排序 */
+    function radixSort(nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        let m = Number.MIN_VALUE;
+        for (const num of nums) {
+            if (num > m) {
+                m = num;
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for (let exp = 1; exp <= m; exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="radix_sort.ts"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    function digit(num: number, exp: number): number {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return Math.floor(num / exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    function countingSortDigit(nums: number[], exp: number): void {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        const counter = new Array(10).fill(0);
+        const n = nums.length;
+        // 统计 0~9 各数字的出现次数
+        for (let i = 0; i < n; i++) {
+            const d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (let i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        const res = new Array(n).fill(0);
+        for (let i = n - 1; i >= 0; i--) {
+            const d = digit(nums[i], exp);
+            const j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i]; // 将当前元素填入索引 j
+            counter[d]--; // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (let i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+
+    /* 基数排序 */
+    function radixSort(nums: number[]): void {
+        // 获取数组的最大元素，用于判断最大位数
+        let m = Number.MIN_VALUE;
+        for (const num of nums) {
+            if (num > m) {
+                m = num;
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for (let exp = 1; exp <= m; exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="radix_sort.dart"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+      // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+      return (num ~/ exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(List<int> nums, int exp) {
+      // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+      List<int> counter = List<int>.filled(10, 0);
+      int n = nums.length;
+      // 统计 0~9 各数字的出现次数
+      for (int i = 0; i < n; i++) {
+        int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+        counter[d]++; // 统计数字 d 的出现次数
+      }
+      // 求前缀和，将“出现个数”转换为“数组索引”
+      for (int i = 1; i < 10; i++) {
+        counter[i] += counter[i - 1];
+      }
+      // 倒序遍历，根据桶内统计结果，将各元素填入 res
+      List<int> res = List<int>.filled(n, 0);
+      for (int i = n - 1; i >= 0; i--) {
+        int d = digit(nums[i], exp);
+        int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+        res[j] = nums[i]; // 将当前元素填入索引 j
+        counter[d]--; // 将 d 的数量减 1
+      }
+      // 使用结果覆盖原数组 nums
+      for (int i = 0; i < n; i++) nums[i] = res[i];
+    }
+
+    /* 基数排序 */
+    void radixSort(List<int> nums) {
+      // 获取数组的最大元素，用于判断最大位数
+      // dart 中 int 的长度是 64 位的
+      int m = -1 << 63;
+      for (int num in nums) if (num > m) m = num;
+      // 按照从低位到高位的顺序遍历
+      for (int exp = 1; exp <= m; exp *= 10)
+        // 对数组元素的第 k 位执行计数排序
+        // k = 1 -> exp = 1
+        // k = 2 -> exp = 10
+        // 即 exp = 10^(k-1)
+        countingSortDigit(nums, exp);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="radix_sort.rs"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    fn digit(num: i32, exp: i32) -> usize {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return ((num / exp) % 10) as usize;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    fn counting_sort_digit(nums: &mut [i32], exp: i32) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        let mut counter = [0; 10];
+        let n = nums.len();
+        // 统计 0~9 各数字的出现次数
+        for i in 0..n {
+            let d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for i in 1..10 {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        let mut res = vec![0; n];
+        for i in (0..n).rev() {
+            let d = digit(nums[i], exp);
+            let j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i]; // 将当前元素填入索引 j
+            counter[d] -= 1; // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for i in 0..n {
+            nums[i] = res[i];
+        }
+    }
+
+    /* 基数排序 */
+    fn radix_sort(nums: &mut [i32]) {
+        // 获取数组的最大元素，用于判断最大位数
+        let m = *nums.into_iter().max().unwrap();
+        // 按照从低位到高位的顺序遍历
+        let mut exp = 1;
+        while exp <= m {
+            counting_sort_digit(nums, exp);
+            exp *= 10;
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="radix_sort.c"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
+
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(int nums[], int size, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        int *counter = (int *)malloc((sizeof(int) * 10));
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < size; i++) {
+            // 获取 nums[i] 第 k 位，记为 d
+            int d = digit(nums[i], exp);
+            // 统计数字 d 的出现次数
+            counter[d]++;
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        int *res = (int *)malloc(sizeof(int) * size);
+        for (int i = size - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < size; i++) {
+            nums[i] = res[i];
+        }
+    }
+
+    /* 基数排序 */
+    void radixSort(int nums[], int size) {
+        // 获取数组的最大元素，用于判断最大位数
+        int max = INT32_MIN;
+        for (size_t i = 0; i < size - 1; i++) {
+            if (nums[i] > max) {
+                max = nums[i];
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; max >= exp; exp *= 10)
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, size, exp);
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="radix_sort.zig"
+    // 获取元素 num 的第 k 位，其中 exp = 10^(k-1)
+    fn digit(num: i32, exp: i32) i32 {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return @mod(@divFloor(num, exp), 10);
+    }
+
+    // 计数排序（根据 nums 第 k 位排序）
+    fn countingSortDigit(nums: []i32, exp: i32) !void {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+        // defer mem_arena.deinit();
+        const mem_allocator = mem_arena.allocator();
+        var counter = try mem_allocator.alloc(usize, 10);
+        @memset(counter, 0);
+        var n = nums.len;
+        // 统计 0~9 各数字的出现次数
+        for (nums) |num| {
+            var d: u32 = @bitCast(digit(num, exp)); // 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        var i: usize = 1;
+        while (i < 10) : (i += 1) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        var res = try mem_allocator.alloc(i32, n);
+        i = n - 1;
+        while (i >= 0) : (i -= 1) {
+            var d: u32 = @bitCast(digit(nums[i], exp));
+            var j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d] -= 1;        // 将 d 的数量减 1
+            if (i == 0) break;
+        }
+        // 使用结果覆盖原数组 nums
+        i = 0;
+        while (i < n) : (i += 1) {
+            nums[i] = res[i];
+        }
+    }
+
+    // 基数排序
+    fn radixSort(nums: []i32) !void {
+        // 获取数组的最大元素，用于判断最大位数
+        var m: i32 = std.math.minInt(i32);
+        for (nums) |num| {
+            if (num > m) m = num;
+        }
+        // 按照从低位到高位的顺序遍历
+        var exp: i32 = 1;
+        while (exp <= m) : (exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            try countingSortDigit(nums, exp);    
+        }
+    } 
+    ```
+
+!!! question "为什么从最低位开始排序？"
+
+    在连续的排序轮次中，后一轮排序会覆盖前一轮排序的结果。举例来说，如果第一轮排序结果 $a < b$ ，而第二轮排序结果 $a > b$ ，那么第二轮的结果将取代第一轮的结果。由于数字的高位优先级高于低位，我们应该先排序低位再排序高位。
+
+## 11.10.2 &nbsp; 算法特性
+
+相较于计数排序，基数排序适用于数值范围较大的情况，**但前提是数据必须可以表示为固定位数的格式，且位数不能过大**。例如，浮点数不适合使用基数排序，因为其位数 $k$ 过大，可能导致时间复杂度 $O(nk) \gg O(n^2)$ 。
+
+- **时间复杂度 $O(nk)$**：设数据量为 $n$、数据为 $d$ 进制、最大位数为 $k$ ，则对某一位执行计数排序使用 $O(n + d)$ 时间，排序所有 $k$ 位使用 $O((n + d)k)$ 时间。通常情况下，$d$ 和 $k$ 都相对较小，时间复杂度趋向 $O(n)$ 。
+- **空间复杂度 $O(n + d)$、非原地排序**：与计数排序相同，基数排序需要借助长度为 $n$ 和 $d$ 的数组 `res` 和 `counter` 。
+- **稳定排序**：与计数排序相同。

docs/chapter_sorting/selection_sort.md

@@ -0,0 +1,295 @@
+---
+comments: true
+---
+
+# 11.2   选择排序
+
+「选择排序 selection sort」的工作原理非常直接：开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。
+
+设数组的长度为 $n$ ，选择排序的算法流程如图 11-2 所示。
+
+1. 初始状态下，所有元素未排序，即未排序（索引）区间为 $[0, n-1]$ 。
+2. 选取区间 $[0, n-1]$ 中的最小元素，将其与索引 $0$ 处元素交换。完成后，数组前 1 个元素已排序。
+3. 选取区间 $[1, n-1]$ 中的最小元素，将其与索引 $1$ 处元素交换。完成后，数组前 2 个元素已排序。
+4. 以此类推。经过 $n - 1$ 轮选择与交换后，数组前 $n - 1$ 个元素已排序。
+5. 仅剩的一个元素必定是最大元素，无须排序，因此数组排序完成。
+
+=== "<1>"
+    ![选择排序步骤](selection_sort.assets/selection_sort_step1.png)
+
+=== "<2>"
+    ![selection_sort_step2](selection_sort.assets/selection_sort_step2.png)
+
+=== "<3>"
+    ![selection_sort_step3](selection_sort.assets/selection_sort_step3.png)
+
+=== "<4>"
+    ![selection_sort_step4](selection_sort.assets/selection_sort_step4.png)
+
+=== "<5>"
+    ![selection_sort_step5](selection_sort.assets/selection_sort_step5.png)
+
+=== "<6>"
+    ![selection_sort_step6](selection_sort.assets/selection_sort_step6.png)
+
+=== "<7>"
+    ![selection_sort_step7](selection_sort.assets/selection_sort_step7.png)
+
+=== "<8>"
+    ![selection_sort_step8](selection_sort.assets/selection_sort_step8.png)
+
+=== "<9>"
+    ![selection_sort_step9](selection_sort.assets/selection_sort_step9.png)
+
+=== "<10>"
+    ![selection_sort_step10](selection_sort.assets/selection_sort_step10.png)
+
+=== "<11>"
+    ![selection_sort_step11](selection_sort.assets/selection_sort_step11.png)
+
+<p align="center"> 图 11-2 &nbsp; 选择排序步骤 </p>
+
+在代码中，我们用 $k$ 来记录未排序区间内的最小元素。
+
+=== "Python"
+
+    ```python title="selection_sort.py"
+    def selection_sort(nums: list[int]):
+        """选择排序"""
+        n = len(nums)
+        # 外循环：未排序区间为 [i, n-1]
+        for i in range(n - 1):
+            # 内循环：找到未排序区间内的最小元素
+            k = i
+            for j in range(i + 1, n):
+                if nums[j] < nums[k]:
+                    k = j  # 记录最小元素的索引
+            # 将该最小元素与未排序区间的首个元素交换
+            nums[i], nums[k] = nums[k], nums[i]
+    ```
+
+=== "C++"
+
+    ```cpp title="selection_sort.cpp"
+    /* 选择排序 */
+    void selectionSort(vector<int> &nums) {
+        int n = nums.size();
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            swap(nums[i], nums[k]);
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="selection_sort.java"
+    /* 选择排序 */
+    void selectionSort(int[] nums) {
+        int n = nums.length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            int temp = nums[i];
+            nums[i] = nums[k];
+            nums[k] = temp;
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="selection_sort.cs"
+    /* 选择排序 */
+    void SelectionSort(int[] nums) {
+        int n = nums.Length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            (nums[k], nums[i]) = (nums[i], nums[k]);
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="selection_sort.go"
+    /* 选择排序 */
+    func selectionSort(nums []int) {
+        n := len(nums)
+        // 外循环：未排序区间为 [i, n-1]
+        for i := 0; i < n-1; i++ {
+            // 内循环：找到未排序区间内的最小元素
+            k := i
+            for j := i + 1; j < n; j++ {
+                if nums[j] < nums[k] {
+                    // 记录最小元素的索引
+                    k = j
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            nums[i], nums[k] = nums[k], nums[i]
+
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="selection_sort.swift"
+    /* 选择排序 */
+    func selectionSort(nums: inout [Int]) {
+        // 外循环：未排序区间为 [i, n-1]
+        for i in nums.indices.dropLast() {
+            // 内循环：找到未排序区间内的最小元素
+            var k = i
+            for j in nums.indices.dropFirst(i + 1) {
+                if nums[j] < nums[k] {
+                    k = j // 记录最小元素的索引
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            nums.swapAt(i, k)
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="selection_sort.js"
+    /* 选择排序 */
+    function selectionSort(nums) {
+        let n = nums.length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (let i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            let k = i;
+            for (let j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k]) {
+                    k = j; // 记录最小元素的索引
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            [nums[i], nums[k]] = [nums[k], nums[i]];
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="selection_sort.ts"
+    /* 选择排序 */
+    function selectionSort(nums: number[]): void {
+        let n = nums.length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (let i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            let k = i;
+            for (let j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k]) {
+                    k = j; // 记录最小元素的索引
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            [nums[i], nums[k]] = [nums[k], nums[i]];
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="selection_sort.dart"
+    /* 选择排序 */
+    void selectionSort(List<int> nums) {
+      int n = nums.length;
+      // 外循环：未排序区间为 [i, n-1]
+      for (int i = 0; i < n - 1; i++) {
+        // 内循环：找到未排序区间内的最小元素
+        int k = i;
+        for (int j = i + 1; j < n; j++) {
+          if (nums[j] < nums[k]) k = j; // 记录最小元素的索引
+        }
+        // 将该最小元素与未排序区间的首个元素交换
+        int temp = nums[i];
+        nums[i] = nums[k];
+        nums[k] = temp;
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="selection_sort.rs"
+    /* 选择排序 */
+    fn selection_sort(nums: &mut [i32]) {
+        let n = nums.len();
+        // 外循环：未排序区间为 [i, n-1]
+        for i in 0..n-1 {
+            // 内循环：找到未排序区间内的最小元素
+            let mut k = i;
+            for j in i+1..n {
+                if nums[j] < nums[k] {
+                    k = j; // 记录最小元素的索引
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            nums.swap(i, k);
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="selection_sort.c"
+    /* 选择排序 */
+    void selectionSort(int nums[], int n) {
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            int temp = nums[i];
+            nums[i] = nums[k];
+            nums[k] = temp;
+        }
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="selection_sort.zig"
+    [class]{}-[func]{selectionSort}
+    ```
+
+## 11.2.1 &nbsp; 算法特性
+
+- **时间复杂度为 $O(n^2)$、非自适应排序**：外循环共 $n - 1$ 轮，第一轮的未排序区间长度为 $n$ ，最后一轮的未排序区间长度为 $2$ ，即各轮外循环分别包含 $n$、$n - 1$、$\dots$、$3$、$2$ 轮内循环，求和为 $\frac{(n - 1)(n + 2)}{2}$ 。
+- **空间复杂度 $O(1)$、原地排序**：指针 $i$ 和 $j$ 使用常数大小的额外空间。
+- **非稳定排序**：如图 11-3 所示，元素 `nums[i]` 有可能被交换至与其相等的元素的右边，导致两者相对顺序发生改变。
+
+![选择排序非稳定示例](selection_sort.assets/selection_sort_instability.png)
+
+<p align="center"> 图 11-3 &nbsp; 选择排序非稳定示例 </p>

docs/chapter_sorting/sorting_algorithm.md

@@ -0,0 +1,54 @@
+---
+comments: true
+---
+
+# 11.1   排序算法
+
+「排序算法 sorting algorithm」用于对一组数据按照特定顺序进行排列。排序算法有着广泛的应用，因为有序数据通常能够被更有效地查找、分析和处理。
+
+如图 11-1 所示，排序算法中的数据类型可以是整数、浮点数、字符或字符串等。排序的判断规则可根据需求设定，如数字大小、字符 ASCII 码顺序或自定义规则。
+
+![数据类型和判断规则示例](sorting_algorithm.assets/sorting_examples.png)
+
+<p align="center"> 图 11-1 &nbsp; 数据类型和判断规则示例 </p>
+
+## 11.1.1 &nbsp; 评价维度
+
+**运行效率**：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。
+
+**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无须借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
+
+**稳定性**：「稳定排序」在完成排序后，相等元素在数组中的相对顺序不发生改变。
+
+稳定排序是多级排序场景的必要条件。假设我们有一个存储学生信息的表格，第 1 列和第 2 列分别是姓名和年龄。在这种情况下，「非稳定排序」可能导致输入数据的有序性丧失。
+
+```shell
+# 输入数据是按照姓名排序好的
+# (name, age)
+  ('A', 19)
+  ('B', 18)
+  ('C', 21)
+  ('D', 19)
+  ('E', 23)
+
+# 假设使用非稳定排序算法按年龄排序列表，
+# 结果中 ('D', 19) 和 ('A', 19) 的相对位置改变，
+# 输入数据按姓名排序的性质丢失
+  ('B', 18)
+  ('D', 19)
+  ('A', 19)
+  ('C', 21)
+  ('E', 23)
+```
+
+**自适应性**：「自适应排序」的时间复杂度会受输入数据的影响，即最佳、最差、平均时间复杂度并不完全相等。
+
+自适应性需要根据具体情况来评估。如果最差时间复杂度差于平均时间复杂度，说明排序算法在某些数据下性能可能劣化，因此被视为负面属性；而如果最佳时间复杂度优于平均时间复杂度，则被视为正面属性。
+
+**是否基于比较**：「基于比较的排序」依赖于比较运算符（$<$、$=$、$>$）来判断元素的相对顺序，从而排序整个数组，理论最优时间复杂度为 $O(n \log n)$ 。而「非比较排序」不使用比较运算符，时间复杂度可达 $O(n)$ ，但其通用性相对较差。
+
+## 11.1.2 &nbsp; 理想排序算法
+
+**运行快、原地、稳定、正向自适应、通用性好**。显然，迄今为止尚未发现兼具以上所有特性的排序算法。因此，在选择排序算法时，需要根据具体的数据特点和问题需求来决定。
+
+接下来，我们将共同学习各种排序算法，并基于上述评价维度对各个排序算法的优缺点进行分析。

docs/chapter_sorting/summary.md

@@ -0,0 +1,55 @@
+---
+comments: true
+---
+
+# 11.11   小结
+
+### 1.   重点回顾
+
+- 冒泡排序通过交换相邻元素来实现排序。通过添加一个标志位来实现提前返回，我们可以将冒泡排序的最佳时间复杂度优化到 $O(n)$ 。
+- 插入排序每轮将未排序区间内的元素插入到已排序区间的正确位置，从而完成排序。虽然插入排序的时间复杂度为 $O(n^2)$ ，但由于单元操作相对较少，它在小数据量的排序任务中非常受欢迎。
+- 快速排序基于哨兵划分操作实现排序。在哨兵划分中，有可能每次都选取到最差的基准数，导致时间复杂度劣化至 $O(n^2)$ 。引入中位数基准数或随机基准数可以降低这种劣化的概率。尾递归方法可以有效地减少递归深度，将空间复杂度优化到 $O(\log n)$ 。
+- 归并排序包括划分和合并两个阶段，典型地体现了分治策略。在归并排序中，排序数组需要创建辅助数组，空间复杂度为 $O(n)$ ；然而排序链表的空间复杂度可以优化至 $O(1)$ 。
+- 桶排序包含三个步骤：数据分桶、桶内排序和合并结果。它同样体现了分治策略，适用于数据体量很大的情况。桶排序的关键在于对数据进行平均分配。
+- 计数排序是桶排序的一个特例，它通过统计数据出现的次数来实现排序。计数排序适用于数据量大但数据范围有限的情况，并且要求数据能够转换为正整数。
+- 基数排序通过逐位排序来实现数据排序，要求数据能够表示为固定位数的数字。
+- 总的来说，我们希望找到一种排序算法，具有高效率、稳定、原地以及正向自适应性等优点。然而，正如其他数据结构和算法一样，没有一种排序算法能够同时满足所有这些条件。在实际应用中，我们需要根据数据的特性来选择合适的排序算法。
+- 图 11-19 对比了主流排序算法的效率、稳定性、就地性和自适应性等。
+
+![排序算法对比](summary.assets/sorting_algorithms_comparison.png)
+
+<p align="center"> 图 11-19 &nbsp; 排序算法对比 </p>
+
+### 2. &nbsp; Q & A
+
+!!! question "排序算法稳定性在什么情况下是必须的？"
+
+    在现实中，我们有可能是在对象的某个属性上进行排序。例如，学生有姓名和身高两个属性，我们希望实现一个多级排序/
+
+    先按照姓名进行排序，得到 `(A, 180) (B, 185) (C, 170) (D, 170)` ；接下来对身高进行排序。由于排序算法不稳定，我们可能得到 `(D, 170) (C, 170) (A, 180) (B, 185)` 。
+
+    可以发现，学生 D 和 C 的位置发生了交换，姓名的有序性被破坏了，而这是我们不希望看到的。
+
+!!! question "哨兵划分中“从右往左查找”与“从左往右查找”的顺序可以交换吗？"
+
+    不行，当我们以最左端元素为基准数时，必须先“从右往左查找”再“从左往右查找”。这个结论有些反直觉，我们来剖析一下原因。
+
+    哨兵划分 `partition()` 的最后一步是交换 `nums[left]` 和 `nums[i]` 。完成交换后，基准数左边的元素都 `<=` 基准数，**这就要求最后一步交换前 `nums[left] >= nums[i]` 必须成立**。假设我们先“从左往右查找”，那么如果找不到比基准数更小的元素，**则会在 `i == j` 时跳出循环，此时可能 `nums[j] == nums[i] > nums[left]`**。也就是说，此时最后一步交换操作会把一个比基准数更大的元素交换至数组最左端，导致哨兵划分失败。
+
+    举个例子，给定数组 `[0, 0, 0, 0, 1]` ，如果先“从左向右查找”，哨兵划分后数组为 `[1, 0, 0, 0, 0]` ，这个结果是不正确的。
+
+    再深入思考一下，如果我们选择 `nums[right]` 为基准数，那么正好反过来，必须先“从左往右查找”。
+
+!!! question "关于尾递归优化，为什么选短的数组能保证递归深度不超过 $\log n$ ？"
+
+    递归深度就是当前未返回的递归方法的数量。每轮哨兵划分我们将原数组划分为两个子数组。在尾递归优化后，向下递归的子数组长度最大为原数组的一半长度。假设最差情况，一直为一半长度，那么最终的递归深度就是 $\log n$ 。
+    
+    回顾原始的快速排序，我们有可能会连续地递归长度较大的数组，最差情况下为 $n$、$n - 1$、$\dots$、$2$、$1$ ，递归深度为 $n$ 。尾递归优化可以避免这种情况的出现。
+
+!!! question "当数组中所有元素都相等时，快速排序的时间复杂度是 $O(n^2)$ 吗？该如何处理这种退化情况？"
+
+    是的。这种情况可以考虑通过哨兵划分将数组划分为三个部分：小于、等于、大于基准数。仅向下递归小于和大于的两部分。在该方法下，输入元素全部相等的数组，仅一轮哨兵划分即可完成排序。
+
+!!! question "桶排序的最差时间复杂度为什么是 $O(n^2)$ ？"
+
+    最差情况下，所有元素被分至同一个桶中。如果我们采用一个 $O(n^2)$ 算法来排序这些元素，则时间复杂度为 $O(n^2)$ 。

docs/chapter_stack_and_queue/index.md

@@ -0,0 +1,25 @@
+---
+comments: true
+icon: material/stack-overflow
+---
+
+# 第 5 章   栈与队列
+
+<div class="center-table" markdown>
+
+![栈与队列](../assets/covers/chapter_stack_and_queue.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    栈如同叠猫猫，而队列就像猫猫排队。
+    
+    两者分别代表着先入后出和先入先出的逻辑关系。
+
+## 本章内容
+
+- [5.1 &nbsp; 栈](https://www.hello-algo.com/chapter_stack_and_queue/stack/)
+- [5.2 &nbsp; 队列](https://www.hello-algo.com/chapter_stack_and_queue/queue/)
+- [5.3 &nbsp; 双向队列](https://www.hello-algo.com/chapter_stack_and_queue/deque/)
+- [5.4 &nbsp; 小结](https://www.hello-algo.com/chapter_stack_and_queue/summary/)

docs/chapter_stack_and_queue/summary.md

@@ -0,0 +1,35 @@
+---
+comments: true
+---
+
+# 5.4   小结
+
+### 1.   重点回顾
+
+- 栈是一种遵循先入后出原则的数据结构，可通过数组或链表来实现。
+- 从时间效率角度看，栈的数组实现具有较高的平均效率，但在扩容过程中，单次入栈操作的时间复杂度会劣化至 $O(n)$ 。相比之下，基于链表实现的栈具有更为稳定的效率表现。
+- 在空间效率方面，栈的数组实现可能导致一定程度的空间浪费。但需要注意的是，链表节点所占用的内存空间比数组元素更大。
+- 队列是一种遵循先入先出原则的数据结构，同样可以通过数组或链表来实现。在时间效率和空间效率的对比上，队列的结论与前述栈的结论相似。
+- 双向队列是一种具有更高自由度的队列，它允许在两端进行元素的添加和删除操作。
+
+### 2.   Q & A
+
+!!! question "浏览器的前进后退是否是双向链表实现？"
+
+    浏览器的前进后退功能本质上是“栈”的体现。当用户访问一个新页面时，该页面会被添加到栈顶；当用户点击后退按钮时，该页面会从栈顶弹出。使用双向队列可以方便实现一些额外操作，这个在双向队列章节有提到。
+
+!!! question "在出栈后，是否需要释放出栈节点的内存？"
+
+    如果后续仍需要使用弹出节点，则不需要释放内存。若之后不需要用到，`Java` 和 `Python` 等语言拥有自动垃圾回收机制，因此不需要手动释放内存；在 `C` 和 `C++` 中需要手动释放内存。
+
+!!! question "双向队列像是两个栈拼接在了一起，它的用途是什么？"
+
+    双向队列就像是栈和队列的组合，或者是两个栈拼在了一起。它表现的是栈 + 队列的逻辑，因此可以实现栈与队列的所有应用，并且更加灵活。
+
+!!! question "撤销（undo）和反撤销（redo）具体是如何实现的？"
+
+    使用两个堆栈，栈 `A` 用于撤销，栈 `B` 用于反撤销。
+
+    1. 每当用户执行一个操作，将这个操作压入栈 `A` ，并清空栈 `B` 。
+    2. 当用户执行“撤销”时，从栈 `A` 中弹出最近的操作，并将其压入栈 `B` 。
+    3. 当用户执行“反撤销”时，从栈 `B` 中弹出最近的操作，并将其压入栈 `A` 。

docs/chapter_tree/binary_tree.md

@@ -0,0 +1,626 @@
+---
+comments: true
+---
+
+# 7.1   二叉树
+
+「二叉树 binary tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含：值、左子节点引用、右子节点引用。
+
+=== "Python"
+
+    ```python title=""
+    class TreeNode:
+        """二叉树节点类"""
+        def __init__(self, val: int):
+            self.val: int = val                # 节点值
+            self.left: TreeNode | None = None  # 左子节点引用
+            self.right: TreeNode | None = None # 右子节点引用
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 二叉树节点结构体 */
+    struct TreeNode {
+        int val;          // 节点值
+        TreeNode *left;   // 左子节点指针
+        TreeNode *right;  // 右子节点指针
+        TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    };
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+        int val;         // 节点值
+        TreeNode left;   // 左子节点引用
+        TreeNode right;  // 右子节点引用
+        TreeNode(int x) { val = x; }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+        int val;          // 节点值
+        TreeNode? left;   // 左子节点引用
+        TreeNode? right;  // 右子节点引用
+        TreeNode(int x) { val = x; }
+    }
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 二叉树节点结构体 */
+    type TreeNode struct {
+        Val   int
+        Left  *TreeNode
+        Right *TreeNode
+    }
+    /* 构造方法 */
+    func NewTreeNode(v int) *TreeNode {
+        return &TreeNode{
+            Left:  nil, // 左子节点指针
+            Right: nil, // 右子节点指针
+            Val:   v,   // 节点值
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+        var val: Int // 节点值
+        var left: TreeNode? // 左子节点引用
+        var right: TreeNode? // 右子节点引用
+
+        init(x: Int) {
+            val = x
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+        val; // 节点值
+        left; // 左子节点指针
+        right; // 右子节点指针
+        constructor(val, left, right) {
+            this.val = val === undefined ? 0 : val;
+            this.left = left === undefined ? null : left;
+            this.right = right === undefined ? null : right;
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+        val: number;
+        left: TreeNode | null;
+        right: TreeNode | null;
+    
+        constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+            this.val = val === undefined ? 0 : val; // 节点值
+            this.left = left === undefined ? null : left; // 左子节点引用
+            this.right = right === undefined ? null : right; // 右子节点引用
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+      int val;         // 节点值
+      TreeNode? left;  // 左子节点引用
+      TreeNode? right; // 右子节点引用
+      TreeNode(this.val, [this.left, this.right]);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    use std::rc::Rc;
+    use std::cell::RefCell;
+
+    /* 二叉树节点结构体 */
+    struct TreeNode {
+        val: i32,                               // 节点值
+        left: Option<Rc<RefCell<TreeNode>>>,    // 左子节点引用
+        right: Option<Rc<RefCell<TreeNode>>>,   // 右子节点引用
+    }
+
+    impl TreeNode {
+        /* 构造方法 */
+        fn new(val: i32) -> Rc<RefCell<Self>> {
+            Rc::new(RefCell::new(Self {
+                val,
+                left: None,
+                right: None
+            }))
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* 二叉树节点结构体 */
+    struct TreeNode {
+        int val;                // 节点值
+        int height;             // 节点高度
+        struct TreeNode *left;  // 左子节点指针
+        struct TreeNode *right; // 右子节点指针
+    };
+
+    typedef struct TreeNode TreeNode;
+
+    /* 构造函数 */
+    TreeNode *newTreeNode(int val) {
+        TreeNode *node;
+
+        node = (TreeNode *)malloc(sizeof(TreeNode));
+        node->val = val;
+        node->height = 0;
+        node->left = NULL;
+        node->right = NULL;
+        return node;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+
+    ```
+
+每个节点都有两个引用（指针），分别指向「左子节点 left-child node」和「右子节点 right-child node」，该节点被称为这两个子节点的「父节点 parent node」。当给定一个二叉树的节点时，我们将该节点的左子节点及其以下节点形成的树称为该节点的「左子树 left subtree」，同理可得「右子树 right subtree」。
+
+**在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树**。如图 7-1 所示，如果将“节点 2”视为父节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，右子树是“节点 5 及其以下节点形成的树”。
+
+![父节点、子节点、子树](binary_tree.assets/binary_tree_definition.png)
+
+<p align="center"> 图 7-1 &nbsp; 父节点、子节点、子树 </p>
+
+## 7.1.1 &nbsp; 二叉树常见术语
+
+二叉树的常用术语如图 7-2 所示。
+
+- 「根节点 root node」：位于二叉树顶层的节点，没有父节点。
+- 「叶节点 leaf node」：没有子节点的节点，其两个指针均指向 $\text{None}$ 。
+- 「边 edge」：连接两个节点的线段，即节点引用（指针）。
+- 节点所在的「层 level」：从顶至底递增，根节点所在层为 1 。
+- 节点的「度 degree」：节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2 。
+- 二叉树的「高度 height」：从根节点到最远叶节点所经过的边的数量。
+- 节点的「深度 depth」：从根节点到该节点所经过的边的数量。
+- 节点的「高度 height」：从最远叶节点到该节点所经过的边的数量。
+
+![二叉树的常用术语](binary_tree.assets/binary_tree_terminology.png)
+
+<p align="center"> 图 7-2 &nbsp; 二叉树的常用术语 </p>
+
+!!! tip
+
+    请注意，我们通常将“高度”和“深度”定义为“走过边的数量”，但有些题目或教材可能会将其定义为“走过节点的数量”。在这种情况下，高度和深度都需要加 1 。
+
+## 7.1.2 &nbsp; 二叉树基本操作
+
+### 1. &nbsp; 初始化二叉树
+
+与链表类似，首先初始化节点，然后构建引用（指针）。
+
+=== "Python"
+
+    ```python title="binary_tree.py"
+    # 初始化二叉树
+    # 初始化节点
+    n1 = TreeNode(val=1)
+    n2 = TreeNode(val=2)
+    n3 = TreeNode(val=3)
+    n4 = TreeNode(val=4)
+    n5 = TreeNode(val=5)
+    # 构建引用指向（即指针）
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_tree.cpp"
+    /* 初始化二叉树 */
+    // 初始化节点
+    TreeNode* n1 = new TreeNode(1);
+    TreeNode* n2 = new TreeNode(2);
+    TreeNode* n3 = new TreeNode(3);
+    TreeNode* n4 = new TreeNode(4);
+    TreeNode* n5 = new TreeNode(5);
+    // 构建引用指向（即指针）
+    n1->left = n2;
+    n1->right = n3;
+    n2->left = n4;
+    n2->right = n5;
+    ```
+
+=== "Java"
+
+    ```java title="binary_tree.java"
+    // 初始化节点
+    TreeNode n1 = new TreeNode(1);
+    TreeNode n2 = new TreeNode(2);
+    TreeNode n3 = new TreeNode(3);
+    TreeNode n4 = new TreeNode(4);
+    TreeNode n5 = new TreeNode(5);
+    // 构建引用指向（即指针）
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_tree.cs"
+    /* 初始化二叉树 */
+    // 初始化节点
+    TreeNode n1 = new(1);
+    TreeNode n2 = new(2);
+    TreeNode n3 = new(3);
+    TreeNode n4 = new(4);
+    TreeNode n5 = new(5);
+    // 构建引用指向（即指针）
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree.go"
+    /* 初始化二叉树 */
+    // 初始化节点
+    n1 := NewTreeNode(1)
+    n2 := NewTreeNode(2)
+    n3 := NewTreeNode(3)
+    n4 := NewTreeNode(4)
+    n5 := NewTreeNode(5)
+    // 构建引用指向（即指针）
+    n1.Left = n2
+    n1.Right = n3
+    n2.Left = n4
+    n2.Right = n5
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_tree.swift"
+    // 初始化节点
+    let n1 = TreeNode(x: 1)
+    let n2 = TreeNode(x: 2)
+    let n3 = TreeNode(x: 3)
+    let n4 = TreeNode(x: 4)
+    let n5 = TreeNode(x: 5)
+    // 构建引用指向（即指针）
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_tree.js"
+    /* 初始化二叉树 */
+    // 初始化节点
+    let n1 = new TreeNode(1),
+        n2 = new TreeNode(2),
+        n3 = new TreeNode(3),
+        n4 = new TreeNode(4),
+        n5 = new TreeNode(5);
+    // 构建引用指向（即指针）
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_tree.ts"
+    /* 初始化二叉树 */
+    // 初始化节点
+    let n1 = new TreeNode(1),
+        n2 = new TreeNode(2),
+        n3 = new TreeNode(3),
+        n4 = new TreeNode(4),
+        n5 = new TreeNode(5);
+    // 构建引用指向（即指针）
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_tree.dart"
+    /* 初始化二叉树 */
+    // 初始化节点
+    TreeNode n1 = new TreeNode(1);
+    TreeNode n2 = new TreeNode(2);
+    TreeNode n3 = new TreeNode(3);
+    TreeNode n4 = new TreeNode(4);
+    TreeNode n5 = new TreeNode(5);
+    // 构建引用指向（即指针）
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_tree.rs"
+    // 初始化节点
+    let n1 = TreeNode::new(1);
+    let n2 = TreeNode::new(2);
+    let n3 = TreeNode::new(3);
+    let n4 = TreeNode::new(4);
+    let n5 = TreeNode::new(5);
+    // 构建引用指向（即指针）
+    n1.borrow_mut().left = Some(n2.clone());
+    n1.borrow_mut().right = Some(n3);
+    n2.borrow_mut().left = Some(n4);
+    n2.borrow_mut().right = Some(n5);
+    ```
+
+=== "C"
+
+    ```c title="binary_tree.c"
+    /* 初始化二叉树 */
+    // 初始化节点
+    TreeNode *n1 = newTreeNode(1);
+    TreeNode *n2 = newTreeNode(2);
+    TreeNode *n3 = newTreeNode(3);
+    TreeNode *n4 = newTreeNode(4);
+    TreeNode *n5 = newTreeNode(5);
+    // 构建引用指向（即指针）
+    n1->left = n2;
+    n1->right = n3;
+    n2->left = n4;
+    n2->right = n5;
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_tree.zig"
+
+    ```
+
+### 2. &nbsp; 插入与删除节点
+
+与链表类似，在二叉树中插入与删除节点可以通过修改指针来实现。图 7-3 给出了一个示例。
+
+![在二叉树中插入与删除节点](binary_tree.assets/binary_tree_add_remove.png)
+
+<p align="center"> 图 7-3 &nbsp; 在二叉树中插入与删除节点 </p>
+
+=== "Python"
+
+    ```python title="binary_tree.py"
+    # 插入与删除节点
+    p = TreeNode(0)
+    # 在 n1 -> n2 中间插入节点 P
+    n1.left = p
+    p.left = n2
+    # 删除节点 P
+    n1.left = n2
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_tree.cpp"
+    /* 插入与删除节点 */
+    TreeNode* P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1->left = P;
+    P->left = n2;
+    // 删除节点 P
+    n1->left = n2;
+    ```
+
+=== "Java"
+
+    ```java title="binary_tree.java"
+    TreeNode P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P;
+    P.left = n2;
+    // 删除节点 P
+    n1.left = n2;
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_tree.cs"
+    /* 插入与删除节点 */
+    TreeNode P = new(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P;
+    P.left = n2;
+    // 删除节点 P
+    n1.left = n2;
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree.go"
+    /* 插入与删除节点 */
+    // 在 n1 -> n2 中间插入节点 P
+    p := NewTreeNode(0)
+    n1.Left = p
+    p.Left = n2
+    // 删除节点 P
+    n1.Left = n2
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_tree.swift"
+    let P = TreeNode(x: 0)
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P
+    P.left = n2
+    // 删除节点 P
+    n1.left = n2
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_tree.js"
+    /* 插入与删除节点 */
+    let P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P;
+    P.left = n2;
+    // 删除节点 P
+    n1.left = n2;
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_tree.ts"
+    /* 插入与删除节点 */
+    const P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P;
+    P.left = n2;
+    // 删除节点 P
+    n1.left = n2;
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_tree.dart"
+    /* 插入与删除节点 */
+    TreeNode P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P;
+    P.left = n2;
+    // 删除节点 P
+    n1.left = n2;
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_tree.rs"
+    let p = TreeNode::new(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1.borrow_mut().left = Some(p.clone());
+    p.borrow_mut().left = Some(n2.clone());
+    // 删除节点 p
+    n1.borrow_mut().left = Some(n2);
+    ```
+
+=== "C"
+
+    ```c title="binary_tree.c"
+    /* 插入与删除节点 */
+    TreeNode *P = newTreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1->left = P;
+    P->left = n2;
+    // 删除节点 P
+    n1->left = n2;
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_tree.zig"
+
+    ```
+
+!!! note
+
+    需要注意的是，插入节点可能会改变二叉树的原有逻辑结构，而删除节点通常意味着删除该节点及其所有子树。因此，在二叉树中，插入与删除操作通常是由一套操作配合完成的，以实现有实际意义的操作。
+
+## 7.1.3 &nbsp; 常见二叉树类型
+
+### 1. &nbsp; 完美二叉树
+
+「完美二叉树 perfect binary tree」所有层的节点都被完全填满。在完美二叉树中，叶节点的度为 $0$ ，其余所有节点的度都为 $2$ ；若树高度为 $h$ ，则节点总数为 $2^{h+1} - 1$ ，呈现标准的指数级关系，反映了自然界中常见的细胞分裂现象。
+
+!!! tip
+
+    请注意，在中文社区中，完美二叉树常被称为「满二叉树」。
+
+![完美二叉树](binary_tree.assets/perfect_binary_tree.png)
+
+<p align="center"> 图 7-4 &nbsp; 完美二叉树 </p>
+
+### 2. &nbsp; 完全二叉树
+
+如图 7-5 所示，「完全二叉树 complete binary tree」只有最底层的节点未被填满，且最底层节点尽量靠左填充。
+
+![完全二叉树](binary_tree.assets/complete_binary_tree.png)
+
+<p align="center"> 图 7-5 &nbsp; 完全二叉树 </p>
+
+### 3. &nbsp; 完满二叉树
+
+如图 7-6 所示，「完满二叉树 full binary tree」除了叶节点之外，其余所有节点都有两个子节点。
+
+![完满二叉树](binary_tree.assets/full_binary_tree.png)
+
+<p align="center"> 图 7-6 &nbsp; 完满二叉树 </p>
+
+### 4. &nbsp; 平衡二叉树
+
+如图 7-7 所示，「平衡二叉树 balanced binary tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。
+
+![平衡二叉树](binary_tree.assets/balanced_binary_tree.png)
+
+<p align="center"> 图 7-7 &nbsp; 平衡二叉树 </p>
+
+## 7.1.4 &nbsp; 二叉树的退化
+
+图 7-8 展示了二叉树的理想与退化状态。当二叉树的每层节点都被填满时，达到“完美二叉树”；而当所有节点都偏向一侧时，二叉树退化为“链表”。
+
+- 完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势。
+- 链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 $O(n)$ 。
+
+![二叉树的最佳与最差结构](binary_tree.assets/binary_tree_best_worst_cases.png)
+
+<p align="center"> 图 7-8 &nbsp; 二叉树的最佳与最差结构 </p>
+
+如表 7-1 所示，在最佳和最差结构下，二叉树的叶节点数量、节点总数、高度等达到极大或极小值。
+
+<p align="center"> 表 7-1 &nbsp; 二叉树的最佳与最差情况 </p>
+
+<div class="center-table" markdown>
+
+|                               | 完美二叉树 | 链表         |
+| ----------------------------- | ---------- | ---------- |
+| 第 $i$ 层的节点数量    | $2^{i-1}$          | $1$     |
+| 高度 $h$ 树的叶节点数量 | $2^h$          | $1$     |
+| 高度 $h$ 树的节点总数 | $2^{h+1} - 1$      | $h + 1$     |
+| 节点总数 $n$ 树的高度 | $\log_2 (n+1) - 1$ | $n - 1$     |
+
+</div>

docs/chapter_tree/binary_tree_traversal.md

@@ -0,0 +1,804 @@
+---
+comments: true
+---
+
+# 7.2   二叉树遍历
+
+从物理结构的角度来看，树是一种基于链表的数据结构，因此其遍历方式是通过指针逐个访问节点。然而，树是一种非线性数据结构，这使得遍历树比遍历链表更加复杂，需要借助搜索算法来实现。
+
+二叉树常见的遍历方式包括层序遍历、前序遍历、中序遍历和后序遍历等。
+
+## 7.2.1   层序遍历
+
+如图 7-9 所示，「层序遍历 level-order traversal」从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。
+
+层序遍历本质上属于「广度优先遍历 breadth-first traversal」，它体现了一种“一圈一圈向外扩展”的逐层遍历方式。
+
+![二叉树的层序遍历](binary_tree_traversal.assets/binary_tree_bfs.png)
+
+<p align="center"> 图 7-9 &nbsp; 二叉树的层序遍历 </p>
+
+### 1. &nbsp; 代码实现
+
+广度优先遍历通常借助“队列”来实现。队列遵循“先进先出”的规则，而广度优先遍历则遵循“逐层推进”的规则，两者背后的思想是一致的。
+
+=== "Python"
+
+    ```python title="binary_tree_bfs.py"
+    def level_order(root: TreeNode | None) -> list[int]:
+        """层序遍历"""
+        # 初始化队列，加入根节点
+        queue: deque[TreeNode] = deque()
+        queue.append(root)
+        # 初始化一个列表，用于保存遍历序列
+        res = []
+        while queue:
+            node: TreeNode = queue.popleft()  # 队列出队
+            res.append(node.val)  # 保存节点值
+            if node.left is not None:
+                queue.append(node.left)  # 左子节点入队
+            if node.right is not None:
+                queue.append(node.right)  # 右子节点入队
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_tree_bfs.cpp"
+    /* 层序遍历 */
+    vector<int> levelOrder(TreeNode *root) {
+        // 初始化队列，加入根节点
+        queue<TreeNode *> queue;
+        queue.push(root);
+        // 初始化一个列表，用于保存遍历序列
+        vector<int> vec;
+        while (!queue.empty()) {
+            TreeNode *node = queue.front();
+            queue.pop();              // 队列出队
+            vec.push_back(node->val); // 保存节点值
+            if (node->left != nullptr)
+                queue.push(node->left); // 左子节点入队
+            if (node->right != nullptr)
+                queue.push(node->right); // 右子节点入队
+        }
+        return vec;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_tree_bfs.java"
+    /* 层序遍历 */
+    List<Integer> levelOrder(TreeNode root) {
+        // 初始化队列，加入根节点
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        // 初始化一个列表，用于保存遍历序列
+        List<Integer> list = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll(); // 队列出队
+            list.add(node.val);           // 保存节点值
+            if (node.left != null)
+                queue.offer(node.left);   // 左子节点入队
+            if (node.right != null)
+                queue.offer(node.right);  // 右子节点入队
+        }
+        return list;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_tree_bfs.cs"
+    /* 层序遍历 */
+    List<int> LevelOrder(TreeNode root) {
+        // 初始化队列，加入根节点
+        Queue<TreeNode> queue = new();
+        queue.Enqueue(root);
+        // 初始化一个列表，用于保存遍历序列
+        List<int> list = new();
+        while (queue.Count != 0) {
+            TreeNode node = queue.Dequeue(); // 队列出队
+            list.Add(node.val);              // 保存节点值
+            if (node.left != null)
+                queue.Enqueue(node.left);    // 左子节点入队
+            if (node.right != null)
+                queue.Enqueue(node.right);   // 右子节点入队
+        }
+        return list;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree_bfs.go"
+    /* 层序遍历 */
+    func levelOrder(root *TreeNode) []any {
+        // 初始化队列，加入根节点
+        queue := list.New()
+        queue.PushBack(root)
+        // 初始化一个切片，用于保存遍历序列
+        nums := make([]any, 0)
+        for queue.Len() > 0 {
+            // 队列出队
+            node := queue.Remove(queue.Front()).(*TreeNode)
+            // 保存节点值
+            nums = append(nums, node.Val)
+            if node.Left != nil {
+                // 左子节点入队
+                queue.PushBack(node.Left)
+            }
+            if node.Right != nil {
+                // 右子节点入队
+                queue.PushBack(node.Right)
+            }
+        }
+        return nums
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_tree_bfs.swift"
+    /* 层序遍历 */
+    func levelOrder(root: TreeNode) -> [Int] {
+        // 初始化队列，加入根节点
+        var queue: [TreeNode] = [root]
+        // 初始化一个列表，用于保存遍历序列
+        var list: [Int] = []
+        while !queue.isEmpty {
+            let node = queue.removeFirst() // 队列出队
+            list.append(node.val) // 保存节点值
+            if let left = node.left {
+                queue.append(left) // 左子节点入队
+            }
+            if let right = node.right {
+                queue.append(right) // 右子节点入队
+            }
+        }
+        return list
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_tree_bfs.js"
+    /* 层序遍历 */
+    function levelOrder(root) {
+        // 初始化队列，加入根节点
+        const queue = [root];
+        // 初始化一个列表，用于保存遍历序列
+        const list = [];
+        while (queue.length) {
+            let node = queue.shift(); // 队列出队
+            list.push(node.val); // 保存节点值
+            if (node.left) queue.push(node.left); // 左子节点入队
+            if (node.right) queue.push(node.right); // 右子节点入队
+        }
+        return list;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_tree_bfs.ts"
+    /* 层序遍历 */
+    function levelOrder(root: TreeNode | null): number[] {
+        // 初始化队列，加入根节点
+        const queue = [root];
+        // 初始化一个列表，用于保存遍历序列
+        const list: number[] = [];
+        while (queue.length) {
+            let node = queue.shift() as TreeNode; // 队列出队
+            list.push(node.val); // 保存节点值
+            if (node.left) {
+                queue.push(node.left); // 左子节点入队
+            }
+            if (node.right) {
+                queue.push(node.right); // 右子节点入队
+            }
+        }
+        return list;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_tree_bfs.dart"
+    /* 层序遍历 */
+    List<int> levelOrder(TreeNode? root) {
+      // 初始化队列，加入根节点
+      Queue<TreeNode?> queue = Queue();
+      queue.add(root);
+      // 初始化一个列表，用于保存遍历序列
+      List<int> res = [];
+      while (queue.isNotEmpty) {
+        TreeNode? node = queue.removeFirst(); // 队列出队
+        res.add(node!.val); // 保存节点值
+        if (node.left != null) queue.add(node.left); // 左子节点入队
+        if (node.right != null) queue.add(node.right); // 右子节点入队
+      }
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_tree_bfs.rs"
+    /* 层序遍历 */
+    fn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {
+        // 初始化队列，加入根结点
+        let mut que = VecDeque::new();
+        que.push_back(Rc::clone(&root));
+        // 初始化一个列表，用于保存遍历序列
+        let mut vec = Vec::new();
+
+        while let Some(node) = que.pop_front() {                 // 队列出队
+            vec.push(node.borrow().val);                         // 保存结点值
+            if let Some(left) = node.borrow().left.as_ref() {
+                que.push_back(Rc::clone(left));                  // 左子结点入队
+            }
+            if let Some(right) = node.borrow().right.as_ref() {
+                que.push_back(Rc::clone(right));                 // 右子结点入队
+            };
+        }
+        vec
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_tree_bfs.c"
+    /* 层序遍历 */
+    int *levelOrder(TreeNode *root, int *size) {
+        /* 辅助队列 */
+        int front, rear;
+        int index, *arr;
+        TreeNode *node;
+        TreeNode **queue;
+
+        /* 辅助队列 */
+        queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_NODE_SIZE);
+        // 队列指针
+        front = 0, rear = 0;
+        // 加入根节点
+        queue[rear++] = root;
+        // 初始化一个列表，用于保存遍历序列
+        /* 辅助数组 */
+        arr = (int *)malloc(sizeof(int) * MAX_NODE_SIZE);
+        // 数组指针
+        index = 0;
+        while (front < rear) {
+            // 队列出队
+            node = queue[front++];
+            // 保存节点值
+            arr[index++] = node->val;
+            if (node->left != NULL) {
+                // 左子节点入队
+                queue[rear++] = node->left;
+            }
+            if (node->right != NULL) {
+                // 右子节点入队
+                queue[rear++] = node->right;
+            }
+        }
+        // 更新数组长度的值
+        *size = index;
+        arr = realloc(arr, sizeof(int) * (*size));
+
+        // 释放辅助数组空间
+        free(queue);
+        return arr;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_tree_bfs.zig"
+    // 层序遍历
+    fn levelOrder(comptime T: type, mem_allocator: std.mem.Allocator, root: *inc.TreeNode(T)) !std.ArrayList(T) {
+        // 初始化队列，加入根节点
+        const L = std.TailQueue(*inc.TreeNode(T));
+        var queue = L{};
+        var root_node = try mem_allocator.create(L.Node);
+        root_node.data = root;
+        queue.append(root_node); 
+        // 初始化一个列表，用于保存遍历序列
+        var list = std.ArrayList(T).init(std.heap.page_allocator);
+        while (queue.len > 0) {
+            var queue_node = queue.popFirst().?;    // 队列出队
+            var node = queue_node.data;
+            try list.append(node.val);              // 保存节点值
+            if (node.left != null) {
+                var tmp_node = try mem_allocator.create(L.Node);
+                tmp_node.data = node.left.?;
+                queue.append(tmp_node);             // 左子节点入队
+            }
+            if (node.right != null) {
+                var tmp_node = try mem_allocator.create(L.Node);
+                tmp_node.data = node.right.?;
+                queue.append(tmp_node);             // 右子节点入队
+            }        
+        }
+        return list;
+    }
+    ```
+
+### 2. &nbsp; 复杂度分析
+
+- **时间复杂度 $O(n)$** ：所有节点被访问一次，使用 $O(n)$ 时间，其中 $n$ 为节点数量。
+- **空间复杂度 $O(n)$** ：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在 $(n + 1) / 2$ 个节点，占用 $O(n)$ 空间。
+
+## 7.2.2 &nbsp; 前序、中序、后序遍历
+
+相应地，前序、中序和后序遍历都属于「深度优先遍历 depth-first traversal」，它体现了一种“先走到尽头，再回溯继续”的遍历方式。
+
+图 7-10 展示了对二叉树进行深度优先遍历的工作原理。**深度优先遍历就像是绕着整个二叉树的外围“走”一圈**，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。
+
+![二叉搜索树的前、中、后序遍历](binary_tree_traversal.assets/binary_tree_dfs.png)
+
+<p align="center"> 图 7-10 &nbsp; 二叉搜索树的前、中、后序遍历 </p>
+
+### 1. &nbsp; 代码实现
+
+深度优先搜索通常基于递归实现：
+
+=== "Python"
+
+    ```python title="binary_tree_dfs.py"
+    def pre_order(root: TreeNode | None):
+        """前序遍历"""
+        if root is None:
+            return
+        # 访问优先级：根节点 -> 左子树 -> 右子树
+        res.append(root.val)
+        pre_order(root=root.left)
+        pre_order(root=root.right)
+
+    def in_order(root: TreeNode | None):
+        """中序遍历"""
+        if root is None:
+            return
+        # 访问优先级：左子树 -> 根节点 -> 右子树
+        in_order(root=root.left)
+        res.append(root.val)
+        in_order(root=root.right)
+
+    def post_order(root: TreeNode | None):
+        """后序遍历"""
+        if root is None:
+            return
+        # 访问优先级：左子树 -> 右子树 -> 根节点
+        post_order(root=root.left)
+        post_order(root=root.right)
+        res.append(root.val)
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_tree_dfs.cpp"
+    /* 前序遍历 */
+    void preOrder(TreeNode *root) {
+        if (root == nullptr)
+            return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        vec.push_back(root->val);
+        preOrder(root->left);
+        preOrder(root->right);
+    }
+
+    /* 中序遍历 */
+    void inOrder(TreeNode *root) {
+        if (root == nullptr)
+            return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root->left);
+        vec.push_back(root->val);
+        inOrder(root->right);
+    }
+
+    /* 后序遍历 */
+    void postOrder(TreeNode *root) {
+        if (root == nullptr)
+            return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root->left);
+        postOrder(root->right);
+        vec.push_back(root->val);
+    }
+    ```
+
+=== "Java"
+
+    ```java title="binary_tree_dfs.java"
+    /* 前序遍历 */
+    void preOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.add(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
+
+    /* 中序遍历 */
+    void inOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.add(root.val);
+        inOrder(root.right);
+    }
+
+    /* 后序遍历 */
+    void postOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root.left);
+        postOrder(root.right);
+        list.add(root.val);
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_tree_dfs.cs"
+    /* 前序遍历 */
+    void PreOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.Add(root.val);
+        PreOrder(root.left);
+        PreOrder(root.right);
+    }
+
+    /* 中序遍历 */
+    void InOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        InOrder(root.left);
+        list.Add(root.val);
+        InOrder(root.right);
+    }
+
+    /* 后序遍历 */
+    void PostOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        PostOrder(root.left);
+        PostOrder(root.right);
+        list.Add(root.val);
+    }
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree_dfs.go"
+    /* 前序遍历 */
+    func preOrder(node *TreeNode) {
+        if node == nil {
+            return
+        }
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        nums = append(nums, node.Val)
+        preOrder(node.Left)
+        preOrder(node.Right)
+    }
+
+    /* 中序遍历 */
+    func inOrder(node *TreeNode) {
+        if node == nil {
+            return
+        }
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(node.Left)
+        nums = append(nums, node.Val)
+        inOrder(node.Right)
+    }
+
+    /* 后序遍历 */
+    func postOrder(node *TreeNode) {
+        if node == nil {
+            return
+        }
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(node.Left)
+        postOrder(node.Right)
+        nums = append(nums, node.Val)
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_tree_dfs.swift"
+    /* 前序遍历 */
+    func preOrder(root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.append(root.val)
+        preOrder(root: root.left)
+        preOrder(root: root.right)
+    }
+
+    /* 中序遍历 */
+    func inOrder(root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root: root.left)
+        list.append(root.val)
+        inOrder(root: root.right)
+    }
+
+    /* 后序遍历 */
+    func postOrder(root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root: root.left)
+        postOrder(root: root.right)
+        list.append(root.val)
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_tree_dfs.js"
+    /* 前序遍历 */
+    function preOrder(root) {
+        if (root === null) return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.push(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
+
+    /* 中序遍历 */
+    function inOrder(root) {
+        if (root === null) return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.push(root.val);
+        inOrder(root.right);
+    }
+
+    /* 后序遍历 */
+    function postOrder(root) {
+        if (root === null) return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root.left);
+        postOrder(root.right);
+        list.push(root.val);
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_tree_dfs.ts"
+    /* 前序遍历 */
+    function preOrder(root: TreeNode | null): void {
+        if (root === null) {
+            return;
+        }
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.push(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
+
+    /* 中序遍历 */
+    function inOrder(root: TreeNode | null): void {
+        if (root === null) {
+            return;
+        }
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.push(root.val);
+        inOrder(root.right);
+    }
+
+    /* 后序遍历 */
+    function postOrder(root: TreeNode | null): void {
+        if (root === null) {
+            return;
+        }
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root.left);
+        postOrder(root.right);
+        list.push(root.val);
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_tree_dfs.dart"
+    /* 前序遍历 */
+    void preOrder(TreeNode? node) {
+      if (node == null) return;
+      // 访问优先级：根节点 -> 左子树 -> 右子树
+      list.add(node.val);
+      preOrder(node.left);
+      preOrder(node.right);
+    }
+
+    /* 中序遍历 */
+    void inOrder(TreeNode? node) {
+      if (node == null) return;
+      // 访问优先级：左子树 -> 根节点 -> 右子树
+      inOrder(node.left);
+      list.add(node.val);
+      inOrder(node.right);
+    }
+
+    /* 后序遍历 */
+    void postOrder(TreeNode? node) {
+      if (node == null) return;
+      // 访问优先级：左子树 -> 右子树 -> 根节点
+      postOrder(node.left);
+      postOrder(node.right);
+      list.add(node.val);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_tree_dfs.rs"
+    /* 前序遍历 */
+    fn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+        let mut result = vec![];
+
+        if let Some(node) = root {
+            // 访问优先级：根结点 -> 左子树 -> 右子树
+            result.push(node.borrow().val);
+            result.append(&mut pre_order(node.borrow().left.as_ref()));
+            result.append(&mut pre_order(node.borrow().right.as_ref()));
+        }
+        result
+    }
+
+    /* 中序遍历 */
+    fn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+        let mut result = vec![];
+
+        if let Some(node) = root {
+            // 访问优先级：左子树 -> 根结点 -> 右子树
+            result.append(&mut in_order(node.borrow().left.as_ref()));
+            result.push(node.borrow().val);
+            result.append(&mut in_order(node.borrow().right.as_ref()));
+        }
+        result
+    }
+
+    /* 后序遍历 */
+    fn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+        let mut result = vec![];
+
+        if let Some(node) = root {
+            // 访问优先级：左子树 -> 右子树 -> 根结点
+            result.append(&mut post_order(node.borrow().left.as_ref()));
+            result.append(&mut post_order(node.borrow().right.as_ref()));
+            result.push(node.borrow().val);
+        }
+        result
+    }
+    ```
+
+=== "C"
+
+    ```c title="binary_tree_dfs.c"
+    /* 前序遍历 */
+    void preOrder(TreeNode *root, int *size) {
+        if (root == NULL)
+            return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        arr[(*size)++] = root->val;
+        preOrder(root->left, size);
+        preOrder(root->right, size);
+    }
+
+    /* 中序遍历 */
+    void inOrder(TreeNode *root, int *size) {
+        if (root == NULL)
+            return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root->left, size);
+        arr[(*size)++] = root->val;
+        inOrder(root->right, size);
+    }
+
+    /* 后序遍历 */
+    void postOrder(TreeNode *root, int *size) {
+        if (root == NULL)
+            return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root->left, size);
+        postOrder(root->right, size);
+        arr[(*size)++] = root->val;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_tree_dfs.zig"
+    // 前序遍历
+    fn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        try list.append(root.?.val);
+        try preOrder(T, root.?.left);
+        try preOrder(T, root.?.right);
+    }
+
+    // 中序遍历
+    fn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        try inOrder(T, root.?.left);
+        try list.append(root.?.val);
+        try inOrder(T, root.?.right);
+    }
+
+    // 后序遍历
+    fn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        try postOrder(T, root.?.left);
+        try postOrder(T, root.?.right);
+        try list.append(root.?.val);
+    }
+    ```
+
+!!! note
+
+    深度优先搜索也可以基于迭代实现，有兴趣的同学可以自行研究。
+
+图 7-11 展示了前序遍历二叉树的递归过程，其可分为“递”和“归”两个逆向的部分。
+
+1. “递”表示开启新方法，程序在此过程中访问下一个节点。
+2. “归”表示函数返回，代表当前节点已经访问完毕。
+
+=== "<1>"
+    ![前序遍历的递归过程](binary_tree_traversal.assets/preorder_step1.png)
+
+=== "<2>"
+    ![preorder_step2](binary_tree_traversal.assets/preorder_step2.png)
+
+=== "<3>"
+    ![preorder_step3](binary_tree_traversal.assets/preorder_step3.png)
+
+=== "<4>"
+    ![preorder_step4](binary_tree_traversal.assets/preorder_step4.png)
+
+=== "<5>"
+    ![preorder_step5](binary_tree_traversal.assets/preorder_step5.png)
+
+=== "<6>"
+    ![preorder_step6](binary_tree_traversal.assets/preorder_step6.png)
+
+=== "<7>"
+    ![preorder_step7](binary_tree_traversal.assets/preorder_step7.png)
+
+=== "<8>"
+    ![preorder_step8](binary_tree_traversal.assets/preorder_step8.png)
+
+=== "<9>"
+    ![preorder_step9](binary_tree_traversal.assets/preorder_step9.png)
+
+=== "<10>"
+    ![preorder_step10](binary_tree_traversal.assets/preorder_step10.png)
+
+=== "<11>"
+    ![preorder_step11](binary_tree_traversal.assets/preorder_step11.png)
+
+<p align="center"> 图 7-11 &nbsp; 前序遍历的递归过程 </p>
+
+### 2. &nbsp; 复杂度分析
+
+- **时间复杂度 $O(n)$** ：所有节点被访问一次，使用 $O(n)$ 时间。
+- **空间复杂度 $O(n)$** ：在最差情况下，即树退化为链表时，递归深度达到 $n$ ，系统占用 $O(n)$ 栈帧空间。

docs/chapter_tree/index.md

@@ -0,0 +1,27 @@
+---
+comments: true
+icon: material/graph-outline
+---
+
+# 第 7 章   树
+
+<div class="center-table" markdown>
+
+![树](../assets/covers/chapter_tree.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    参天大树充满生命力，其根深叶茂，分枝扶疏。
+    
+    它为我们展现了数据分治的生动形态。
+
+## 本章内容
+
+- [7.1 &nbsp; 二叉树](https://www.hello-algo.com/chapter_tree/binary_tree/)
+- [7.2 &nbsp; 二叉树遍历](https://www.hello-algo.com/chapter_tree/binary_tree_traversal/)
+- [7.3 &nbsp; 二叉树数组表示](https://www.hello-algo.com/chapter_tree/array_representation_of_tree/)
+- [7.4 &nbsp; 二叉搜索树](https://www.hello-algo.com/chapter_tree/binary_search_tree/)
+- [7.5 &nbsp; AVL 树 *](https://www.hello-algo.com/chapter_tree/avl_tree/)
+- [7.6 &nbsp; 小结](https://www.hello-algo.com/chapter_tree/summary/)