Move documents to a sub-directory

to support multi-language selector.

docs/zh/chapter_appendix/contribution.md

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

docs/zh/chapter_appendix/index.md

@@ -0,0 +1,7 @@
+# 附录
+
+<div class="center-table" markdown>
+
+![附录](../assets/covers/chapter_appendix.jpg){ width="600" }
+
+</div>

docs/zh/chapter_appendix/installation.md

@@ -0,0 +1,55 @@
+# 编程环境安装
+
+### VSCode
+
+本书推荐使用开源轻量的 VSCode 作为本地 IDE ，下载并安装 [VSCode](https://code.visualstudio.com/) 。
+
+### Java 环境
+
+1. 下载并安装 [OpenJDK](https://jdk.java.net/18/)（版本需满足 > JDK 9）。
+2. 在 VSCode 的插件市场中搜索 `java` ，安装 Extension Pack for Java 。
+
+### 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 }` 。
+
+### Python 环境
+
+1. 下载并安装 [Miniconda3](https://docs.conda.io/en/latest/miniconda.html) 。
+2. 在 VSCode 的插件市场中搜索 `python` ，安装 Python Extension Pack 。
+3. （可选）在命令行输入 `pip install black` ，安装代码格式化工具。
+
+### Go 环境
+
+1. 下载并安装 [go](https://go.dev/dl/) 。
+2. 在 VSCode 的插件市场中搜索 `go` ，安装 Go 。
+3. 快捷键 `Ctrl + Shift + P` 呼出命令栏，输入 go ，选择 `Go: Install/Update Tools` ，全部勾选并安装即可。
+
+### JavaScript 环境
+
+1. 下载并安装 [node.js](https://nodejs.org/en/) 。
+2. 在 VSCode 的插件市场中搜索 `javascript` ，安装 JavaScript (ES6) code snippets 。
+3. （可选）在 VSCode 的插件市场中搜索 `Prettier` ，安装代码格式化工具。
+
+### 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)）。
+
+### 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) 。
+
+### Dart 环境
+
+1. 下载并安装 [Dart](https://dart.dev/get-dart) 。
+2. 在 VSCode 的插件市场中搜索 `dart` ，安装 [Dart](https://marketplace.visualstudio.com/items?itemName=Dart-Code.dart-code) 。
+
+### 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/zh/chapter_array_and_linkedlist/array.md

@@ -0,0 +1,618 @@
+# 数组
+
+「数组 array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将元素在数组中的位置称为该元素的「索引 index」。下图展示了数组的主要术语和概念。
+
+![数组定义与存储方式](array.assets/array_definition.png)
+
+## 数组常用操作
+
+### 初始化数组
+
+我们可以根据需求选用数组的两种初始化方式：无初始值、给定初始值。在未指定初始值的情况下，大多数编程语言会将数组元素初始化为 $0$ 。
+
+=== "Python"
+
+    ```python title="array.py"
+    # 初始化数组
+    arr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]
+    nums: list[int] = [1, 3, 2, 5, 4]  
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    /* 初始化数组 */
+    // 存储在栈上
+    int arr[5];
+    int nums[5] { 1, 3, 2, 5, 4 };
+    // 存储在堆上（需要手动释放空间）
+    int* arr1 = new int[5];
+    int* nums1 = new int[5] { 1, 3, 2, 5, 4 };
+    ```
+
+=== "Java"
+
+    ```java title="array.java"
+    /* 初始化数组 */
+    int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
+    int[] nums = { 1, 3, 2, 5, 4 };
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    /* 初始化数组 */
+    int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
+    int[] nums = { 1, 3, 2, 5, 4 };
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    /* 初始化数组 */
+    var arr [5]int
+    // 在 Go 中，指定长度时（[5]int）为数组，不指定长度时（[]int）为切片
+    // 由于 Go 的数组被设计为在编译期确定长度，因此只能使用常量来指定长度
+    // 为了方便实现扩容 extend() 方法，以下将切片（Slice）看作数组（Array）
+    nums := []int{1, 3, 2, 5, 4}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    /* 初始化数组 */
+    let arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]
+    let nums = [1, 3, 2, 5, 4]
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    /* 初始化数组 */
+    var arr = new Array(5).fill(0);
+    var nums = [1, 3, 2, 5, 4];
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    /* 初始化数组 */
+    let arr: number[] = new Array(5).fill(0);
+    let nums: number[] = [1, 3, 2, 5, 4];
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    /* 初始化数组 */
+    List<int> arr = List.filled(5, 0); // [0, 0, 0, 0, 0]
+    List<int> nums = [1, 3, 2, 5, 4];
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    /* 初始化数组 */
+    let arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]
+    let nums: Vec<i32> = vec![1, 3, 2, 5, 4];
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    /* 初始化数组 */
+    int arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }
+    int nums[5] = { 1, 3, 2, 5, 4 };
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    // 初始化数组
+    var arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
+    var nums = [_]i32{ 1, 3, 2, 5, 4 };
+    ```
+
+### 访问元素
+
+数组元素被存储在连续的内存空间中，这意味着计算数组元素的内存地址非常容易。给定数组内存地址（即首元素内存地址）和某个元素的索引，我们可以使用下图所示的公式计算得到该元素的内存地址，从而直接访问此元素。
+
+![数组元素的内存地址计算](array.assets/array_memory_location_calculation.png)
+
+观察上图，我们发现数组首个元素的索引为 $0$ ，这似乎有些反直觉，因为从 $1$ 开始计数会更自然。但从地址计算公式的角度看，**索引的含义本质上是内存地址的偏移量**。首个元素的地址偏移量是 $0$ ，因此它的索引为 $0$ 也是合理的。
+
+在数组中访问元素是非常高效的，我们可以在 $O(1)$ 时间内随机访问数组中的任意一个元素。
+
+=== "Python"
+
+    ```python title="array.py"
+    [class]{}-[func]{random_access}
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    [class]{}-[func]{randomAccess}
+    ```
+
+=== "Java"
+
+    ```java title="array.java"
+    [class]{array}-[func]{randomAccess}
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    [class]{array}-[func]{randomAccess}
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    [class]{}-[func]{randomAccess}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    [class]{}-[func]{randomAccess}
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    [class]{}-[func]{randomAccess}
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    [class]{}-[func]{randomAccess}
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    [class]{}-[func]{randomAccess}
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    [class]{}-[func]{random_access}
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    [class]{}-[func]{randomAccess}
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    [class]{}-[func]{randomAccess}
+    ```
+
+### 插入元素
+
+数组元素在内存中是“紧挨着的”，它们之间没有空间再存放任何数据。如下图所示，如果想要在数组中间插入一个元素，则需要将该元素之后的所有元素都向后移动一位，之后再把元素赋值给该索引。
+
+![数组插入元素示例](array.assets/array_insert_element.png)
+
+值得注意的是，由于数组的长度是固定的，因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。
+
+=== "Python"
+
+    ```python title="array.py"
+    [class]{}-[func]{insert}
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Java"
+
+    ```java title="array.java"
+    [class]{array}-[func]{insert}
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    [class]{array}-[func]{insert}
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    [class]{}-[func]{insert}
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    [class]{}-[func]{insert}
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    [class]{}-[func]{insert}
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    [class]{}-[func]{insert}
+    ```
+
+### 删除元素
+
+同理，如下图所示，若想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。
+
+![数组删除元素示例](array.assets/array_remove_element.png)
+
+请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。
+
+=== "Python"
+
+    ```python title="array.py"
+    [class]{}-[func]{remove}
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    [class]{}-[func]{remove}
+    ```
+
+=== "Java"
+
+    ```java title="array.java"
+    [class]{array}-[func]{remove}
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    [class]{array}-[func]{remove}
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    [class]{}-[func]{remove}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    [class]{}-[func]{remove}
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    [class]{}-[func]{remove}
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    [class]{}-[func]{remove}
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    [class]{}-[func]{remove}
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    [class]{}-[func]{remove}
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    [class]{}-[func]{removeItem}
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    [class]{}-[func]{remove}
+    ```
+
+总的来看，数组的插入与删除操作有以下缺点。
+
+- **时间复杂度高**：数组的插入和删除的平均时间复杂度均为 $O(n)$ ，其中 $n$ 为数组长度。
+- **丢失元素**：由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会丢失。
+- **内存浪费**：我们可以初始化一个比较长的数组，只用前面一部分，这样在插入数据时，丢失的末尾元素都是“无意义”的，但这样做也会造成部分内存空间的浪费。
+
+### 遍历数组
+
+在大多数编程语言中，我们既可以通过索引遍历数组，也可以直接遍历获取数组中的每个元素。
+
+=== "Python"
+
+    ```python title="array.py"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "Java"
+
+    ```java title="array.java"
+    [class]{array}-[func]{traverse}
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    [class]{array}-[func]{traverse}
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    [class]{}-[func]{traverse}
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    [class]{}-[func]{traverse}
+    ```
+
+### 查找元素
+
+在数组中查找指定元素需要遍历数组，每轮判断元素值是否匹配，若匹配则输出对应索引。
+
+因为数组是线性数据结构，所以上述查找操作被称为“线性查找”。
+
+=== "Python"
+
+    ```python title="array.py"
+    [class]{}-[func]{find}
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    [class]{}-[func]{find}
+    ```
+
+=== "Java"
+
+    ```java title="array.java"
+    [class]{array}-[func]{find}
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    [class]{array}-[func]{find}
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    [class]{}-[func]{find}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    [class]{}-[func]{find}
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    [class]{}-[func]{find}
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    [class]{}-[func]{find}
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    [class]{}-[func]{find}
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    [class]{}-[func]{find}
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    [class]{}-[func]{find}
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    [class]{}-[func]{find}
+    ```
+
+### 扩容数组
+
+在复杂的系统环境中，程序难以保证数组之后的内存空间是可用的，从而无法安全地扩展数组容量。因此在大多数编程语言中，**数组的长度是不可变的**。
+
+如果我们希望扩容数组，则需重新建立一个更大的数组，然后把原数组元素依次拷贝到新数组。这是一个 $O(n)$ 的操作，在数组很大的情况下是非常耗时的。
+
+=== "Python"
+
+    ```python title="array.py"
+    [class]{}-[func]{extend}
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Java"
+
+    ```java title="array.java"
+    [class]{array}-[func]{extend}
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    [class]{array}-[func]{extend}
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    [class]{}-[func]{extend}
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    [class]{}-[func]{extend}
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    [class]{}-[func]{extend}
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    [class]{}-[func]{extend}
+    ```
+
+## 数组优点与局限性
+
+数组存储在连续的内存空间内，且元素类型相同。这种做法包含丰富的先验信息，系统可以利用这些信息来优化数据结构的操作效率。
+
+- **空间效率高**: 数组为数据分配了连续的内存块，无须额外的结构开销。
+- **支持随机访问**: 数组允许在 $O(1)$ 时间内访问任何元素。
+- **缓存局部性**: 当访问数组元素时，计算机不仅会加载它，还会缓存其周围的其他数据，从而借助高速缓存来提升后续操作的执行速度。
+
+连续空间存储是一把双刃剑，其存在以下缺点。
+
+- **插入与删除效率低**:当数组中元素较多时，插入与删除操作需要移动大量的元素。
+- **长度不可变**: 数组在初始化后长度就固定了，扩容数组需要将所有数据复制到新数组，开销很大。
+- **空间浪费**: 如果数组分配的大小超过了实际所需，那么多余的空间就被浪费了。
+
+## 数组典型应用
+
+数组是一种基础且常见的数据结构，既频繁应用在各类算法之中，也可用于实现各种复杂数据结构。
+
+- **随机访问**：如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
+- **排序和搜索**：数组是排序和搜索算法最常用的数据结构。快速排序、归并排序、二分查找等都主要在数组上进行。
+- **查找表**：当我们需要快速查找一个元素或者需要查找一个元素的对应关系时，可以使用数组作为查找表。假如我们想要实现字符到 ASCII 码的映射，则可以将字符的 ASCII 码值作为索引，对应的元素存放在数组中的对应位置。
+- **机器学习**：神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
+- **数据结构实现**：数组可以用于实现栈、队列、哈希表、堆、图等数据结构。例如，图的邻接矩阵表示实际上是一个二维数组。

docs/zh/chapter_array_and_linkedlist/index.md

@@ -0,0 +1,13 @@
+# 数组与链表
+
+<div class="center-table" markdown>
+
+![数组与链表](../assets/covers/chapter_array_and_linkedlist.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    数据结构的世界如同一堵厚实的砖墙。
+
+    数组的砖块整齐排列，逐个紧贴。链表的砖块分散各处，连接的藤蔓自由地穿梭于砖缝之间。

docs/zh/chapter_array_and_linkedlist/linked_list.md

@@ -0,0 +1,952 @@
+# 链表
+
+内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。
+
+「链表 linked list」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，通过它可以从当前节点访问到下一个节点。
+
+链表的设计使得各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。
+
+![链表定义与存储方式](linked_list.assets/linkedlist_definition.png)
+
+观察上图，链表的组成单位是「节点 node」对象。每个节点都包含两项数据：节点的“值”和指向下一节点的“引用”。
+
+- 链表的首个节点被称为“头节点”，最后一个节点被称为“尾节点”。
+- 尾节点指向的是“空”，它在 Java、C++ 和 Python 中分别被记为 $\text{null}$、$\text{nullptr}$ 和 $\text{None}$ 。
+- 在 C、C++、Go 和 Rust 等支持指针的语言中，上述的“引用”应被替换为“指针”。
+
+如以下代码所示，链表节点 `ListNode` 除了包含值，还需额外保存一个引用（指针）。因此在相同数据量下，**链表比数组占用更多的内存空间**。
+
+=== "Python"
+
+    ```python title=""
+    class ListNode:
+        """链表节点类"""
+        def __init__(self, val: int):
+            self.val: int = val               # 节点值
+            self.next: ListNode | None = None # 指向下一节点的引用
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 链表节点结构体 */
+    struct ListNode {
+        int val;         // 节点值
+        ListNode *next;  // 指向下一节点的指针
+        ListNode(int x) : val(x), next(nullptr) {}  // 构造函数
+    };
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* 链表节点类 */
+    class ListNode {
+        int val;        // 节点值
+        ListNode next;  // 指向下一节点的引用
+        ListNode(int x) { val = x; }  // 构造函数
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 链表节点类 */
+    class ListNode {
+        int val;         // 节点值
+        ListNode next;   // 指向下一节点的引用
+        ListNode(int x) => val = x;  //构造函数
+    }
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 链表节点结构体 */
+    type ListNode struct {
+        Val  int       // 节点值
+        Next *ListNode // 指向下一节点的指针
+    }
+
+    // NewListNode 构造函数，创建一个新的链表
+    func NewListNode(val int) *ListNode {
+        return &ListNode{
+            Val:  val,
+            Next: nil,
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* 链表节点类 */
+    class ListNode {
+        var val: Int // 节点值
+        var next: ListNode? // 指向下一节点的引用
+
+        init(x: Int) { // 构造函数
+            val = x
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* 链表节点类 */
+    class ListNode {
+        val;
+        next;
+        constructor(val, next) {
+            this.val = (val === undefined ? 0 : val);       // 节点值
+            this.next = (next === undefined ? null : next); // 指向下一节点的引用
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* 链表节点类 */
+    class ListNode {
+        val: number;
+        next: ListNode | null;
+        constructor(val?: number, next?: ListNode | null) {
+            this.val = val === undefined ? 0 : val;        // 节点值
+            this.next = next === undefined ? null : next;  // 指向下一节点的引用
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* 链表节点类 */
+    class ListNode {
+      int val; // 节点值
+      ListNode? next; // 指向下一节点的引用
+      ListNode(this.val, [this.next]); // 构造函数
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    use std::rc::Rc;
+    use std::cell::RefCell;
+    /* 链表节点类 */
+    #[derive(Debug)]
+    struct ListNode {
+        val: i32, // 节点值
+        next: Option<Rc<RefCell<ListNode>>>, // 指向下一节点的指针
+    }
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* 链表节点结构体 */
+    struct ListNode {
+        int val;               // 节点值
+        struct ListNode *next; // 指向下一节点的指针
+    };
+
+    typedef struct ListNode ListNode;
+
+    /* 构造函数 */
+    ListNode *newListNode(int val) {
+        ListNode *node, *next;
+        node = (ListNode *) malloc(sizeof(ListNode));
+        node->val = val;
+        node->next = NULL;
+        return node;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+    // 链表节点类
+    pub fn ListNode(comptime T: type) type {
+        return struct {
+            const Self = @This();
+
+            val: T = 0, // 节点值
+            next: ?*Self = null, // 指向下一节点的指针
+
+            // 构造函数
+            pub fn init(self: *Self, x: i32) void {
+                self.val = x;
+                self.next = null;
+            }
+        };
+    }
+    ```
+
+## 链表常用操作
+
+### 初始化链表
+
+建立链表分为两步，第一步是初始化各个节点对象，第二步是构建引用指向关系。初始化完成后，我们就可以从链表的头节点出发，通过引用指向 `next` 依次访问所有节点。
+
+=== "Python"
+
+    ```python title="linked_list.py"
+    # 初始化链表 1 -> 3 -> 2 -> 5 -> 4
+    # 初始化各个节点
+    n0 = ListNode(1)
+    n1 = ListNode(3)
+    n2 = ListNode(2)
+    n3 = ListNode(5)
+    n4 = ListNode(4)
+    # 构建引用指向
+    n0.next = n1
+    n1.next = n2
+    n2.next = n3
+    n3.next = n4
+    ```
+
+=== "C++"
+
+    ```cpp title="linked_list.cpp"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    ListNode* n0 = new ListNode(1);
+    ListNode* n1 = new ListNode(3);
+    ListNode* n2 = new ListNode(2);
+    ListNode* n3 = new ListNode(5);
+    ListNode* n4 = new ListNode(4);
+    // 构建引用指向
+    n0->next = n1;
+    n1->next = n2;
+    n2->next = n3;
+    n3->next = n4;
+    ```
+
+=== "Java"
+
+    ```java title="linked_list.java"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    ListNode n0 = new ListNode(1);
+    ListNode n1 = new ListNode(3);
+    ListNode n2 = new ListNode(2);
+    ListNode n3 = new ListNode(5);
+    ListNode n4 = new ListNode(4);
+    // 构建引用指向
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "C#"
+
+    ```csharp title="linked_list.cs"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    ListNode n0 = new ListNode(1);
+    ListNode n1 = new ListNode(3);
+    ListNode n2 = new ListNode(2);
+    ListNode n3 = new ListNode(5);
+    ListNode n4 = new ListNode(4);
+    // 构建引用指向
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "Go"
+
+    ```go title="linked_list.go"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    n0 := NewListNode(1)
+    n1 := NewListNode(3)
+    n2 := NewListNode(2)
+    n3 := NewListNode(5)
+    n4 := NewListNode(4)
+    // 构建引用指向
+    n0.Next = n1
+    n1.Next = n2
+    n2.Next = n3
+    n3.Next = n4
+    ```
+
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    let n0 = ListNode(x: 1)
+    let n1 = ListNode(x: 3)
+    let n2 = ListNode(x: 2)
+    let n3 = ListNode(x: 5)
+    let n4 = ListNode(x: 4)
+    // 构建引用指向
+    n0.next = n1
+    n1.next = n2
+    n2.next = n3
+    n3.next = n4
+    ```
+
+=== "JS"
+
+    ```javascript title="linked_list.js"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    const n0 = new ListNode(1);
+    const n1 = new ListNode(3);
+    const n2 = new ListNode(2);
+    const n3 = new ListNode(5);
+    const n4 = new ListNode(4);
+    // 构建引用指向
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "TS"
+
+    ```typescript title="linked_list.ts"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    const n0 = new ListNode(1);
+    const n1 = new ListNode(3);
+    const n2 = new ListNode(2);
+    const n3 = new ListNode(5);
+    const n4 = new ListNode(4);
+    // 构建引用指向
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "Dart"
+
+    ```dart title="linked_list.dart"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */\
+    // 初始化各个节点
+    ListNode n0 = ListNode(1);
+    ListNode n1 = ListNode(3);
+    ListNode n2 = ListNode(2);
+    ListNode n3 = ListNode(5);
+    ListNode n4 = ListNode(4);
+    // 构建引用指向
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "Rust"
+
+    ```rust title="linked_list.rs"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    let n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));
+    let n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));
+    let n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));
+    let n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));
+    let n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));
+
+    // 构建引用指向
+    n0.borrow_mut().next = Some(n1.clone());
+    n1.borrow_mut().next = Some(n2.clone());
+    n2.borrow_mut().next = Some(n3.clone());
+    n3.borrow_mut().next = Some(n4.clone());
+    ```
+
+=== "C"
+
+    ```c title="linked_list.c"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    ListNode* n0 = newListNode(1);
+    ListNode* n1 = newListNode(3);
+    ListNode* n2 = newListNode(2);
+    ListNode* n3 = newListNode(5);
+    ListNode* n4 = newListNode(4);
+    // 构建引用指向
+    n0->next = n1;
+    n1->next = n2;
+    n2->next = n3;
+    n3->next = n4;
+    ```
+
+=== "Zig"
+
+    ```zig title="linked_list.zig"
+    // 初始化链表
+    // 初始化各个节点
+    var n0 = inc.ListNode(i32){.val = 1};
+    var n1 = inc.ListNode(i32){.val = 3};
+    var n2 = inc.ListNode(i32){.val = 2};
+    var n3 = inc.ListNode(i32){.val = 5};
+    var n4 = inc.ListNode(i32){.val = 4};
+    // 构建引用指向
+    n0.next = &n1;
+    n1.next = &n2;
+    n2.next = &n3;
+    n3.next = &n4;
+    ```
+
+数组整体是一个变量，比如数组 `nums` 包含元素 `nums[0]` 和 `nums[1]` 等，而链表是由多个独立的节点对象组成的。**我们通常将头节点当作链表的代称**，比如以上代码中的链表可被记做链表 `n0` 。
+
+### 插入节点
+
+在链表中插入节点非常容易。如下图所示，假设我们想在相邻的两个节点 `n0` 和 `n1` 之间插入一个新节点 `P` ，**则只需要改变两个节点引用（指针）即可**，时间复杂度为 $O(1)$ 。
+
+相比之下，在数组中插入元素的时间复杂度为 $O(n)$ ，在大数据量下的效率较低。
+
+![链表插入节点示例](linked_list.assets/linkedlist_insert_node.png)
+
+=== "Python"
+
+    ```python title="linked_list.py"
+    [class]{}-[func]{insert}
+    ```
+
+=== "C++"
+
+    ```cpp title="linked_list.cpp"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Java"
+
+    ```java title="linked_list.java"
+    [class]{linked_list}-[func]{insert}
+    ```
+
+=== "C#"
+
+    ```csharp title="linked_list.cs"
+    [class]{linked_list}-[func]{insert}
+    ```
+
+=== "Go"
+
+    ```go title="linked_list.go"
+    [class]{}-[func]{insertNode}
+    ```
+
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+    [class]{}-[func]{insert}
+    ```
+
+=== "JS"
+
+    ```javascript title="linked_list.js"
+    [class]{}-[func]{insert}
+    ```
+
+=== "TS"
+
+    ```typescript title="linked_list.ts"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Dart"
+
+    ```dart title="linked_list.dart"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Rust"
+
+    ```rust title="linked_list.rs"
+    [class]{}-[func]{insert}
+    ```
+
+=== "C"
+
+    ```c title="linked_list.c"
+    [class]{}-[func]{insert}
+    ```
+
+=== "Zig"
+
+    ```zig title="linked_list.zig"
+    [class]{}-[func]{insert}
+    ```
+
+### 删除节点
+
+如下图所示，在链表中删除节点也非常方便，**只需改变一个节点的引用（指针）即可**。
+
+请注意，尽管在删除操作完成后节点 `P` 仍然指向 `n1` ，但实际上遍历此链表已经无法访问到 `P` ，这意味着 `P` 已经不再属于该链表了。
+
+![链表删除节点](linked_list.assets/linkedlist_remove_node.png)
+
+=== "Python"
+
+    ```python title="linked_list.py"
+    [class]{}-[func]{remove}
+    ```
+
+=== "C++"
+
+    ```cpp title="linked_list.cpp"
+    [class]{}-[func]{remove}
+    ```
+
+=== "Java"
+
+    ```java title="linked_list.java"
+    [class]{linked_list}-[func]{remove}
+    ```
+
+=== "C#"
+
+    ```csharp title="linked_list.cs"
+    [class]{linked_list}-[func]{remove}
+    ```
+
+=== "Go"
+
+    ```go title="linked_list.go"
+    [class]{}-[func]{removeNode}
+    ```
+
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+    [class]{}-[func]{remove}
+    ```
+
+=== "JS"
+
+    ```javascript title="linked_list.js"
+    [class]{}-[func]{remove}
+    ```
+
+=== "TS"
+
+    ```typescript title="linked_list.ts"
+    [class]{}-[func]{remove}
+    ```
+
+=== "Dart"
+
+    ```dart title="linked_list.dart"
+    [class]{}-[func]{remove}
+    ```
+
+=== "Rust"
+
+    ```rust title="linked_list.rs"
+    [class]{}-[func]{remove}
+    ```
+
+=== "C"
+
+    ```c title="linked_list.c"
+    [class]{}-[func]{removeNode}
+    ```
+
+=== "Zig"
+
+    ```zig title="linked_list.zig"
+    [class]{}-[func]{remove}
+    ```
+
+### 访问节点
+
+**在链表访问节点的效率较低**。如上节所述，我们可以在 $O(1)$ 时间下访问数组中的任意元素。链表则不然，程序需要从头节点出发，逐个向后遍历，直至找到目标节点。也就是说，访问链表的第 $i$ 个节点需要循环 $i - 1$ 轮，时间复杂度为 $O(n)$ 。
+
+=== "Python"
+
+    ```python title="linked_list.py"
+    [class]{}-[func]{access}
+    ```
+
+=== "C++"
+
+    ```cpp title="linked_list.cpp"
+    [class]{}-[func]{access}
+    ```
+
+=== "Java"
+
+    ```java title="linked_list.java"
+    [class]{linked_list}-[func]{access}
+    ```
+
+=== "C#"
+
+    ```csharp title="linked_list.cs"
+    [class]{linked_list}-[func]{access}
+    ```
+
+=== "Go"
+
+    ```go title="linked_list.go"
+    [class]{}-[func]{access}
+    ```
+
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+    [class]{}-[func]{access}
+    ```
+
+=== "JS"
+
+    ```javascript title="linked_list.js"
+    [class]{}-[func]{access}
+    ```
+
+=== "TS"
+
+    ```typescript title="linked_list.ts"
+    [class]{}-[func]{access}
+    ```
+
+=== "Dart"
+
+    ```dart title="linked_list.dart"
+    [class]{}-[func]{access}
+    ```
+
+=== "Rust"
+
+    ```rust title="linked_list.rs"
+    [class]{}-[func]{access}
+    ```
+
+=== "C"
+
+    ```c title="linked_list.c"
+    [class]{}-[func]{access}
+    ```
+
+=== "Zig"
+
+    ```zig title="linked_list.zig"
+    [class]{}-[func]{access}
+    ```
+
+### 查找节点
+
+遍历链表，查找链表内值为 `target` 的节点，输出节点在链表中的索引。此过程也属于线性查找。
+
+=== "Python"
+
+    ```python title="linked_list.py"
+    [class]{}-[func]{find}
+    ```
+
+=== "C++"
+
+    ```cpp title="linked_list.cpp"
+    [class]{}-[func]{find}
+    ```
+
+=== "Java"
+
+    ```java title="linked_list.java"
+    [class]{linked_list}-[func]{find}
+    ```
+
+=== "C#"
+
+    ```csharp title="linked_list.cs"
+    [class]{linked_list}-[func]{find}
+    ```
+
+=== "Go"
+
+    ```go title="linked_list.go"
+    [class]{}-[func]{findNode}
+    ```
+
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+    [class]{}-[func]{find}
+    ```
+
+=== "JS"
+
+    ```javascript title="linked_list.js"
+    [class]{}-[func]{find}
+    ```
+
+=== "TS"
+
+    ```typescript title="linked_list.ts"
+    [class]{}-[func]{find}
+    ```
+
+=== "Dart"
+
+    ```dart title="linked_list.dart"
+    [class]{}-[func]{find}
+    ```
+
+=== "Rust"
+
+    ```rust title="linked_list.rs"
+    [class]{}-[func]{find}
+    ```
+
+=== "C"
+
+    ```c title="linked_list.c"
+    [class]{}-[func]{find}
+    ```
+
+=== "Zig"
+
+    ```zig title="linked_list.zig"
+    [class]{}-[func]{find}
+    ```
+
+## 数组 VS 链表
+
+下表总结对比了数组和链表的各项特点与操作效率。由于它们采用两种相反的存储策略，因此各种性质和操作效率也呈现对立的特点。
+
+<p align="center"> 表 <id> &nbsp; 数组与链表的效率对比 </p>
+
+|            | 数组                     | 链表         |
+| ---------- | ------------------------ | ------------ |
+| 存储方式   | 连续内存空间             | 分散内存空间 |
+| 缓存局部性 | 友好                     | 不友好       |
+| 容量扩展   | 长度不可变               | 可灵活扩展   |
+| 内存效率   | 占用内存少、浪费部分空间 | 占用内存多   |
+| 访问元素   | $O(1)$                   | $O(n)$       |
+| 添加元素   | $O(n)$                   | $O(1)$       |
+| 删除元素   | $O(n)$                   | $O(1)$       |
+
+## 常见链表类型
+
+如下图所示，常见的链表类型包括三种。
+
+- **单向链表**：即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点称为尾节点，尾节点指向空 $\text{None}$ 。
+- **环形链表**：如果我们令单向链表的尾节点指向头节点（即首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。
+- **双向链表**：与单向链表相比，双向链表记录了两个方向的引用。双向链表的节点定义同时包含指向后继节点（下一个节点）和前驱节点（上一个节点）的引用（指针）。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。
+
+=== "Python"
+
+    ```python title=""
+    class ListNode:
+        """双向链表节点类"""
+        def __init__(self, val: int):
+            self.val: int = val                # 节点值
+            self.next: ListNode | None = None  # 指向后继节点的引用
+            self.prev: ListNode | None = None  # 指向前驱节点的引用
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 双向链表节点结构体 */
+    struct ListNode {
+        int val;         // 节点值
+        ListNode *next;  // 指向后继节点的指针
+        ListNode *prev;  // 指向前驱节点的指针
+        ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // 构造函数
+    };
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* 双向链表节点类 */
+    class ListNode {
+        int val;        // 节点值
+        ListNode next;  // 指向后继节点的引用
+        ListNode prev;  // 指向前驱节点的引用
+        ListNode(int x) { val = x; }  // 构造函数
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 双向链表节点类 */
+    class ListNode {
+        int val;        // 节点值
+        ListNode next;  // 指向后继节点的引用
+        ListNode prev;  // 指向前驱节点的引用
+        ListNode(int x) => val = x;  // 构造函数
+    }
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 双向链表节点结构体 */
+    type DoublyListNode struct {
+        Val  int             // 节点值
+        Next *DoublyListNode // 指向后继节点的指针
+        Prev *DoublyListNode // 指向前驱节点的指针
+    }
+
+    // NewDoublyListNode 初始化
+    func NewDoublyListNode(val int) *DoublyListNode {
+        return &DoublyListNode{
+            Val:  val,
+            Next: nil,
+            Prev: nil,
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* 双向链表节点类 */
+    class ListNode {
+        var val: Int // 节点值
+        var next: ListNode? // 指向后继节点的引用
+        var prev: ListNode? // 指向前驱节点的引用
+
+        init(x: Int) { // 构造函数
+            val = x
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* 双向链表节点类 */
+    class ListNode {
+        val;
+        next;
+        prev;
+        constructor(val, next, prev) {
+            this.val = val  ===  undefined ? 0 : val;        // 节点值
+            this.next = next  ===  undefined ? null : next;  // 指向后继节点的引用
+            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱节点的引用
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* 双向链表节点类 */
+    class ListNode {
+        val: number;
+        next: ListNode | null;
+        prev: ListNode | null;
+        constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {
+            this.val = val  ===  undefined ? 0 : val;        // 节点值
+            this.next = next  ===  undefined ? null : next;  // 指向后继节点的引用
+            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱节点的引用
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* 双向链表节点类 */
+    class ListNode {
+        int val;        // 节点值
+        ListNode next;  // 指向后继节点的引用
+        ListNode prev;  // 指向前驱节点的引用
+        ListNode(this.val, [this.next, this.prev]);  // 构造函数
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    use std::rc::Rc;
+    use std::cell::RefCell;
+
+    /* 双向链表节点类型 */
+    #[derive(Debug)]
+    struct ListNode {
+        val: i32, // 节点值
+        next: Option<Rc<RefCell<ListNode>>>, // 指向后继节点的指针
+        prev: Option<Rc<RefCell<ListNode>>>, // 指向前驱节点的指针
+    }
+
+    /* 构造函数 */
+    impl ListNode {
+        fn new(val: i32) -> Self {
+            ListNode {
+                val,
+                next: None,
+                prev: None,
+            }
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* 双向链表节点结构体 */
+    struct ListNode {
+        int val;               // 节点值
+        struct ListNode *next; // 指向后继节点的指针
+        struct ListNode *prev; // 指向前驱节点的指针
+    };
+
+    typedef struct ListNode ListNode;
+
+    /* 构造函数 */
+    ListNode *newListNode(int val) {
+        ListNode *node, *next;
+        node = (ListNode *) malloc(sizeof(ListNode));
+        node->val = val;
+        node->next = NULL;
+        node->prev = NULL;
+        return node;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+    // 双向链表节点类
+    pub fn ListNode(comptime T: type) type {
+        return struct {
+            const Self = @This();
+
+            val: T = 0, // 节点值
+            next: ?*Self = null, // 指向后继节点的指针
+            prev: ?*Self = null, // 指向前驱节点的指针
+
+            // 构造函数
+            pub fn init(self: *Self, x: i32) void {
+                self.val = x;
+                self.next = null;
+                self.prev = null;
+            }
+        };
+    }
+    ```
+
+![常见链表种类](linked_list.assets/linkedlist_common_types.png)
+
+## 链表典型应用
+
+单向链表通常用于实现栈、队列、哈希表和图等数据结构。
+
+- **栈与队列**：当插入和删除操作都在链表的一端进行时，它表现出先进后出的的特性，对应栈；当插入操作在链表的一端进行，删除操作在链表的另一端进行，它表现出先进先出的特性，对应队列。
+- **哈希表**：链地址法是解决哈希冲突的主流方案之一，在该方案中，所有冲突的元素都会被放到一个链表中。
+- **图**：邻接表是表示图的一种常用方式，在其中，图的每个顶点都与一个链表相关联，链表中的每个元素都代表与该顶点相连的其他顶点。
+
+双向链表常被用于需要快速查找前一个和下一个元素的场景。
+
+- **高级数据结构**：比如在红黑树、B 树中，我们需要访问节点的父节点，这可以通过在节点中保存一个指向父节点的引用来实现，类似于双向链表。
+- **浏览器历史**：在网页浏览器中，当用户点击前进或后退按钮时，浏览器需要知道用户访问过的前一个和后一个网页。双向链表的特性使得这种操作变得简单。
+- **LRU 算法**：在缓存淘汰算法（LRU）中，我们需要快速找到最近最少使用的数据，以及支持快速地添加和删除节点。这时候使用双向链表就非常合适。
+
+循环链表常被用于需要周期性操作的场景，比如操作系统的资源调度。
+
+- **时间片轮转调度算法**：在操作系统中，时间片轮转调度算法是一种常见的 CPU 调度算法，它需要对一组进程进行循环。每个进程被赋予一个时间片，当时间片用完时，CPU 将切换到下一个进程。这种循环的操作就可以通过循环链表来实现。
+- **数据缓冲区**：在某些数据缓冲区的实现中，也可能会使用到循环链表。比如在音频、视频播放器中，数据流可能会被分成多个缓冲块并放入一个循环链表，以便实现无缝播放。

docs/zh/chapter_array_and_linkedlist/list.md

@@ -0,0 +1,933 @@
+# 列表
+
+**数组长度不可变导致实用性降低**。在实际中，我们可能事先无法确定需要存储多少数据，这使数组长度的选择变得困难。若长度过小，需要在持续添加数据时频繁扩容数组；若长度过大，则会造成内存空间的浪费。
+
+为解决此问题，出现了一种被称为「动态数组 dynamic array」的数据结构，即长度可变的数组，也常被称为「列表 list」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无须担心超过容量限制。
+
+## 列表常用操作
+
+### 初始化列表
+
+我们通常使用“无初始值”和“有初始值”这两种初始化方法。
+
+=== "Python"
+
+    ```python title="list.py"
+    # 初始化列表
+    # 无初始值
+    list1: list[int] = []
+    # 有初始值
+    list: list[int] = [1, 3, 2, 5, 4]
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+    /* 初始化列表 */
+    // 需注意，C++ 中 vector 即是本文描述的 list
+    // 无初始值
+    vector<int> list1;
+    // 有初始值
+    vector<int> list = { 1, 3, 2, 5, 4 };
+    ```
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 初始化列表 */
+    // 无初始值
+    List<Integer> list1 = new ArrayList<>();
+    // 有初始值（注意数组的元素类型需为 int[] 的包装类 Integer[]）
+    Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
+    List<Integer> list = new ArrayList<>(Arrays.asList(numbers));
+    ```
+
+=== "C#"
+
+    ```csharp title="list.cs"
+    /* 初始化列表 */
+    // 无初始值
+    List<int> list1 = new ();
+    // 有初始值
+    int[] numbers = new int[] { 1, 3, 2, 5, 4 };
+    List<int> list = numbers.ToList();
+    ```
+
+=== "Go"
+
+    ```go title="list_test.go"
+    /* 初始化列表 */
+    // 无初始值
+    list1 := []int
+    // 有初始值
+    list := []int{1, 3, 2, 5, 4}
+    ```
+
+=== "Swift"
+
+    ```swift title="list.swift"
+    /* 初始化列表 */
+    // 无初始值
+    let list1: [Int] = []
+    // 有初始值
+    var list = [1, 3, 2, 5, 4]
+    ```
+
+=== "JS"
+
+    ```javascript title="list.js"
+    /* 初始化列表 */
+    // 无初始值
+    const list1 = [];
+    // 有初始值
+    const list = [1, 3, 2, 5, 4];
+    ```
+
+=== "TS"
+
+    ```typescript title="list.ts"
+    /* 初始化列表 */
+    // 无初始值
+    const list1: number[] = [];
+    // 有初始值
+    const list: number[] = [1, 3, 2, 5, 4];
+    ```
+
+=== "Dart"
+
+    ```dart title="list.dart"
+    /* 初始化列表 */
+    // 无初始值
+    List<int> list1 = [];
+    // 有初始值
+    List<int> list = [1, 3, 2, 5, 4];
+    ```
+
+=== "Rust"
+
+    ```rust title="list.rs"
+    /* 初始化列表 */
+    // 无初始值
+    let list1: Vec<i32> = Vec::new();
+    // 有初始值
+    let list2: Vec<i32> = vec![1, 3, 2, 5, 4];
+    ```
+
+=== "C"
+
+    ```c title="list.c"
+    // C 未提供内置动态数组
+    ```
+
+=== "Zig"
+
+    ```zig title="list.zig"
+    // 初始化列表
+    var list = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer list.deinit();
+    try list.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
+    ```
+
+### 访问元素
+
+列表本质上是数组，因此可以在 $O(1)$ 时间内访问和更新元素，效率很高。
+
+=== "Python"
+
+    ```python title="list.py"
+    # 访问元素
+    num: int = list[1]  # 访问索引 1 处的元素
+
+    # 更新元素
+    list[1] = 0    # 将索引 1 处的元素更新为 0
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+    /* 访问元素 */
+    int num = list[1];  // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
+    ```
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 访问元素 */
+    int num = list.get(1);  // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list.set(1, 0);  // 将索引 1 处的元素更新为 0
+    ```
+
+=== "C#"
+
+    ```csharp title="list.cs"
+    /* 访问元素 */
+    int num = list[1];  // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
+    ```
+
+=== "Go"
+
+    ```go title="list_test.go"
+    /* 访问元素 */
+    num := list[1]  // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list[1] = 0     // 将索引 1 处的元素更新为 0
+    ```
+
+=== "Swift"
+
+    ```swift title="list.swift"
+    /* 访问元素 */
+    let num = list[1] // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list[1] = 0 // 将索引 1 处的元素更新为 0
+    ```
+
+=== "JS"
+
+    ```javascript title="list.js"
+    /* 访问元素 */
+    const num = list[1];  // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
+    ```
+
+=== "TS"
+
+    ```typescript title="list.ts"
+    /* 访问元素 */
+    const num: number = list[1];  // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
+    ```
+
+=== "Dart"
+
+    ```dart title="list.dart"
+    /* 访问元素 */
+    int num = list[1];  // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
+    ```
+
+=== "Rust"
+
+    ```rust title="list.rs"
+    /* 访问元素 */
+    let num: i32 = list[1];    // 访问索引 1 处的元素
+    /* 更新元素 */
+    list[1] = 0;               // 将索引 1 处的元素更新为 0
+    ```
+
+=== "C"
+
+    ```c title="list.c"
+    // C 未提供内置动态数组
+    ```
+
+=== "Zig"
+
+    ```zig title="list.zig"
+    // 访问元素
+    var num = list.items[1]; // 访问索引 1 处的元素
+
+    // 更新元素
+    list.items[1] = 0; // 将索引 1 处的元素更新为 0  
+    ```
+
+### 插入与删除元素
+
+相较于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但插入和删除元素的效率仍与数组相同，时间复杂度为 $O(n)$ 。
+
+=== "Python"
+
+    ```python title="list.py"
+    # 清空列表
+    list.clear()
+
+    # 尾部添加元素
+    list.append(1)
+    list.append(3)
+    list.append(2)
+    list.append(5)
+    list.append(4)
+
+    # 中间插入元素
+    list.insert(3, 6)  # 在索引 3 处插入数字 6
+
+    # 删除元素
+    list.pop(3)        # 删除索引 3 处的元素
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+    /* 清空列表 */
+    list.clear();
+
+    /* 尾部添加元素 */
+    list.push_back(1);
+    list.push_back(3);
+    list.push_back(2);
+    list.push_back(5);
+    list.push_back(4);
+
+    /* 中间插入元素 */
+    list.insert(list.begin() + 3, 6);  // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.erase(list.begin() + 3);      // 删除索引 3 处的元素
+    ```
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 清空列表 */
+    list.clear();
+
+    /* 尾部添加元素 */
+    list.add(1);
+    list.add(3);
+    list.add(2);
+    list.add(5);
+    list.add(4);
+
+    /* 中间插入元素 */
+    list.add(3, 6);  // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.remove(3);  // 删除索引 3 处的元素
+    ```
+
+=== "C#"
+
+    ```csharp title="list.cs"
+    /* 清空列表 */
+    list.Clear();
+
+    /* 尾部添加元素 */
+    list.Add(1);
+    list.Add(3);
+    list.Add(2);
+    list.Add(5);
+    list.Add(4);
+
+    /* 中间插入元素 */
+    list.Insert(3, 6);
+
+    /* 删除元素 */
+    list.RemoveAt(3);
+    ```
+
+=== "Go"
+
+    ```go title="list_test.go"
+    /* 清空列表 */
+    list = nil
+
+    /* 尾部添加元素 */
+    list = append(list, 1)
+    list = append(list, 3)
+    list = append(list, 2)
+    list = append(list, 5)
+    list = append(list, 4)
+
+    /* 中间插入元素 */
+    list = append(list[:3], append([]int{6}, list[3:]...)...) // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list = append(list[:3], list[4:]...) // 删除索引 3 处的元素
+    ```
+
+=== "Swift"
+
+    ```swift title="list.swift"
+    /* 清空列表 */
+    list.removeAll()
+
+    /* 尾部添加元素 */
+    list.append(1)
+    list.append(3)
+    list.append(2)
+    list.append(5)
+    list.append(4)
+
+    /* 中间插入元素 */
+    list.insert(6, at: 3) // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.remove(at: 3) // 删除索引 3 处的元素
+    ```
+
+=== "JS"
+
+    ```javascript title="list.js"
+    /* 清空列表 */
+    list.length = 0;
+
+    /* 尾部添加元素 */
+    list.push(1);
+    list.push(3);
+    list.push(2);
+    list.push(5);
+    list.push(4);
+
+    /* 中间插入元素 */
+    list.splice(3, 0, 6);
+
+    /* 删除元素 */
+    list.splice(3, 1);
+    ```
+
+=== "TS"
+
+    ```typescript title="list.ts"
+    /* 清空列表 */
+    list.length = 0;
+
+    /* 尾部添加元素 */
+    list.push(1);
+    list.push(3);
+    list.push(2);
+    list.push(5);
+    list.push(4);
+
+    /* 中间插入元素 */
+    list.splice(3, 0, 6);
+
+    /* 删除元素 */
+    list.splice(3, 1);
+    ```
+
+=== "Dart"
+
+    ```dart title="list.dart"
+    /* 清空列表 */
+    list.clear();
+
+    /* 尾部添加元素 */
+    list.add(1);
+    list.add(3);
+    list.add(2);
+    list.add(5);
+    list.add(4);
+
+    /* 中间插入元素 */
+    list.insert(3, 6); // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.removeAt(3); // 删除索引 3 处的元素
+    ```
+
+=== "Rust"
+
+    ```rust title="list.rs"
+    /* 清空列表 */
+    list.clear();
+
+    /* 尾部添加元素 */
+    list.push(1);
+    list.push(3);
+    list.push(2);
+    list.push(5);
+    list.push(4);
+
+    /* 中间插入元素 */
+    list.insert(3, 6);  // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.remove(3);    // 删除索引 3 处的元素
+    ```
+
+=== "C"
+
+    ```c title="list.c"
+    // C 未提供内置动态数组
+    ```
+
+=== "Zig"
+
+    ```zig title="list.zig"
+    // 清空列表
+    list.clearRetainingCapacity();
+
+    // 尾部添加元素
+    try list.append(1);
+    try list.append(3);
+    try list.append(2);
+    try list.append(5);
+    try list.append(4);
+
+    // 中间插入元素
+    try list.insert(3, 6); // 在索引 3 处插入数字 6
+
+    // 删除元素
+    _ = list.orderedRemove(3); // 删除索引 3 处的元素
+    ```
+
+### 遍历列表
+
+与数组一样，列表可以根据索引遍历，也可以直接遍历各元素。
+
+=== "Python"
+
+    ```python title="list.py"
+    # 通过索引遍历列表
+    count = 0
+    for i in range(len(list)):
+        count += 1
+
+    # 直接遍历列表元素
+    count = 0
+    for n in list:
+        count += 1
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+    /* 通过索引遍历列表 */
+    int count = 0;
+    for (int i = 0; i < list.size(); i++) {
+        count++;
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0;
+    for (int n : list) {
+        count++;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 通过索引遍历列表 */
+    int count = 0;
+    for (int i = 0; i < list.size(); i++) {
+        count++;
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0;
+    for (int n : list) {
+        count++;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="list.cs"
+    /* 通过索引遍历列表 */
+    int count = 0;
+    for (int i = 0; i < list.Count; i++) {
+        count++;
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0;
+    foreach (int n in list) {
+        count++;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="list_test.go"
+    /* 通过索引遍历列表 */
+    count := 0
+    for i := 0; i < len(list); i++ {
+        count++
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0
+    for range list {
+        count++
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="list.swift"
+    /* 通过索引遍历列表 */
+    var count = 0
+    for _ in list.indices {
+        count += 1
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0
+    for _ in list {
+        count += 1
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="list.js"
+    /* 通过索引遍历列表 */
+    let count = 0;
+    for (let i = 0; i < list.length; i++) {
+        count++;
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0;
+    for (const n of list) {
+        count++;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="list.ts"
+    /* 通过索引遍历列表 */
+    let count = 0;
+    for (let i = 0; i < list.length; i++) {
+        count++;
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0;
+    for (const n of list) {
+        count++;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="list.dart"
+    /* 通过索引遍历列表 */
+    int count = 0;
+    for (int i = 0; i < list.length; i++) {
+        count++;
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0;
+    for (int n in list) {
+        count++;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="list.rs"
+    /* 通过索引遍历列表 */
+    let mut count = 0;
+    for (index, value) in list.iter().enumerate() {
+        count += 1;
+    }
+
+    /* 直接遍历列表元素 */
+    let mut count = 0;
+    for value in list.iter() {
+        count += 1;
+    }
+    ```
+
+=== "C"
+
+    ```c title="list.c"
+    // C 未提供内置动态数组
+    ```
+
+=== "Zig"
+
+    ```zig title="list.zig"
+    // 通过索引遍历列表
+    var count: i32 = 0;
+    var i: i32 = 0;
+    while (i < list.items.len) : (i += 1) {
+        count += 1;
+    }
+
+    // 直接遍历列表元素
+    count = 0;
+    for (list.items) |_| {
+        count += 1;
+    }
+    ```
+
+### 拼接列表
+
+给定一个新列表 `list1` ，我们可以将该列表拼接到原列表的尾部。
+
+=== "Python"
+
+    ```python title="list.py"
+    # 拼接两个列表
+    list1: list[int] = [6, 8, 7, 10, 9]
+    list += list1  # 将列表 list1 拼接到 list 之后
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+    /* 拼接两个列表 */
+    vector<int> list1 = { 6, 8, 7, 10, 9 };
+    // 将列表 list1 拼接到 list 之后
+    list.insert(list.end(), list1.begin(), list1.end());
+    ```
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 拼接两个列表 */
+    List<Integer> list1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));
+    list.addAll(list1);  // 将列表 list1 拼接到 list 之后
+    ```
+
+=== "C#"
+
+    ```csharp title="list.cs"
+    /* 拼接两个列表 */
+    List<int> list1 = new() { 6, 8, 7, 10, 9 };
+    list.AddRange(list1);  // 将列表 list1 拼接到 list 之后
+    ```
+
+=== "Go"
+
+    ```go title="list_test.go"
+    /* 拼接两个列表 */
+    list1 := []int{6, 8, 7, 10, 9}
+    list = append(list, list1...)  // 将列表 list1 拼接到 list 之后
+    ```
+
+=== "Swift"
+
+    ```swift title="list.swift"
+    /* 拼接两个列表 */
+    let list1 = [6, 8, 7, 10, 9]
+    list.append(contentsOf: list1) // 将列表 list1 拼接到 list 之后
+    ```
+
+=== "JS"
+
+    ```javascript title="list.js"
+    /* 拼接两个列表 */
+    const list1 = [6, 8, 7, 10, 9];
+    list.push(...list1);  // 将列表 list1 拼接到 list 之后
+    ```
+
+=== "TS"
+
+    ```typescript title="list.ts"
+    /* 拼接两个列表 */
+    const list1: number[] = [6, 8, 7, 10, 9];
+    list.push(...list1);  // 将列表 list1 拼接到 list 之后
+    ```
+
+=== "Dart"
+
+    ```dart title="list.dart"
+    /* 拼接两个列表 */
+    List<int> list1 = [6, 8, 7, 10, 9];
+    list.addAll(list1);  // 将列表 list1 拼接到 list 之后
+    ```
+
+=== "Rust"
+
+    ```rust title="list.rs"
+    /* 拼接两个列表 */
+    let list1: Vec<i32> = vec![6, 8, 7, 10, 9];
+    list.extend(list1);
+    ```
+
+=== "C"
+
+    ```c title="list.c"
+    // C 未提供内置动态数组
+    ```
+
+=== "Zig"
+
+    ```zig title="list.zig"
+    // 拼接两个列表
+    var list1 = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer list1.deinit();
+    try list1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });
+    try list.insertSlice(list.items.len, list1.items); // 将列表 list1 拼接到 list 之后
+    ```
+
+### 排序列表
+
+完成列表排序后，我们便可以使用在数组类算法题中经常考察的“二分查找”和“双指针”算法。
+
+=== "Python"
+
+    ```python title="list.py"
+    # 排序列表
+    list.sort()  # 排序后，列表元素从小到大排列
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+    /* 排序列表 */
+    sort(list.begin(), list.end());  // 排序后，列表元素从小到大排列
+    ```
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 排序列表 */
+    Collections.sort(list);  // 排序后，列表元素从小到大排列
+    ```
+
+=== "C#"
+
+    ```csharp title="list.cs"
+    /* 排序列表 */
+    list.Sort(); // 排序后，列表元素从小到大排列
+    ```
+
+=== "Go"
+
+    ```go title="list_test.go"
+    /* 排序列表 */
+    sort.Ints(list)  // 排序后，列表元素从小到大排列
+    ```
+
+=== "Swift"
+
+    ```swift title="list.swift"
+    /* 排序列表 */
+    list.sort() // 排序后，列表元素从小到大排列
+    ```
+
+=== "JS"
+
+    ```javascript title="list.js"
+    /* 排序列表 */  
+    list.sort((a, b) => a - b);  // 排序后，列表元素从小到大排列
+    ```
+
+=== "TS"
+
+    ```typescript title="list.ts"
+    /* 排序列表 */
+    list.sort((a, b) => a - b);  // 排序后，列表元素从小到大排列
+    ```
+
+=== "Dart"
+
+    ```dart title="list.dart"
+    /* 排序列表 */
+    list.sort(); // 排序后，列表元素从小到大排列
+    ```
+
+=== "Rust"
+
+    ```rust title="list.rs"
+    /* 排序列表 */
+    list.sort(); // 排序后，列表元素从小到大排列
+    ```
+
+=== "C"
+
+    ```c title="list.c"
+    // C 未提供内置动态数组
+    ```
+
+=== "Zig"
+
+    ```zig title="list.zig"
+    // 排序列表
+    std.sort.sort(i32, list.items, {}, comptime std.sort.asc(i32));
+    ```
+
+## 列表实现
+
+许多编程语言都提供内置的列表，例如 Java、C++、Python 等。它们的实现比较复杂，各个参数的设定也非常有考究，例如初始容量、扩容倍数等。感兴趣的读者可以查阅源码进行学习。
+
+为了加深对列表工作原理的理解，我们尝试实现一个简易版列表，包括以下三个重点设计。
+
+- **初始容量**：选取一个合理的数组初始容量。在本示例中，我们选择 10 作为初始容量。
+- **数量记录**：声明一个变量 `size` ，用于记录列表当前元素数量，并随着元素插入和删除实时更新。根据此变量，我们可以定位列表尾部，以及判断是否需要扩容。
+- **扩容机制**：若插入元素时列表容量已满，则需要进行扩容。首先根据扩容倍数创建一个更大的数组，再将当前数组的所有元素依次移动至新数组。在本示例中，我们规定每次将数组扩容至之前的 2 倍。
+
+=== "Python"
+
+    ```python title="my_list.py"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "C++"
+
+    ```cpp title="my_list.cpp"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "Java"
+
+    ```java title="my_list.java"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "C#"
+
+    ```csharp title="my_list.cs"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "Go"
+
+    ```go title="my_list.go"
+    [class]{myList}-[func]{}
+    ```
+
+=== "Swift"
+
+    ```swift title="my_list.swift"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "JS"
+
+    ```javascript title="my_list.js"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "TS"
+
+    ```typescript title="my_list.ts"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "Dart"
+
+    ```dart title="my_list.dart"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "Rust"
+
+    ```rust title="my_list.rs"
+    [class]{MyList}-[func]{}
+    ```
+
+=== "C"
+
+    ```c title="my_list.c"
+    [class]{myList}-[func]{}
+    ```
+
+=== "Zig"
+
+    ```zig title="my_list.zig"
+    [class]{MyList}-[func]{}
+    ```

docs/zh/chapter_array_and_linkedlist/summary.md

@@ -0,0 +1,68 @@
+# 小结
+
+### 重点回顾
+
+- 数组和链表是两种基本的数据结构，分别代表数据在计算机内存中的两种存储方式：连续空间存储和分散空间存储。两者的特点呈现出互补的特性。
+- 数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变。
+- 链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、循环链表、双向链表。
+- 动态数组，又称列表，是基于数组实现的一种数据结构。它保留了数组的优势，同时可以灵活调整长度。列表的出现极大地提高了数组的易用性，但可能导致部分内存空间浪费。
+
+### 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/zh/chapter_backtracking/backtracking_algorithm.md

@@ -0,0 +1,849 @@
+# 回溯算法
+
+「回溯算法 backtracking algorithm」是一种通过穷举来解决问题的方法，它的核心思想是从一个初始状态出发，暴力搜索所有可能的解决方案，当遇到正确的解则将其记录，直到找到解或者尝试了所有可能的选择都无法找到解为止。
+
+回溯算法通常采用“深度优先搜索”来遍历解空间。在二叉树章节中，我们提到前序、中序和后序遍历都属于深度优先搜索。接下来，我们利用前序遍历构造一个回溯问题，逐步了解回溯算法的工作原理。
+
+!!! question "例题一"
+
+    给定一个二叉树，搜索并记录所有值为 $7$ 的节点，请返回节点列表。
+
+对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 $7$ ，若是则将该节点的值加入到结果列表 `res` 之中。相关过程实现如下图和以下代码所示。
+
+=== "Python"
+
+    ```python title="preorder_traversal_i_compact.py"
+    [class]{}-[func]{pre_order}
+    ```
+
+=== "C++"
+
+    ```cpp title="preorder_traversal_i_compact.cpp"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Java"
+
+    ```java title="preorder_traversal_i_compact.java"
+    [class]{preorder_traversal_i_compact}-[func]{preOrder}
+    ```
+
+=== "C#"
+
+    ```csharp title="preorder_traversal_i_compact.cs"
+    [class]{preorder_traversal_i_compact}-[func]{preOrder}
+    ```
+
+=== "Go"
+
+    ```go title="preorder_traversal_i_compact.go"
+    [class]{}-[func]{preOrderI}
+    ```
+
+=== "Swift"
+
+    ```swift title="preorder_traversal_i_compact.swift"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "JS"
+
+    ```javascript title="preorder_traversal_i_compact.js"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "TS"
+
+    ```typescript title="preorder_traversal_i_compact.ts"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Dart"
+
+    ```dart title="preorder_traversal_i_compact.dart"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Rust"
+
+    ```rust title="preorder_traversal_i_compact.rs"
+    [class]{}-[func]{pre_order}
+    ```
+
+=== "C"
+
+    ```c title="preorder_traversal_i_compact.c"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Zig"
+
+    ```zig title="preorder_traversal_i_compact.zig"
+    [class]{}-[func]{preOrder}
+    ```
+
+![在前序遍历中搜索节点](backtracking_algorithm.assets/preorder_find_nodes.png)
+
+## 尝试与回退
+
+**之所以称之为回溯算法，是因为该算法在搜索解空间时会采用“尝试”与“回退”的策略**。当算法在搜索过程中遇到某个状态无法继续前进或无法得到满足条件的解时，它会撤销上一步的选择，退回到之前的状态，并尝试其他可能的选择。
+
+对于例题一，访问每个节点都代表一次“尝试”，而越过叶结点或返回父节点的 `return` 则表示“回退”。
+
+值得说明的是，**回退并不仅仅包括函数返回**。为解释这一点，我们对例题一稍作拓展。
+
+!!! question "例题二"
+
+    在二叉树中搜索所有值为 $7$ 的节点，**请返回根节点到这些节点的路径**。
+
+在例题一代码的基础上，我们需要借助一个列表 `path` 记录访问过的节点路径。当访问到值为 $7$ 的节点时，则复制 `path` 并添加进结果列表 `res` 。遍历完成后，`res` 中保存的就是所有的解。
+
+=== "Python"
+
+    ```python title="preorder_traversal_ii_compact.py"
+    [class]{}-[func]{pre_order}
+    ```
+
+=== "C++"
+
+    ```cpp title="preorder_traversal_ii_compact.cpp"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Java"
+
+    ```java title="preorder_traversal_ii_compact.java"
+    [class]{preorder_traversal_ii_compact}-[func]{preOrder}
+    ```
+
+=== "C#"
+
+    ```csharp title="preorder_traversal_ii_compact.cs"
+    [class]{preorder_traversal_ii_compact}-[func]{preOrder}
+    ```
+
+=== "Go"
+
+    ```go title="preorder_traversal_ii_compact.go"
+    [class]{}-[func]{preOrderII}
+    ```
+
+=== "Swift"
+
+    ```swift title="preorder_traversal_ii_compact.swift"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "JS"
+
+    ```javascript title="preorder_traversal_ii_compact.js"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "TS"
+
+    ```typescript title="preorder_traversal_ii_compact.ts"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Dart"
+
+    ```dart title="preorder_traversal_ii_compact.dart"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Rust"
+
+    ```rust title="preorder_traversal_ii_compact.rs"
+    [class]{}-[func]{pre_order}
+    ```
+
+=== "C"
+
+    ```c title="preorder_traversal_ii_compact.c"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Zig"
+
+    ```zig title="preorder_traversal_ii_compact.zig"
+    [class]{}-[func]{preOrder}
+    ```
+
+在每次“尝试”中，我们通过将当前节点添加进 `path` 来记录路径；而在“回退”前，我们需要将该节点从 `path` 中弹出，**以恢复本次尝试之前的状态**。
+
+观察下图所示的过程，**我们可以将尝试和回退理解为“前进”与“撤销”**，两个操作是互为逆向的。
+
+=== "<1>"
+    ![尝试与回退](backtracking_algorithm.assets/preorder_find_paths_step1.png)
+
+=== "<2>"
+    ![preorder_find_paths_step2](backtracking_algorithm.assets/preorder_find_paths_step2.png)
+
+=== "<3>"
+    ![preorder_find_paths_step3](backtracking_algorithm.assets/preorder_find_paths_step3.png)
+
+=== "<4>"
+    ![preorder_find_paths_step4](backtracking_algorithm.assets/preorder_find_paths_step4.png)
+
+=== "<5>"
+    ![preorder_find_paths_step5](backtracking_algorithm.assets/preorder_find_paths_step5.png)
+
+=== "<6>"
+    ![preorder_find_paths_step6](backtracking_algorithm.assets/preorder_find_paths_step6.png)
+
+=== "<7>"
+    ![preorder_find_paths_step7](backtracking_algorithm.assets/preorder_find_paths_step7.png)
+
+=== "<8>"
+    ![preorder_find_paths_step8](backtracking_algorithm.assets/preorder_find_paths_step8.png)
+
+=== "<9>"
+    ![preorder_find_paths_step9](backtracking_algorithm.assets/preorder_find_paths_step9.png)
+
+=== "<10>"
+    ![preorder_find_paths_step10](backtracking_algorithm.assets/preorder_find_paths_step10.png)
+
+=== "<11>"
+    ![preorder_find_paths_step11](backtracking_algorithm.assets/preorder_find_paths_step11.png)
+
+## 剪枝
+
+复杂的回溯问题通常包含一个或多个约束条件，**约束条件通常可用于“剪枝”**。
+
+!!! question "例题三"
+
+    在二叉树中搜索所有值为 $7$ 的节点，请返回根节点到这些节点的路径，**并要求路径中不包含值为 $3$ 的节点**。
+
+为了满足以上约束条件，**我们需要添加剪枝操作**：在搜索过程中，若遇到值为 $3$ 的节点，则提前返回，停止继续搜索。
+
+=== "Python"
+
+    ```python title="preorder_traversal_iii_compact.py"
+    [class]{}-[func]{pre_order}
+    ```
+
+=== "C++"
+
+    ```cpp title="preorder_traversal_iii_compact.cpp"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Java"
+
+    ```java title="preorder_traversal_iii_compact.java"
+    [class]{preorder_traversal_iii_compact}-[func]{preOrder}
+    ```
+
+=== "C#"
+
+    ```csharp title="preorder_traversal_iii_compact.cs"
+    [class]{preorder_traversal_iii_compact}-[func]{preOrder}
+    ```
+
+=== "Go"
+
+    ```go title="preorder_traversal_iii_compact.go"
+    [class]{}-[func]{preOrderIII}
+    ```
+
+=== "Swift"
+
+    ```swift title="preorder_traversal_iii_compact.swift"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "JS"
+
+    ```javascript title="preorder_traversal_iii_compact.js"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "TS"
+
+    ```typescript title="preorder_traversal_iii_compact.ts"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Dart"
+
+    ```dart title="preorder_traversal_iii_compact.dart"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Rust"
+
+    ```rust title="preorder_traversal_iii_compact.rs"
+    [class]{}-[func]{pre_order}
+    ```
+
+=== "C"
+
+    ```c title="preorder_traversal_iii_compact.c"
+    [class]{}-[func]{preOrder}
+    ```
+
+=== "Zig"
+
+    ```zig title="preorder_traversal_iii_compact.zig"
+    [class]{}-[func]{preOrder}
+    ```
+
+剪枝是一个非常形象的名词。如下图所示，在搜索过程中，**我们“剪掉”了不满足约束条件的搜索分支**，避免许多无意义的尝试，从而提高了搜索效率。
+
+![根据约束条件剪枝](backtracking_algorithm.assets/preorder_find_constrained_paths.png)
+
+## 框架代码
+
+接下来，我们尝试将回溯的“尝试、回退、剪枝”的主体框架提炼出来，提升代码的通用性。
+
+在以下框架代码中，`state` 表示问题的当前状态，`choices` 表示当前状态下可以做出的选择。
+
+=== "Python"
+
+    ```python title=""
+    def backtrack(state: State, choices: list[choice], res: list[state]):
+        """回溯算法框架"""
+        # 判断是否为解
+        if is_solution(state):
+            # 记录解
+            record_solution(state, res)
+            # 停止继续搜索
+            return
+        # 遍历所有选择
+        for choice in choices:
+            # 剪枝：判断选择是否合法
+            if is_valid(state, choice):
+                # 尝试：做出选择，更新状态
+                make_choice(state, choice)
+                backtrack(state, choices, res)
+                # 回退：撤销选择，恢复到之前的状态
+                undo_choice(state, choice)
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 回溯算法框架 */
+    void backtrack(State *state, vector<Choice *> &choices, vector<State *> &res) {
+        // 判断是否为解
+        if (isSolution(state)) {
+            // 记录解
+            recordSolution(state, res);
+            // 停止继续搜索
+            return;
+        }
+        // 遍历所有选择
+        for (Choice choice : choices) {
+            // 剪枝：判断选择是否合法
+            if (isValid(state, choice)) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* 回溯算法框架 */
+    void backtrack(State state, List<Choice> choices, List<State> res) {
+        // 判断是否为解
+        if (isSolution(state)) {
+            // 记录解
+            recordSolution(state, res);
+            // 停止继续搜索
+            return;
+        }
+        // 遍历所有选择
+        for (Choice choice : choices) {
+            // 剪枝：判断选择是否合法
+            if (isValid(state, choice)) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 回溯算法框架 */
+    void backtrack(State state, List<Choice> choices, List<State> res) {
+        // 判断是否为解
+        if (isSolution(state)) {
+            // 记录解
+            recordSolution(state, res);
+            // 停止继续搜索
+            return;
+        }
+        // 遍历所有选择
+        foreach (Choice choice in choices) {
+            // 剪枝：判断选择是否合法
+            if (isValid(state, choice)) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 回溯算法框架 */
+    func backtrack(state *State, choices []Choice, res *[]State) {
+        // 判断是否为解
+        if isSolution(state) {
+            // 记录解
+            recordSolution(state, res)
+            // 停止继续搜索
+            return
+        }
+        // 遍历所有选择
+        for _, choice := range choices {
+            // 剪枝：判断选择是否合法
+            if isValid(state, choice) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state, choice)
+                backtrack(state, choices, res)
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state, choice)
+            }
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* 回溯算法框架 */
+    func backtrack(state: inout State, choices: [Choice], res: inout [State]) {
+        // 判断是否为解
+        if isSolution(state: state) {
+            // 记录解
+            recordSolution(state: state, res: &res)
+            // 停止继续搜索
+            return
+        }
+        // 遍历所有选择
+        for choice in choices {
+            // 剪枝：判断选择是否合法
+            if isValid(state: state, choice: choice) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state: &state, choice: choice)
+                backtrack(state: &state, choices: choices, res: &res)
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state: &state, choice: choice)
+            }
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* 回溯算法框架 */
+    function backtrack(state, choices, res) {
+        // 判断是否为解
+        if (isSolution(state)) {
+            // 记录解
+            recordSolution(state, res);
+            // 停止继续搜索
+            return;
+        }
+        // 遍历所有选择
+        for (let choice of choices) {
+            // 剪枝：判断选择是否合法
+            if (isValid(state, choice)) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* 回溯算法框架 */
+    function backtrack(state: State, choices: Choice[], res: State[]): void {
+        // 判断是否为解
+        if (isSolution(state)) {
+            // 记录解
+            recordSolution(state, res);
+            // 停止继续搜索
+            return;
+        }
+        // 遍历所有选择
+        for (let choice of choices) {
+            // 剪枝：判断选择是否合法
+            if (isValid(state, choice)) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* 回溯算法框架 */
+    void backtrack(State state, List<Choice>, List<State> res) {
+      // 判断是否为解
+      if (isSolution(state)) {
+        // 记录解
+        recordSolution(state, res);
+        // 停止继续搜索
+        return;
+      }
+      // 遍历所有选择
+      for (Choice choice in choices) {
+        // 剪枝：判断选择是否合法
+        if (isValid(state, choice)) {
+          // 尝试：做出选择，更新状态
+          makeChoice(state, choice);
+          backtrack(state, choices, res);
+          // 回退：撤销选择，恢复到之前的状态
+          undoChoice(state, choice);
+        }
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    /* 回溯算法框架 */
+    fn backtrack(state: &mut State, choices: &Vec<Choice>, res: &mut Vec<State>) {
+        // 判断是否为解
+        if is_solution(state) {
+            // 记录解
+            record_solution(state, res);
+            // 停止继续搜索
+            return;
+        }
+        // 遍历所有选择
+        for choice in choices {
+            // 剪枝：判断选择是否合法
+            if is_valid(state, choice) {
+                // 尝试：做出选择，更新状态
+                make_choice(state, choice);
+                backtrack(state, choices, res);
+                // 回退：撤销选择，恢复到之前的状态
+                undo_choice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* 回溯算法框架 */
+    void backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {
+        // 判断是否为解
+        if (isSolution(state)) {
+            // 记录解
+            recordSolution(state, res, numRes);
+            // 停止继续搜索
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < numChoices; i++) {
+            // 剪枝：判断选择是否合法
+            if (isValid(state, &choices[i])) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state, &choices[i]);
+                backtrack(state, choices, numChoices, res, numRes);
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state, &choices[i]);
+            }
+        }
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+
+    ```
+
+接下来，我们基于框架代码来解决例题三。状态 `state` 为节点遍历路径，选择 `choices` 为当前节点的左子节点和右子节点，结果 `res` 是路径列表。
+
+=== "Python"
+
+    ```python title="preorder_traversal_iii_template.py"
+    [class]{}-[func]{is_solution}
+
+    [class]{}-[func]{record_solution}
+
+    [class]{}-[func]{is_valid}
+
+    [class]{}-[func]{make_choice}
+
+    [class]{}-[func]{undo_choice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+=== "C++"
+
+    ```cpp title="preorder_traversal_iii_template.cpp"
+    [class]{}-[func]{isSolution}
+
+    [class]{}-[func]{recordSolution}
+
+    [class]{}-[func]{isValid}
+
+    [class]{}-[func]{makeChoice}
+
+    [class]{}-[func]{undoChoice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+=== "Java"
+
+    ```java title="preorder_traversal_iii_template.java"
+    [class]{preorder_traversal_iii_template}-[func]{isSolution}
+
+    [class]{preorder_traversal_iii_template}-[func]{recordSolution}
+
+    [class]{preorder_traversal_iii_template}-[func]{isValid}
+
+    [class]{preorder_traversal_iii_template}-[func]{makeChoice}
+
+    [class]{preorder_traversal_iii_template}-[func]{undoChoice}
+
+    [class]{preorder_traversal_iii_template}-[func]{backtrack}
+    ```
+
+=== "C#"
+
+    ```csharp title="preorder_traversal_iii_template.cs"
+    [class]{preorder_traversal_iii_template}-[func]{isSolution}
+
+    [class]{preorder_traversal_iii_template}-[func]{recordSolution}
+
+    [class]{preorder_traversal_iii_template}-[func]{isValid}
+
+    [class]{preorder_traversal_iii_template}-[func]{makeChoice}
+
+    [class]{preorder_traversal_iii_template}-[func]{undoChoice}
+
+    [class]{preorder_traversal_iii_template}-[func]{backtrack}
+    ```
+
+=== "Go"
+
+    ```go title="preorder_traversal_iii_template.go"
+    [class]{}-[func]{isSolution}
+
+    [class]{}-[func]{recordSolution}
+
+    [class]{}-[func]{isValid}
+
+    [class]{}-[func]{makeChoice}
+
+    [class]{}-[func]{undoChoice}
+
+    [class]{}-[func]{backtrackIII}
+    ```
+
+=== "Swift"
+
+    ```swift title="preorder_traversal_iii_template.swift"
+    [class]{}-[func]{isSolution}
+
+    [class]{}-[func]{recordSolution}
+
+    [class]{}-[func]{isValid}
+
+    [class]{}-[func]{makeChoice}
+
+    [class]{}-[func]{undoChoice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+=== "JS"
+
+    ```javascript title="preorder_traversal_iii_template.js"
+    [class]{}-[func]{isSolution}
+
+    [class]{}-[func]{recordSolution}
+
+    [class]{}-[func]{isValid}
+
+    [class]{}-[func]{makeChoice}
+
+    [class]{}-[func]{undoChoice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+=== "TS"
+
+    ```typescript title="preorder_traversal_iii_template.ts"
+    [class]{}-[func]{isSolution}
+
+    [class]{}-[func]{recordSolution}
+
+    [class]{}-[func]{isValid}
+
+    [class]{}-[func]{makeChoice}
+
+    [class]{}-[func]{undoChoice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+=== "Dart"
+
+    ```dart title="preorder_traversal_iii_template.dart"
+    [class]{}-[func]{isSolution}
+
+    [class]{}-[func]{recordSolution}
+
+    [class]{}-[func]{isValid}
+
+    [class]{}-[func]{makeChoice}
+
+    [class]{}-[func]{undoChoice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+=== "Rust"
+
+    ```rust title="preorder_traversal_iii_template.rs"
+    [class]{}-[func]{is_solution}
+
+    [class]{}-[func]{record_solution}
+
+    [class]{}-[func]{is_valid}
+
+    [class]{}-[func]{make_choice}
+
+    [class]{}-[func]{undo_choice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+=== "C"
+
+    ```c title="preorder_traversal_iii_template.c"
+    [class]{}-[func]{isSolution}
+
+    [class]{}-[func]{recordSolution}
+
+    [class]{}-[func]{isValid}
+
+    [class]{}-[func]{makeChoice}
+
+    [class]{}-[func]{undoChoice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+=== "Zig"
+
+    ```zig title="preorder_traversal_iii_template.zig"
+    [class]{}-[func]{isSolution}
+
+    [class]{}-[func]{recordSolution}
+
+    [class]{}-[func]{isValid}
+
+    [class]{}-[func]{makeChoice}
+
+    [class]{}-[func]{undoChoice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
+根据题意，我们在找到值为 $7$ 的节点后应该继续搜索，**因此需要将记录解之后的 `return` 语句删除**。下图对比了保留或删除 `return` 语句的搜索过程。
+
+![保留与删除 return 的搜索过程对比](backtracking_algorithm.assets/backtrack_remove_return_or_not.png)
+
+相比基于前序遍历的代码实现，基于回溯算法框架的代码实现虽然显得啰嗦，但通用性更好。实际上，**许多回溯问题都可以在该框架下解决**。我们只需根据具体问题来定义 `state` 和 `choices` ，并实现框架中的各个方法即可。
+
+## 常用术语
+
+为了更清晰地分析算法问题，我们总结一下回溯算法中常用术语的含义，并对照例题三给出对应示例。
+
+<p align="center"> 表 <id> &nbsp; 常见的回溯算法术语 </p>
+
+| 名词                | 定义                                                                       | 例题三                                                               |
+| ------------------- | -------------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| 解 Solution         | 解是满足问题特定条件的答案，可能有一个或多个                               | 根节点到节点 $7$ 的满足约束条件的所有路径                            |
+| 约束条件 Constraint | 约束条件是问题中限制解的可行性的条件，通常用于剪枝                         | 路径中不包含节点 $3$                                                 |
+| 状态 State          | 状态表示问题在某一时刻的情况，包括已经做出的选择                           | 当前已访问的节点路径，即 `path` 节点列表                             |
+| 尝试 Attempt        | 尝试是根据可用选择来探索解空间的过程，包括做出选择，更新状态，检查是否为解 | 递归访问左（右）子节点，将节点添加进 `path` ，判断节点的值是否为 $7$ |
+| 回退 Backtracking   | 回退指遇到不满足约束条件的状态时，撤销前面做出的选择，回到上一个状态       | 当越过叶结点、结束结点访问、遇到值为 $3$ 的节点时终止搜索，函数返回  |
+| 剪枝 Pruning        | 剪枝是根据问题特性和约束条件避免无意义的搜索路径的方法，可提高搜索效率     | 当遇到值为 $3$ 的节点时，则终止继续搜索                              |
+
+!!! tip
+
+    问题、解、状态等概念是通用的，在分治、回溯、动态规划、贪心等算法中都有涉及。
+
+## 优势与局限性
+
+回溯算法本质上是一种深度优先搜索算法，它尝试所有可能的解决方案直到找到满足条件的解。这种方法的优势在于它能够找到所有可能的解决方案，而且在合理的剪枝操作下，具有很高的效率。
+
+然而，在处理大规模或者复杂问题时，**回溯算法的运行效率可能难以接受**。
+
+- **时间**：回溯算法通常需要遍历状态空间的所有可能，时间复杂度可以达到指数阶或阶乘阶。
+- **空间**：在递归调用中需要保存当前的状态（例如路径、用于剪枝的辅助变量等），当深度很大时，空间需求可能会变得很大。
+
+即便如此，**回溯算法仍然是某些搜索问题和约束满足问题的最佳解决方案**。对于这些问题，由于无法预测哪些选择可生成有效的解，因此我们必须对所有可能的选择进行遍历。在这种情况下，**关键是如何进行效率优化**，常见的效率优化方法有两种。
+
+- **剪枝**：避免搜索那些肯定不会产生解的路径，从而节省时间和空间。
+- **启发式搜索**：在搜索过程中引入一些策略或者估计值，从而优先搜索最有可能产生有效解的路径。
+
+## 回溯典型例题
+
+回溯算法可用于解决许多搜索问题、约束满足问题和组合优化问题。
+
+**搜索问题**：这类问题的目标是找到满足特定条件的解决方案。
+
+- 全排列问题：给定一个集合，求出其所有可能的排列组合。
+- 子集和问题：给定一个集合和一个目标和，找到集合中所有和为目标和的子集。
+- 汉诺塔问题：给定三个柱子和一系列大小不同的圆盘，要求将所有圆盘从一个柱子移动到另一个柱子，每次只能移动一个圆盘，且不能将大圆盘放在小圆盘上。
+
+**约束满足问题**：这类问题的目标是找到满足所有约束条件的解。
+
+- $n$ 皇后：在 $n \times n$ 的棋盘上放置 $n$ 个皇后，使得它们互不攻击。
+- 数独：在 $9 \times 9$ 的网格中填入数字 $1$ ~ $9$ ，使得每行、每列和每个 $3 \times 3$ 子网格中的数字不重复。
+- 图着色问题：给定一个无向图，用最少的颜色给图的每个顶点着色，使得相邻顶点颜色不同。
+
+**组合优化问题**：这类问题的目标是在一个组合空间中找到满足某些条件的最优解。
+
+- 0-1 背包问题：给定一组物品和一个背包，每个物品有一定的价值和重量，要求在背包容量限制内，选择物品使得总价值最大。
+- 旅行商问题：在一个图中，从一个点出发，访问所有其他点恰好一次后返回起点，求最短路径。
+- 最大团问题：给定一个无向图，找到最大的完全子图，即子图中的任意两个顶点之间都有边相连。
+
+请注意，对于许多组合优化问题，回溯都不是最优解决方案。
+
+- 0-1 背包问题通常使用动态规划解决，以达到更高的时间效率。
+- 旅行商是一个著名的 NP-Hard 问题，常用解法有遗传算法和蚁群算法等。
+- 最大团问题是图论中的一个经典问题，可用贪心等启发式算法来解决。

docs/zh/chapter_backtracking/index.md

@@ -0,0 +1,13 @@
+# 回溯
+
+<div class="center-table" markdown>
+
+![回溯](../assets/covers/chapter_backtracking.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    我们如同迷宫中的探索者，在前进的道路上可能会遇到困难。
+    
+    回溯的力量让我们能够重新开始，不断尝试，最终找到通往光明的出口。

docs/zh/chapter_backtracking/n_queens_problem.md

@@ -0,0 +1,141 @@
+# N 皇后问题
+
+!!! question
+
+    根据国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给定 $n$ 个皇后和一个 $n \times n$ 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。
+
+如下图所示，当 $n = 4$ 时，共可以找到两个解。从回溯算法的角度看，$n \times n$ 大小的棋盘共有 $n^2$ 个格子，给出了所有的选择 `choices` 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 `state` 。
+
+![4 皇后问题的解](n_queens_problem.assets/solution_4_queens.png)
+
+下图展示了本题的三个约束条件：**多个皇后不能在同一行、同一列、同一对角线**。值得注意的是，对角线分为主对角线 `\` 和次对角线 `/` 两种。
+
+![n 皇后问题的约束条件](n_queens_problem.assets/n_queens_constraints.png)
+
+### 逐行放置策略
+
+皇后的数量和棋盘的行数都为 $n$ ，因此我们容易得到一个推论：**棋盘每行都允许且只允许放置一个皇后**。
+
+也就是说，我们可以采取逐行放置策略：从第一行开始，在每行放置一个皇后，直至最后一行结束。
+
+如下图所示，为 $4$ 皇后问题的逐行放置过程。受画幅限制，下图仅展开了第一行的其中一个搜索分支，并且将不满足列约束和对角线约束的方案都进行了剪枝。
+
+![逐行放置策略](n_queens_problem.assets/n_queens_placing.png)
+
+本质上看，**逐行放置策略起到了剪枝的作用**，它避免了同一行出现多个皇后的所有搜索分支。
+
+### 列与对角线剪枝
+
+为了满足列约束，我们可以利用一个长度为 $n$ 的布尔型数组 `cols` 记录每一列是否有皇后。在每次决定放置前，我们通过 `cols` 将已有皇后的列进行剪枝，并在回溯中动态更新 `cols` 的状态。
+
+那么，如何处理对角线约束呢？设棋盘中某个格子的行列索引为 $(row, col)$ ，选定矩阵中的某条主对角线，我们发现该对角线上所有格子的行索引减列索引都相等，**即对角线上所有格子的 $row - col$ 为恒定值**。
+
+也就是说，如果两个格子满足 $row_1 - col_1 = row_2 - col_2$ ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助下图所示的数组 `diag1` ，记录每条主对角线上是否有皇后。
+
+同理，**次对角线上的所有格子的 $row + col$ 是恒定值**。我们同样也可以借助数组 `diag2` 来处理次对角线约束。
+
+![处理列约束和对角线约束](n_queens_problem.assets/n_queens_cols_diagonals.png)
+
+### 代码实现
+
+请注意，$n$ 维方阵中 $row - col$ 的范围是 $[-n + 1, n - 1]$ ，$row + col$ 的范围是 $[0, 2n - 2]$ ，所以主对角线和次对角线的数量都为 $2n - 1$ ，即数组 `diag1` 和 `diag2` 的长度都为 $2n - 1$ 。
+
+=== "Python"
+
+    ```python title="n_queens.py"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{n_queens}
+    ```
+
+=== "C++"
+
+    ```cpp title="n_queens.cpp"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+=== "Java"
+
+    ```java title="n_queens.java"
+    [class]{n_queens}-[func]{backtrack}
+
+    [class]{n_queens}-[func]{nQueens}
+    ```
+
+=== "C#"
+
+    ```csharp title="n_queens.cs"
+    [class]{n_queens}-[func]{backtrack}
+
+    [class]{n_queens}-[func]{nQueens}
+    ```
+
+=== "Go"
+
+    ```go title="n_queens.go"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+=== "Swift"
+
+    ```swift title="n_queens.swift"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+=== "JS"
+
+    ```javascript title="n_queens.js"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+=== "TS"
+
+    ```typescript title="n_queens.ts"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+=== "Dart"
+
+    ```dart title="n_queens.dart"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+=== "Rust"
+
+    ```rust title="n_queens.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{n_queens}
+    ```
+
+=== "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/zh/chapter_backtracking/permutations_problem.md

@@ -0,0 +1,279 @@
+# 全排列问题
+
+全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合（如一个数组或字符串）的情况下，找出这个集合中元素的所有可能的排列。
+
+下表列举了几个示例数据，包括输入数组和对应的所有排列。
+
+<p align="center"> 表 <id> &nbsp; 数组与链表的效率对比 </p>
+
+| 输入数组    | 所有排列                                                           |
+| :---------- | :----------------------------------------------------------------- |
+| $[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]$ |
+
+## 无相等元素的情况
+
+!!! question
+
+    输入一个整数数组，数组中不包含重复元素，返回所有可能的排列。
+
+从回溯算法的角度看，**我们可以把生成排列的过程想象成一系列选择的结果**。假设输入数组为 $[1, 2, 3]$ ，如果我们先选择 $1$、再选择 $3$、最后选择 $2$ ，则获得排列 $[1, 3, 2]$ 。回退表示撤销一个选择，之后继续尝试其他选择。
+
+从回溯代码的角度看，候选集合 `choices` 是输入数组中的所有元素，状态 `state` 是直至目前已被选择的元素。请注意，每个元素只允许被选择一次，**因此 `state` 中的所有元素都应该是唯一的**。
+
+如下图所示，我们可以将搜索过程展开成一个递归树，树中的每个节点代表当前状态 `state` 。从根节点开始，经过三轮选择后到达叶节点，每个叶节点都对应一个排列。
+
+![全排列的递归树](permutations_problem.assets/permutations_i.png)
+
+### 重复选择剪枝
+
+为了实现每个元素只被选择一次，我们考虑引入一个布尔型数组 `selected` ，其中 `selected[i]` 表示 `choices[i]` 是否已被选择，并基于它实现以下剪枝操作。
+
+- 在做出选择 `choice[i]` 后，我们就将 `selected[i]` 赋值为 $\text{True}$ ，代表它已被选择。
+- 遍历选择列表 `choices` 时，跳过所有已被选择过的节点，即剪枝。
+
+如下图所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1 和元素 3 的分支。
+
+![全排列剪枝示例](permutations_problem.assets/permutations_i_pruning.png)
+
+观察上图发现，该剪枝操作将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$ 。
+
+### 代码实现
+
+想清楚以上信息之后，我们就可以在框架代码中做“完形填空”了。为了缩短代码行数，我们不单独实现框架代码中的各个函数，而是将他们展开在 `backtrack()` 函数中。
+
+=== "Python"
+
+    ```python title="permutations_i.py"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutations_i}
+    ```
+
+=== "C++"
+
+    ```cpp title="permutations_i.cpp"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+=== "Java"
+
+    ```java title="permutations_i.java"
+    [class]{permutations_i}-[func]{backtrack}
+
+    [class]{permutations_i}-[func]{permutationsI}
+    ```
+
+=== "C#"
+
+    ```csharp title="permutations_i.cs"
+    [class]{permutations_i}-[func]{backtrack}
+
+    [class]{permutations_i}-[func]{permutationsI}
+    ```
+
+=== "Go"
+
+    ```go title="permutations_i.go"
+    [class]{}-[func]{backtrackI}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+=== "Swift"
+
+    ```swift title="permutations_i.swift"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+=== "JS"
+
+    ```javascript title="permutations_i.js"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+=== "TS"
+
+    ```typescript title="permutations_i.ts"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+=== "Dart"
+
+    ```dart title="permutations_i.dart"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+=== "Rust"
+
+    ```rust title="permutations_i.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutations_i}
+    ```
+
+=== "C"
+
+    ```c title="permutations_i.c"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+=== "Zig"
+
+    ```zig title="permutations_i.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
+## 考虑相等元素的情况
+
+!!! question
+
+    输入一个整数数组，**数组中可能包含重复元素**，返回所有不重复的排列。
+
+假设输入数组为 $[1, 1, 2]$ 。为了方便区分两个重复元素 $1$ ，我们将第二个 $1$ 记为 $\hat{1}$ 。
+
+如下图所示，上述方法生成的排列有一半都是重复的。
+
+![重复排列](permutations_problem.assets/permutations_ii.png)
+
+那么如何去除重复的排列呢？最直接地，考虑借助一个哈希表，直接对排列结果进行去重。然而这样做不够优雅，**因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝**，这样可以进一步提升算法效率。
+
+### 相等元素剪枝
+
+观察下图，在第一轮中，选择 $1$ 或选择 $\hat{1}$ 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 $\hat{1}$ 剪枝掉。
+
+同理，在第一轮选择 $2$ 之后，第二轮选择中的 $1$ 和 $\hat{1}$ 也会产生重复分支，因此也应将第二轮的 $\hat{1}$ 剪枝。
+
+本质上看，**我们的目标是在某一轮选择中，保证多个相等的元素仅被选择一次**。
+
+![重复排列剪枝](permutations_problem.assets/permutations_ii_pruning.png)
+
+### 代码实现
+
+在上一题的代码的基础上，我们考虑在每一轮选择中开启一个哈希表 `duplicated` ，用于记录该轮中已经尝试过的元素，并将重复元素剪枝。
+
+=== "Python"
+
+    ```python title="permutations_ii.py"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutations_ii}
+    ```
+
+=== "C++"
+
+    ```cpp title="permutations_ii.cpp"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+=== "Java"
+
+    ```java title="permutations_ii.java"
+    [class]{permutations_ii}-[func]{backtrack}
+
+    [class]{permutations_ii}-[func]{permutationsII}
+    ```
+
+=== "C#"
+
+    ```csharp title="permutations_ii.cs"
+    [class]{permutations_ii}-[func]{backtrack}
+
+    [class]{permutations_ii}-[func]{permutationsII}
+    ```
+
+=== "Go"
+
+    ```go title="permutations_ii.go"
+    [class]{}-[func]{backtrackII}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+=== "Swift"
+
+    ```swift title="permutations_ii.swift"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+=== "JS"
+
+    ```javascript title="permutations_ii.js"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+=== "TS"
+
+    ```typescript title="permutations_ii.ts"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+=== "Dart"
+
+    ```dart title="permutations_ii.dart"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+=== "Rust"
+
+    ```rust title="permutations_ii.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutations_ii}
+    ```
+
+=== "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)$** 。
+
+### 两种剪枝对比
+
+请注意，虽然 `selected` 和 `duplicated` 都用作剪枝，但两者的目标是不同的。
+
+- **重复选择剪枝**：整个搜索过程中只有一个 `selected` 。它记录的是当前状态中包含哪些元素，作用是避免某个元素在 `state` 中重复出现。
+- **相等元素剪枝**：每轮选择（即每个开启的 `backtrack` 函数）都包含一个 `duplicated` 。它记录的是在遍历中哪些元素已被选择过，作用是保证相等元素只被选择一次。
+
+下图展示了两个剪枝条件的生效范围。注意，树中的每个节点代表一个选择，从根节点到叶节点的路径上的各个节点构成一个排列。
+
+![两种剪枝条件的作用范围](permutations_problem.assets/permutations_ii_pruning_summary.png)

docs/zh/chapter_backtracking/subset_sum_problem.md

@@ -0,0 +1,371 @@
+# 子集和问题
+
+## 无重复元素的情况
+
+!!! question
+
+    给定一个正整数数组 `nums` 和一个目标正整数 `target` ，请找出所有可能的组合，使得组合中的元素和等于 `target` 。给定数组无重复元素，每个元素可以被选取多次。请以列表形式返回这些组合，列表中不应包含重复组合。
+
+例如，输入集合 $\{3, 4, 5\}$ 和目标整数 $9$ ，解为 $\{3, 3, 3\}, \{4, 5\}$ 。需要注意以下两点。
+
+- 输入集合中的元素可以被无限次重复选取。
+- 子集是不区分元素顺序的，比如 $\{4, 5\}$ 和 $\{5, 4\}$ 是同一个子集。
+
+### 参考全排列解法
+
+类似于全排列问题，我们可以把子集的生成过程想象成一系列选择的结果，并在选择过程中实时更新“元素和”，当元素和等于 `target` 时，就将子集记录至结果列表。
+
+而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无须借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。
+
+=== "Python"
+
+    ```python title="subset_sum_i_naive.py"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_i_naive}
+    ```
+
+=== "C++"
+
+    ```cpp title="subset_sum_i_naive.cpp"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumINaive}
+    ```
+
+=== "Java"
+
+    ```java title="subset_sum_i_naive.java"
+    [class]{subset_sum_i_naive}-[func]{backtrack}
+
+    [class]{subset_sum_i_naive}-[func]{subsetSumINaive}
+    ```
+
+=== "C#"
+
+    ```csharp title="subset_sum_i_naive.cs"
+    [class]{subset_sum_i_naive}-[func]{backtrack}
+
+    [class]{subset_sum_i_naive}-[func]{subsetSumINaive}
+    ```
+
+=== "Go"
+
+    ```go title="subset_sum_i_naive.go"
+    [class]{}-[func]{backtrackSubsetSumINaive}
+
+    [class]{}-[func]{subsetSumINaive}
+    ```
+
+=== "Swift"
+
+    ```swift title="subset_sum_i_naive.swift"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumINaive}
+    ```
+
+=== "JS"
+
+    ```javascript title="subset_sum_i_naive.js"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumINaive}
+    ```
+
+=== "TS"
+
+    ```typescript title="subset_sum_i_naive.ts"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumINaive}
+    ```
+
+=== "Dart"
+
+    ```dart title="subset_sum_i_naive.dart"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumINaive}
+    ```
+
+=== "Rust"
+
+    ```rust title="subset_sum_i_naive.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_i_naive}
+    ```
+
+=== "C"
+
+    ```c title="subset_sum_i_naive.c"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumINaive}
+    ```
+
+=== "Zig"
+
+    ```zig title="subset_sum_i_naive.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumINaive}
+    ```
+
+向以上代码输入数组 $[3, 4, 5]$ 和目标元素 $9$ ，输出结果为 $[3, 3, 3], [4, 5], [5, 4]$ 。**虽然成功找出了所有和为 $9$ 的子集，但其中存在重复的子集 $[4, 5]$ 和 $[5, 4]$** 。
+
+这是因为搜索过程是区分选择顺序的，然而子集不区分选择顺序。如下图所示，先选 $4$ 后选 $5$ 与先选 $5$ 后选 $4$ 是两个不同的分支，但两者对应同一个子集。
+
+![子集搜索与越界剪枝](subset_sum_problem.assets/subset_sum_i_naive.png)
+
+为了去除重复子集，**一种直接的思路是对结果列表进行去重**。但这个方法效率很低，有两方面原因。
+
+- 当数组元素较多，尤其是当 `target` 较大时，搜索过程会产生大量的重复子集。
+- 比较子集（数组）的异同非常耗时，需要先排序数组，再比较数组中每个元素的异同。
+
+### 重复子集剪枝
+
+**我们考虑在搜索过程中通过剪枝进行去重**。观察下图，重复子集是在以不同顺序选择数组元素时产生的，例如以下情况。
+
+1. 当第一轮和第二轮分别选择 $3$ 和 $4$ 时，会生成包含这两个元素的所有子集，记为 $[3, 4, \dots]$ 。
+2. 之后，当第一轮选择 $4$ 时，**则第二轮应该跳过 $3$** ，因为该选择产生的子集 $[4, 3, \dots]$ 和 `1.` 中生成的子集完全重复。
+
+在搜索中，每一层的选择都是从左到右被逐个尝试的，因此越靠右的分支被剪掉的越多。
+
+1. 前两轮选择 $3$ 和 $5$ ，生成子集 $[3, 5, \dots]$ 。
+2. 前两轮选择 $4$ 和 $5$ ，生成子集 $[4, 5, \dots]$ 。
+3. 若第一轮选择 $5$ ，**则第二轮应该跳过 $3$ 和 $4$** ，因为子集 $[5, 3, \dots]$ 和 $[5, 4, \dots]$ 与第 `1.` 和 `2.` 步中描述的子集完全重复。
+
+![不同选择顺序导致的重复子集](subset_sum_problem.assets/subset_sum_i_pruning.png)
+
+总结来看，给定输入数组 $[x_1, x_2, \dots, x_n]$ ，设搜索过程中的选择序列为 $[x_{i_1}, x_{i_2}, \dots, x_{i_m}]$ ，则该选择序列需要满足 $i_1 \leq i_2 \leq \dots \leq i_m$ ，**不满足该条件的选择序列都会造成重复，应当剪枝**。
+
+### 代码实现
+
+为实现该剪枝，我们初始化变量 `start` ，用于指示遍历起点。**当做出选择 $x_{i}$ 后，设定下一轮从索引 $i$ 开始遍历**。这样做就可以让选择序列满足 $i_1 \leq i_2 \leq \dots \leq i_m$ ，从而保证子集唯一。
+
+除此之外，我们还对代码进行了以下两项优化。
+
+- 在开启搜索前，先将数组 `nums` 排序。在遍历所有选择时，**当子集和超过 `target` 时直接结束循环**，因为后边的元素更大，其子集和都一定会超过 `target` 。
+- 省去元素和变量 `total` ，**通过在 `target` 上执行减法来统计元素和**，当 `target` 等于 $0$ 时记录解。
+
+=== "Python"
+
+    ```python title="subset_sum_i.py"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_i}
+    ```
+
+=== "C++"
+
+    ```cpp title="subset_sum_i.cpp"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumI}
+    ```
+
+=== "Java"
+
+    ```java title="subset_sum_i.java"
+    [class]{subset_sum_i}-[func]{backtrack}
+
+    [class]{subset_sum_i}-[func]{subsetSumI}
+    ```
+
+=== "C#"
+
+    ```csharp title="subset_sum_i.cs"
+    [class]{subset_sum_i}-[func]{backtrack}
+
+    [class]{subset_sum_i}-[func]{subsetSumI}
+    ```
+
+=== "Go"
+
+    ```go title="subset_sum_i.go"
+    [class]{}-[func]{backtrackSubsetSumI}
+
+    [class]{}-[func]{subsetSumI}
+    ```
+
+=== "Swift"
+
+    ```swift title="subset_sum_i.swift"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumI}
+    ```
+
+=== "JS"
+
+    ```javascript title="subset_sum_i.js"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumI}
+    ```
+
+=== "TS"
+
+    ```typescript title="subset_sum_i.ts"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumI}
+    ```
+
+=== "Dart"
+
+    ```dart title="subset_sum_i.dart"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumI}
+    ```
+
+=== "Rust"
+
+    ```rust title="subset_sum_i.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_i}
+    ```
+
+=== "C"
+
+    ```c title="subset_sum_i.c"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumI}
+    ```
+
+=== "Zig"
+
+    ```zig title="subset_sum_i.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumI}
+    ```
+
+如下图所示，为将数组 $[3, 4, 5]$ 和目标元素 $9$ 输入到以上代码后的整体回溯过程。
+
+![子集和 I 回溯过程](subset_sum_problem.assets/subset_sum_i.png)
+
+## 考虑重复元素的情况
+
+!!! question
+
+    给定一个正整数数组 `nums` 和一个目标正整数 `target` ，请找出所有可能的组合，使得组合中的元素和等于 `target` 。**给定数组可能包含重复元素，每个元素只可被选择一次**。请以列表形式返回这些组合，列表中不应包含重复组合。
+
+相比于上题，**本题的输入数组可能包含重复元素**，这引入了新的问题。例如，给定数组 $[4, \hat{4}, 5]$ 和目标元素 $9$ ，则现有代码的输出结果为 $[4, 5], [\hat{4}, 5]$ ，出现了重复子集。
+
+**造成这种重复的原因是相等元素在某轮中被多次选择**。在下图中，第一轮共有三个选择，其中两个都为 $4$ ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 $4$ 也会产生重复子集。
+
+![相等元素导致的重复子集](subset_sum_problem.assets/subset_sum_ii_repeat.png)
+
+### 相等元素剪枝
+
+为解决此问题，**我们需要限制相等元素在每一轮中只被选择一次**。实现方式比较巧妙：由于数组是已排序的，因此相等元素都是相邻的。这意味着在某轮选择中，若当前元素与其左边元素相等，则说明它已经被选择过，因此直接跳过当前元素。
+
+与此同时，**本题规定中的每个数组元素只能被选择一次**。幸运的是，我们也可以利用变量 `start` 来满足该约束：当做出选择 $x_{i}$ 后，设定下一轮从索引 $i + 1$ 开始向后遍历。这样即能去除重复子集，也能避免重复选择元素。
+
+### 代码实现
+
+=== "Python"
+
+    ```python title="subset_sum_ii.py"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_ii}
+    ```
+
+=== "C++"
+
+    ```cpp title="subset_sum_ii.cpp"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumII}
+    ```
+
+=== "Java"
+
+    ```java title="subset_sum_ii.java"
+    [class]{subset_sum_ii}-[func]{backtrack}
+
+    [class]{subset_sum_ii}-[func]{subsetSumII}
+    ```
+
+=== "C#"
+
+    ```csharp title="subset_sum_ii.cs"
+    [class]{subset_sum_ii}-[func]{backtrack}
+
+    [class]{subset_sum_ii}-[func]{subsetSumII}
+    ```
+
+=== "Go"
+
+    ```go title="subset_sum_ii.go"
+    [class]{}-[func]{backtrackSubsetSumII}
+
+    [class]{}-[func]{subsetSumII}
+    ```
+
+=== "Swift"
+
+    ```swift title="subset_sum_ii.swift"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumII}
+    ```
+
+=== "JS"
+
+    ```javascript title="subset_sum_ii.js"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumII}
+    ```
+
+=== "TS"
+
+    ```typescript title="subset_sum_ii.ts"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumII}
+    ```
+
+=== "Dart"
+
+    ```dart title="subset_sum_ii.dart"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumII}
+    ```
+
+=== "Rust"
+
+    ```rust title="subset_sum_ii.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_ii}
+    ```
+
+=== "C"
+
+    ```c title="subset_sum_ii.c"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumII}
+    ```
+
+=== "Zig"
+
+    ```zig title="subset_sum_ii.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subsetSumII}
+    ```
+
+下图展示了数组 $[4, 4, 5]$ 和目标元素 $9$ 的回溯过程，共包含四种剪枝操作。请你将图示与代码注释相结合，理解整个搜索过程，以及每种剪枝操作是如何工作的。
+
+![子集和 II 回溯过程](subset_sum_problem.assets/subset_sum_ii.png)

docs/zh/chapter_backtracking/summary.md

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

docs/zh/chapter_computational_complexity/index.md

@@ -0,0 +1,13 @@
+# 复杂度分析
+
+<div class="center-table" markdown>
+
+![复杂度分析](../assets/covers/chapter_complexity_analysis.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    复杂度分析犹如浩瀚的算法宇宙中的时空向导。
+    
+    它带领我们在时间与空间这两个维度上深入探索，寻找更优雅的解决方案。

docs/zh/chapter_computational_complexity/iteration_and_recursion.md

@@ -0,0 +1,738 @@
+# 迭代与递归
+
+在数据结构与算法中，重复执行某个任务是很常见的，其与算法的复杂度密切相关。而要重复执行某个任务，我们通常会选用两种基本的程序结构：迭代和递归。
+
+## 迭代
+
+「迭代 iteration」是一种重复执行某个任务的控制结构。在迭代中，程序会在满足一定的条件下重复执行某段代码，直到这个条件不再满足。
+
+### for 循环
+
+`for` 循环是最常见的迭代形式之一，**适合预先知道迭代次数时使用**。
+
+以下函数基于 `for` 循环实现了求和 $1 + 2 + \dots + n$ ，求和结果使用变量 `res` 记录。需要注意的是，Python 中 `range(a, b)` 对应的区间是“左闭右开”的，对应的遍历范围为 $a, a + 1, \dots, b-1$ 。
+
+=== "Python"
+
+    ```python title="iteration.py"
+    [class]{}-[func]{for_loop}
+    ```
+
+=== "C++"
+
+    ```cpp title="iteration.cpp"
+    [class]{}-[func]{forLoop}
+    ```
+
+=== "Java"
+
+    ```java title="iteration.java"
+    [class]{iteration}-[func]{forLoop}
+    ```
+
+=== "C#"
+
+    ```csharp title="iteration.cs"
+    [class]{iteration}-[func]{forLoop}
+    ```
+
+=== "Go"
+
+    ```go title="iteration.go"
+    [class]{}-[func]{forLoop}
+    ```
+
+=== "Swift"
+
+    ```swift title="iteration.swift"
+    [class]{}-[func]{forLoop}
+    ```
+
+=== "JS"
+
+    ```javascript title="iteration.js"
+    [class]{}-[func]{forLoop}
+    ```
+
+=== "TS"
+
+    ```typescript title="iteration.ts"
+    [class]{}-[func]{forLoop}
+    ```
+
+=== "Dart"
+
+    ```dart title="iteration.dart"
+    [class]{}-[func]{forLoop}
+    ```
+
+=== "Rust"
+
+    ```rust title="iteration.rs"
+    [class]{}-[func]{for_loop}
+    ```
+
+=== "C"
+
+    ```c title="iteration.c"
+    [class]{}-[func]{forLoop}
+    ```
+
+=== "Zig"
+
+    ```zig title="iteration.zig"
+    [class]{}-[func]{forLoop}
+    ```
+
+下图展示了该求和函数的流程框图。
+
+![求和函数的流程框图](iteration_and_recursion.assets/iteration.png)
+
+此求和函数的操作数量与输入数据大小 $n$ 成正比，或者说成“线性关系”。实际上，**时间复杂度描述的就是这个“线性关系”**。相关内容将会在下一节中详细介绍。
+
+### while 循环
+
+与 `for` 循环类似，`while` 循环也是一种实现迭代的方法。在 `while` 循环中，程序每轮都会先检查条件，如果条件为真则继续执行，否则就结束循环。
+
+下面，我们用 `while` 循环来实现求和 $1 + 2 + \dots + n$ 。
+
+=== "Python"
+
+    ```python title="iteration.py"
+    [class]{}-[func]{while_loop}
+    ```
+
+=== "C++"
+
+    ```cpp title="iteration.cpp"
+    [class]{}-[func]{whileLoop}
+    ```
+
+=== "Java"
+
+    ```java title="iteration.java"
+    [class]{iteration}-[func]{whileLoop}
+    ```
+
+=== "C#"
+
+    ```csharp title="iteration.cs"
+    [class]{iteration}-[func]{whileLoop}
+    ```
+
+=== "Go"
+
+    ```go title="iteration.go"
+    [class]{}-[func]{whileLoop}
+    ```
+
+=== "Swift"
+
+    ```swift title="iteration.swift"
+    [class]{}-[func]{whileLoop}
+    ```
+
+=== "JS"
+
+    ```javascript title="iteration.js"
+    [class]{}-[func]{whileLoop}
+    ```
+
+=== "TS"
+
+    ```typescript title="iteration.ts"
+    [class]{}-[func]{whileLoop}
+    ```
+
+=== "Dart"
+
+    ```dart title="iteration.dart"
+    [class]{}-[func]{whileLoop}
+    ```
+
+=== "Rust"
+
+    ```rust title="iteration.rs"
+    [class]{}-[func]{while_loop}
+    ```
+
+=== "C"
+
+    ```c title="iteration.c"
+    [class]{}-[func]{whileLoop}
+    ```
+
+=== "Zig"
+
+    ```zig title="iteration.zig"
+    [class]{}-[func]{whileLoop}
+    ```
+
+在 `while` 循环中，由于初始化和更新条件变量的步骤是独立在循环结构之外的，**因此它比 `for` 循环的自由度更高**。
+
+例如在以下代码中，条件变量 $i$ 每轮进行了两次更新，这种情况就不太方便用 `for` 循环实现。
+
+=== "Python"
+
+    ```python title="iteration.py"
+    [class]{}-[func]{while_loop_ii}
+    ```
+
+=== "C++"
+
+    ```cpp title="iteration.cpp"
+    [class]{}-[func]{whileLoopII}
+    ```
+
+=== "Java"
+
+    ```java title="iteration.java"
+    [class]{iteration}-[func]{whileLoopII}
+    ```
+
+=== "C#"
+
+    ```csharp title="iteration.cs"
+    [class]{iteration}-[func]{whileLoopII}
+    ```
+
+=== "Go"
+
+    ```go title="iteration.go"
+    [class]{}-[func]{whileLoopII}
+    ```
+
+=== "Swift"
+
+    ```swift title="iteration.swift"
+    [class]{}-[func]{whileLoopII}
+    ```
+
+=== "JS"
+
+    ```javascript title="iteration.js"
+    [class]{}-[func]{whileLoopII}
+    ```
+
+=== "TS"
+
+    ```typescript title="iteration.ts"
+    [class]{}-[func]{whileLoopII}
+    ```
+
+=== "Dart"
+
+    ```dart title="iteration.dart"
+    [class]{}-[func]{whileLoopII}
+    ```
+
+=== "Rust"
+
+    ```rust title="iteration.rs"
+    [class]{}-[func]{while_loop_ii}
+    ```
+
+=== "C"
+
+    ```c title="iteration.c"
+    [class]{}-[func]{whileLoopII}
+    ```
+
+=== "Zig"
+
+    ```zig title="iteration.zig"
+    [class]{}-[func]{whileLoopII}
+    ```
+
+总的来说，**`for` 循环的代码更加紧凑，`while` 循环更加灵活**，两者都可以实现迭代结构。选择使用哪一个应该根据特定问题的需求来决定。
+
+### 嵌套循环
+
+我们可以在一个循环结构内嵌套另一个循环结构，以 `for` 循环为例：
+
+=== "Python"
+
+    ```python title="iteration.py"
+    [class]{}-[func]{nested_for_loop}
+    ```
+
+=== "C++"
+
+    ```cpp title="iteration.cpp"
+    [class]{}-[func]{nestedForLoop}
+    ```
+
+=== "Java"
+
+    ```java title="iteration.java"
+    [class]{iteration}-[func]{nestedForLoop}
+    ```
+
+=== "C#"
+
+    ```csharp title="iteration.cs"
+    [class]{iteration}-[func]{nestedForLoop}
+    ```
+
+=== "Go"
+
+    ```go title="iteration.go"
+    [class]{}-[func]{nestedForLoop}
+    ```
+
+=== "Swift"
+
+    ```swift title="iteration.swift"
+    [class]{}-[func]{nestedForLoop}
+    ```
+
+=== "JS"
+
+    ```javascript title="iteration.js"
+    [class]{}-[func]{nestedForLoop}
+    ```
+
+=== "TS"
+
+    ```typescript title="iteration.ts"
+    [class]{}-[func]{nestedForLoop}
+    ```
+
+=== "Dart"
+
+    ```dart title="iteration.dart"
+    [class]{}-[func]{nestedForLoop}
+    ```
+
+=== "Rust"
+
+    ```rust title="iteration.rs"
+    [class]{}-[func]{nested_for_loop}
+    ```
+
+=== "C"
+
+    ```c title="iteration.c"
+    [class]{}-[func]{nestedForLoop}
+    ```
+
+=== "Zig"
+
+    ```zig title="iteration.zig"
+    [class]{}-[func]{nestedForLoop}
+    ```
+
+下图给出了该嵌套循环的流程框图。
+
+![嵌套循环的流程框图](iteration_and_recursion.assets/nested_iteration.png)
+
+在这种情况下，函数的操作数量与 $n^2$ 成正比，或者说算法运行时间和输入数据大小 $n$ 成“平方关系”。
+
+我们可以继续添加嵌套循环，每一次嵌套都是一次“升维”，将会使时间复杂度提高至“立方关系”、“四次方关系”、以此类推。
+
+## 递归
+
+ 「递归 recursion」是一种算法策略，通过函数调用自身来解决问题。它主要包含两个阶段。
+
+1. **递**：程序不断深入地调用自身，通常传入更小或更简化的参数，直到达到“终止条件”。
+2. **归**：触发“终止条件”后，程序从最深层的递归函数开始逐层返回，汇聚每一层的结果。
+
+而从实现的角度看，递归代码主要包含三个要素。
+
+1. **终止条件**：用于决定什么时候由“递”转“归”。
+2. **递归调用**：对应“递”，函数调用自身，通常输入更小或更简化的参数。
+3. **返回结果**：对应“归”，将当前递归层级的结果返回至上一层。
+
+观察以下代码，我们只需调用函数 `recur(n)`  ，就可以完成 $1 + 2 + \dots + n$ 的计算：
+
+=== "Python"
+
+    ```python title="recursion.py"
+    [class]{}-[func]{recur}
+    ```
+
+=== "C++"
+
+    ```cpp title="recursion.cpp"
+    [class]{}-[func]{recur}
+    ```
+
+=== "Java"
+
+    ```java title="recursion.java"
+    [class]{recursion}-[func]{recur}
+    ```
+
+=== "C#"
+
+    ```csharp title="recursion.cs"
+    [class]{recursion}-[func]{recur}
+    ```
+
+=== "Go"
+
+    ```go title="recursion.go"
+    [class]{}-[func]{recur}
+    ```
+
+=== "Swift"
+
+    ```swift title="recursion.swift"
+    [class]{}-[func]{recur}
+    ```
+
+=== "JS"
+
+    ```javascript title="recursion.js"
+    [class]{}-[func]{recur}
+    ```
+
+=== "TS"
+
+    ```typescript title="recursion.ts"
+    [class]{}-[func]{recur}
+    ```
+
+=== "Dart"
+
+    ```dart title="recursion.dart"
+    [class]{}-[func]{recur}
+    ```
+
+=== "Rust"
+
+    ```rust title="recursion.rs"
+    [class]{}-[func]{recur}
+    ```
+
+=== "C"
+
+    ```c title="recursion.c"
+    [class]{}-[func]{recur}
+    ```
+
+=== "Zig"
+
+    ```zig title="recursion.zig"
+    [class]{}-[func]{recur}
+    ```
+
+下图展示了该函数的递归过程。
+
+![求和函数的递归过程](iteration_and_recursion.assets/recursion_sum.png)
+
+虽然从计算角度看，迭代与递归可以得到相同的结果，**但它们代表了两种完全不同的思考和解决问题的范式**。
+
+- **迭代**：“自下而上”地解决问题。从最基础的步骤开始，然后不断重复或累加这些步骤，直到任务完成。
+- **递归**：“自上而下”地解决问题。将原问题分解为更小的子问题，这些子问题和原问题具有相同的形式。接下来将子问题继续分解为更小的子问题，直到基本情况时停止（基本情况的解是已知的）。
+
+以上述的求和函数为例，设问题 $f(n) = 1 + 2 + \dots + n$ 。
+
+- **迭代**：在循环中模拟求和过程，从 $1$ 遍历到 $n$ ，每轮执行求和操作，即可求得 $f(n)$ 。
+- **递归**：将问题分解为子问题 $f(n) = n + f(n-1)$ ，不断（递归地）分解下去，直至基本情况 $f(1) = 1$ 时终止。
+
+### 调用栈
+
+递归函数每次调用自身时，系统都会为新开启的函数分配内存，以存储局部变量、调用地址和其他信息等。这将导致两方面的结果。
+
+- 函数的上下文数据都存储在称为“栈帧空间”的内存区域中，直至函数返回后才会被释放。因此，**递归通常比迭代更加耗费内存空间**。
+- 递归调用函数会产生额外的开销。**因此递归通常比循环的时间效率更低**。
+
+如下图所示，在触发终止条件前，同时存在 $n$ 个未返回的递归函数，**递归深度为 $n$** 。
+
+![递归调用深度](iteration_and_recursion.assets/recursion_sum_depth.png)
+
+在实际中，编程语言允许的递归深度通常是有限的，过深的递归可能导致栈溢出报错。
+
+### 尾递归
+
+有趣的是，**如果函数在返回前的最后一步才进行递归调用**，则该函数可以被编译器或解释器优化，使其在空间效率上与迭代相当。这种情况被称为「尾递归 tail recursion」。
+
+- **普通递归**：当函数返回到上一层级的函数后，需要继续执行代码，因此系统需要保存上一层调用的上下文。
+- **尾递归**：递归调用是函数返回前的最后一个操作，这意味着函数返回到上一层级后，无需继续执行其他操作，因此系统无需保存上一层函数的上下文。
+
+以计算 $1 + 2 + \dots + n$ 为例，我们可以将结果变量 `res` 设为函数参数，从而实现尾递归。
+
+=== "Python"
+
+    ```python title="recursion.py"
+    [class]{}-[func]{tail_recur}
+    ```
+
+=== "C++"
+
+    ```cpp title="recursion.cpp"
+    [class]{}-[func]{tailRecur}
+    ```
+
+=== "Java"
+
+    ```java title="recursion.java"
+    [class]{recursion}-[func]{tailRecur}
+    ```
+
+=== "C#"
+
+    ```csharp title="recursion.cs"
+    [class]{recursion}-[func]{tailRecur}
+    ```
+
+=== "Go"
+
+    ```go title="recursion.go"
+    [class]{}-[func]{tailRecur}
+    ```
+
+=== "Swift"
+
+    ```swift title="recursion.swift"
+    [class]{}-[func]{tailRecur}
+    ```
+
+=== "JS"
+
+    ```javascript title="recursion.js"
+    [class]{}-[func]{tailRecur}
+    ```
+
+=== "TS"
+
+    ```typescript title="recursion.ts"
+    [class]{}-[func]{tailRecur}
+    ```
+
+=== "Dart"
+
+    ```dart title="recursion.dart"
+    [class]{}-[func]{tailRecur}
+    ```
+
+=== "Rust"
+
+    ```rust title="recursion.rs"
+    [class]{}-[func]{tail_recur}
+    ```
+
+=== "C"
+
+    ```c title="recursion.c"
+    [class]{}-[func]{tailRecur}
+    ```
+
+=== "Zig"
+
+    ```zig title="recursion.zig"
+    [class]{}-[func]{tailRecur}
+    ```
+
+尾递归的执行过程如下图所示。对比普通递归和尾递归，求和操作的执行点是不同的。
+
+- **普通递归**：求和操作是在“归”的过程中执行的，每层返回后都要再执行一次求和操作。
+- **尾递归**：求和操作是在“递”的过程中执行的，“归”的过程只需层层返回。
+
+![尾递归过程](iteration_and_recursion.assets/tail_recursion_sum.png)
+
+!!! tip
+
+    请注意，许多编译器或解释器并不支持尾递归优化。例如，Python 默认不支持尾递归优化，因此即使函数是尾递归形式，但仍然可能会遇到栈溢出问题。
+
+### 递归树
+
+当处理与“分治”相关的算法问题时，递归往往比迭代的思路更加直观、代码更加易读。以“斐波那契数列”为例。
+
+!!! question
+
+    给定一个斐波那契数列 $0, 1, 1, 2, 3, 5, 8, 13, \dots$ ，求该数列的第 $n$ 个数字。
+
+设斐波那契数列的第 $n$ 个数字为 $f(n)$ ，易得两个结论。
+
+- 数列的前两个数字为 $f(1) = 0$ 和 $f(2) = 1$ 。
+- 数列中的每个数字是前两个数字的和，即 $f(n) = f(n - 1) + f(n - 2)$ 。
+
+按照递推关系进行递归调用，将前两个数字作为终止条件，便可写出递归代码。调用 `fib(n)` 即可得到斐波那契数列的第 $n$ 个数字。
+
+=== "Python"
+
+    ```python title="recursion.py"
+    [class]{}-[func]{fib}
+    ```
+
+=== "C++"
+
+    ```cpp title="recursion.cpp"
+    [class]{}-[func]{fib}
+    ```
+
+=== "Java"
+
+    ```java title="recursion.java"
+    [class]{recursion}-[func]{fib}
+    ```
+
+=== "C#"
+
+    ```csharp title="recursion.cs"
+    [class]{recursion}-[func]{fib}
+    ```
+
+=== "Go"
+
+    ```go title="recursion.go"
+    [class]{}-[func]{fib}
+    ```
+
+=== "Swift"
+
+    ```swift title="recursion.swift"
+    [class]{}-[func]{fib}
+    ```
+
+=== "JS"
+
+    ```javascript title="recursion.js"
+    [class]{}-[func]{fib}
+    ```
+
+=== "TS"
+
+    ```typescript title="recursion.ts"
+    [class]{}-[func]{fib}
+    ```
+
+=== "Dart"
+
+    ```dart title="recursion.dart"
+    [class]{}-[func]{fib}
+    ```
+
+=== "Rust"
+
+    ```rust title="recursion.rs"
+    [class]{}-[func]{fib}
+    ```
+
+=== "C"
+
+    ```c title="recursion.c"
+    [class]{}-[func]{fib}
+    ```
+
+=== "Zig"
+
+    ```zig title="recursion.zig"
+    [class]{}-[func]{fib}
+    ```
+
+观察以上代码，我们在函数内递归调用了两个函数，**这意味着从一个调用产生了两个调用分支**。如下图所示，这样不断递归调用下去，最终将产生一个层数为 $n$ 的「递归树 recursion tree」。
+
+![斐波那契数列的递归树](iteration_and_recursion.assets/recursion_tree.png)
+
+本质上看，递归体现“将问题分解为更小子问题”的思维范式，这种分治策略是至关重要的。
+
+- 从算法角度看，搜索、排序、回溯、分治、动态规划等许多重要算法策略都直接或间接地应用这种思维方式。
+- 从数据结构角度看，递归天然适合处理链表、树和图的相关问题，因为它们非常适合用分治思想进行分析。
+
+## 两者对比
+
+总结以上内容，如下表所示，迭代和递归在实现、性能和适用性上有所不同。
+
+<p align="center"> 表 <id> &nbsp; 迭代与递归特点对比 </p>
+
+|          | 迭代                                   | 递归                                                         |
+| -------- | -------------------------------------- | ------------------------------------------------------------ |
+| 实现方式 | 循环结构                               | 函数调用自身                                                 |
+| 时间效率 | 效率通常较高，无函数调用开销           | 每次函数调用都会产生开销                                     |
+| 内存使用 | 通常使用固定大小的内存空间             | 累积函数调用可能使用大量的栈帧空间                           |
+| 适用问题 | 适用于简单循环任务，代码直观、可读性好 | 适用于子问题分解，如树、图、分治、回溯等，代码结构简洁、清晰 |
+
+!!! tip
+
+    如果感觉以下内容理解困难，可以在读完“栈”章节后再来复习。
+
+那么，迭代和递归具有什么内在联系呢？以上述的递归函数为例，求和操作在递归的“归”阶段进行。这意味着最初被调用的函数实际上是最后完成其求和操作的，**这种工作机制与栈的“先入后出”原则是异曲同工的**。
+
+事实上，“调用栈”和“栈帧空间”这类递归术语已经暗示了递归与栈之间的密切关系。
+
+1. **递**：当函数被调用时，系统会在“调用栈”上为该函数分配新的栈帧，用于存储函数的局部变量、参数、返回地址等数据。
+2. **归**：当函数完成执行并返回时，对应的栈帧会从“调用栈”上被移除，恢复之前函数的执行环境。
+
+因此，**我们可以使用一个显式的栈来模拟调用栈的行为**，从而将递归转化为迭代形式：
+
+=== "Python"
+
+    ```python title="recursion.py"
+    [class]{}-[func]{for_loop_recur}
+    ```
+
+=== "C++"
+
+    ```cpp title="recursion.cpp"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Java"
+
+    ```java title="recursion.java"
+    [class]{recursion}-[func]{forLoopRecur}
+    ```
+
+=== "C#"
+
+    ```csharp title="recursion.cs"
+    [class]{recursion}-[func]{forLoopRecur}
+    ```
+
+=== "Go"
+
+    ```go title="recursion.go"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Swift"
+
+    ```swift title="recursion.swift"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "JS"
+
+    ```javascript title="recursion.js"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "TS"
+
+    ```typescript title="recursion.ts"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Dart"
+
+    ```dart title="recursion.dart"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Rust"
+
+    ```rust title="recursion.rs"
+    [class]{}-[func]{for_loop_recur}
+    ```
+
+=== "C"
+
+    ```c title="recursion.c"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Zig"
+
+    ```zig title="recursion.zig"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+观察以上代码，当递归被转换为迭代后，代码变得更加复杂了。尽管迭代和递归在很多情况下可以互相转换，但也不一定值得这样做，有以下两点原因。
+
+- 转化后的代码可能更加难以理解，可读性更差。
+- 对于某些复杂问题，模拟系统调用栈的行为可能非常困难。
+
+总之，**选择迭代还是递归取决于特定问题的性质**。在编程实践中，权衡两者的优劣并根据情境选择合适的方法是至关重要的。

docs/zh/chapter_computational_complexity/performance_evaluation.md

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

docs/zh/chapter_computational_complexity/summary.md

@@ -0,0 +1,49 @@
+# 小结
+
+### 重点回顾
+
+**算法效率评估**
+
+- 时间效率和空间效率是衡量算法优劣的两个主要评价指标。
+- 我们可以通过实际测试来评估算法效率，但难以消除测试环境的影响，且会耗费大量计算资源。
+- 复杂度分析可以克服实际测试的弊端，分析结果适用于所有运行平台，并且能够揭示算法在不同数据规模下的效率。
+
+**时间复杂度**
+
+- 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入的数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。
+- 最差时间复杂度使用大 $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)$ 等。
+
+### 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/zh/chapter_data_structure/basic_data_types.md

@@ -0,0 +1,159 @@
+# 基本数据类型
+
+谈及计算机中的数据，我们会想到文本、图片、视频、语音、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}$ 个数字。
+
+下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无须硬背，大致理解即可，需要时可以通过查表来回忆。
+
+<p align="center"> 表 <id> &nbsp; 基本数据类型的占用空间和取值范围 </p>
+
+| 类型   | 符号     | 占用空间         | 最小值                   | 最大值                  | 默认值         |
+| ------ | -------- | ---------------- | ------------------------ | ----------------------- | -------------- |
+| 整数   | `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}$ |
+
+对于上表，需要注意以下几点。
+
+- C 和 C++ 未明确规定基本数据类型大小，而因实现和平台各异。上表遵循 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/zh/chapter_data_structure/character_encoding.md

@@ -0,0 +1,87 @@
+# 字符编码 *
+
+在计算机中，所有数据都是以二进制数的形式存储的，字符 `char` 也不例外。为了表示字符，我们需要建立一套“字符集”，规定每个字符和二进制数之间的一一对应关系。有了字符集之后，计算机就可以通过查表完成二进制数到字符的转换。
+
+## ASCII 字符集
+
+「ASCII 码」是最早出现的字符集，全称为“美国标准信息交换代码”。它使用 7 位二进制数（即一个字节的低 7 位）表示一个字符，最多能够表示 128 个不同的字符。如下图所示，ASCII 码包括英文字母的大小写、数字 0 ~ 9、一些标点符号，以及一些控制字符（如换行符和制表符）。
+
+![ASCII 码](character_encoding.assets/ascii_table.png)
+
+然而，**ASCII 码仅能够表示英文**。随着计算机的全球化，诞生了一种能够表示更多语言的字符集「EASCII」。它在 ASCII 的 7 位基础上扩展到 8 位，能够表示 256 个不同的字符。
+
+在世界范围内，陆续出现了一批适用于不同地区的 EASCII 字符集。这些字符集的前 128 个字符统一为 ASCII 码，后 128 个字符定义不同，以适应不同语言的需求。
+
+## GBK 字符集
+
+后来人们发现，**EASCII 码仍然无法满足许多语言的字符数量要求**。比如汉字大约有近十万个，光日常使用的就有几千个。中国国家标准总局于 1980 年发布了「GB2312」字符集，其收录了 6763 个汉字，基本满足了汉字的计算机处理需要。
+
+然而，GB2312 无法处理部分的罕见字和繁体字。「GBK」字符集是在 GB2312 的基础上扩展得到的，它共收录了 21886 个汉字。在 GBK 的编码方案中，ASCII 字符使用一个字节表示，汉字使用两个字节表示。
+
+## Unicode 字符集
+
+随着计算机的蓬勃发展，字符集与编码标准百花齐放，而这带来了许多问题。一方面，这些字符集一般只定义了特定语言的字符，无法在多语言环境下正常工作。另一方面，同一种语言也存在多种字符集标准，如果两台电脑安装的是不同的编码标准，则在信息传递时就会出现乱码。
+
+那个时代的研究人员就在想：**如果推出一个足够完整的字符集，将世界范围内的所有语言和符号都收录其中，不就可以解决跨语言环境和乱码问题了吗**？在这种想法的驱动下，一个大而全的字符集 Unicode 应运而生。
+
+「Unicode」的全称为“统一字符编码”，理论上能容纳一百多万个字符。它致力于将全球范围内的字符纳入到统一的字符集之中，提供一种通用的字符集来处理和显示各种语言文字，减少因为编码标准不同而产生的乱码问题。
+
+自 1991 年发布以来，Unicode 不断扩充新的语言与字符。截止 2022 年 9 月，Unicode 已经包含 149186 个字符，包括各种语言的字符、符号、甚至是表情符号等。在庞大的 Unicode 字符集中，常用的字符占用 2 字节，有些生僻的字符占 3 字节甚至 4 字节。
+
+Unicode 是一种字符集标准，本质上是给每个字符分配一个编号（称为“码点”），**但它并没有规定在计算机中如何存储这些字符码点**。我们不禁会问：当多种长度的 Unicode 码点同时出现在同一个文本中时，系统如何解析字符？例如给定一个长度为 2 字节的编码，系统如何确认它是一个 2 字节的字符还是两个 1 字节的字符？
+
+对于以上问题，**一种直接的解决方案是将所有字符存储为等长的编码**。如下图所示，“Hello”中的每个字符占用 1 字节，“算法”中的每个字符占用 2 字节。我们可以通过高位填 0 ，将“Hello 算法”中的所有字符都编码为 2 字节长度。这样系统就可以每隔 2 字节解析一个字符，恢复出这个短语的内容了。
+
+![Unicode 编码示例](character_encoding.assets/unicode_hello_algo.png)
+
+然而 ASCII 码已经向我们证明，编码英文只需要 1 字节。若采用上述方案，英文文本占用空间的大小将会是 ASCII 编码下大小的两倍，非常浪费内存空间。因此，我们需要一种更加高效的 Unicode 编码方法。
+
+## 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 码点。
+
+下图展示了“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)
+
+除了 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 。
+
+## 编程语言的字符编码
+
+对于以往的大多数编程语言，程序运行中的字符串都采用 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/zh/chapter_data_structure/classification_of_data_structure.md

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

docs/zh/chapter_data_structure/index.md

@@ -0,0 +1,13 @@
+# 数据结构
+
+<div class="center-table" markdown>
+
+![数据结构](../assets/covers/chapter_data_structure.jpg){ width="600" }
+
+</div>
+
+!!! abstract
+
+    数据结构如同一副稳固而多样的框架。
+    
+    它为数据的有序组织提供了蓝图，使算法得以在此基础上生动起来。

docs/zh/chapter_data_structure/number_encoding.md

@@ -0,0 +1,150 @@
+# 数字编码 *
+
+!!! note
+
+    在本书中，标题带有的 * 符号的是选读章节。如果你时间有限或感到理解困难，可以先跳过，等学完必读章节后再单独攻克。
+
+## 整数编码
+
+在上一节的表格中我们发现，所有整数类型能够表示的负数都比正数多一个，例如 `byte` 的取值范围是 $[-128, 127]$ 。这个现象比较反直觉，它的内在原因涉及到原码、反码、补码的相关知识。
+
+首先需要指出，**数字是以“补码”的形式存储在计算机中的**。在分析这样做的原因之前，我们首先给出三者的定义。
+
+- **原码**：我们将数字的二进制表示的最高位视为符号位，其中 $0$ 表示正数，$1$ 表示负数，其余位表示数字的值。
+- **反码**：正数的反码与其原码相同，负数的反码是对其原码除符号位外的所有位取反。
+- **补码**：正数的补码与其原码相同，负数的补码是在其反码的基础上加 $1$ 。
+
+下图展示了原码、反码和补码之间的转换方法。
+
+![原码、反码与补码之间的相互转换](number_encoding.assets/1s_2s_complement.png)
+
+「原码 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)$ ；计算乘法和除法可以转换为计算多次加法或减法。
+
+现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无须特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。
+
+补码的设计非常精妙，因篇幅关系我们就先介绍到这里，建议有兴趣的读者进一步深度了解。
+
+## 浮点数编码
+
+细心的你可能会发现：`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)
+
+观察上图，给定一个示例数据 $\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` 的数值越大，相邻两个数字之间的差值就会趋向越大。
+
+如下表所示，指数位 $E = 0$ 和 $E = 255$ 具有特殊含义，**用于表示零、无穷大、$\mathrm{NaN}$ 等**。
+
+<p align="center"> 表 <id> &nbsp; 指数位含义 </p>
+
+| 指数位 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}$            |                                                                        |
+
+值得说明的是，次正规数显著提升了浮点数的精度。最小正正规数为 $2^{-126}$ ，最小正次正规数为 $2^{-126} \times 2^{-23}$ 。
+
+双精度 `double` 也采用类似 `float` 的表示方法，在此不做赘述。

docs/zh/chapter_data_structure/summary.md

@@ -0,0 +1,24 @@
+# 小结
+
+### 重点回顾
+
+- 数据结构可以从逻辑结构和物理结构两个角度进行分类。逻辑结构描述了数据元素之间的逻辑关系，而物理结构描述了数据在计算机内存中的存储方式。
+- 常见的逻辑结构包括线性、树状和网状等。通常我们根据逻辑结构将数据结构分为线性（数组、链表、栈、队列）和非线性（树、图、堆）两种。哈希表的实现可能同时包含线性和非线性结构。
+- 当程序运行时，数据被存储在计算机内存中。每个内存空间都拥有对应的内存地址，程序通过这些内存地址访问数据。
+- 物理结构主要分为连续空间存储（数组）和分散空间存储（链表）。所有数据结构都是由数组、链表或两者的组合实现的。
+- 计算机中的基本数据类型包括整数 `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 编码。
+
+### Q & A
+
+!!! question "为什么哈希表同时包含线性数据结构和非线性数据结构？"
+
+    哈希表底层是数组，而为了解决哈希冲突，我们可能会使用“链式地址”（后续哈希表章节会讲）。在拉链法中，数组中每个地址（桶）指向一个链表；当这个链表长度超过一定阈值时，又可能被转化为树（通常为红黑树）。因此，哈希表可能同时包含线性（数组、链表）和非线性（树）数据结构。
+
+!!! question "`char` 类型的长度是 1 byte 吗？"
+
+    `char` 类型的长度由编程语言采用的编码方法决定。例如，Java、JS、TS、C# 都采用 UTF-16 编码（保存 Unicode 码点），因此 char 类型的长度为 2 bytes 。

docs/zh/chapter_divide_and_conquer/binary_search_recur.md

@@ -0,0 +1,137 @@
+# 分治搜索策略
+
+我们已经学过，搜索算法分为两大类。
+
+- **暴力搜索**：它通过遍历数据结构实现，时间复杂度为 $O(n)$ 。
+- **自适应搜索**：它利用特有的数据组织形式或先验信息，可达到 $O(\log n)$ 甚至 $O(1)$ 的时间复杂度。
+
+实际上，**时间复杂度为 $O(\log n)$ 的搜索算法通常都是基于分治策略实现的**，例如二分查找和树。
+
+- 二分查找的每一步都将问题（在数组中搜索目标元素）分解为一个小问题（在数组的一半中搜索目标元素），这个过程一直持续到数组为空或找到目标元素为止。
+- 树是分治关系的代表，在二叉搜索树、AVL 树、堆等数据结构中，各种操作的时间复杂度皆为 $O(\log n)$ 。
+
+二分查找的分治策略如下所示。
+
+- **问题可以被分解**：二分查找递归地将原问题（在数组中进行查找）分解为子问题（在数组的一半中进行查找），这是通过比较中间元素和目标元素来实现的。
+- **子问题是独立的**：在二分查找中，每轮只处理一个子问题，它不受另外子问题的影响。
+- **子问题的解无须合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
+
+分治能够提升搜索效率，本质上是因为暴力搜索每轮只能排除一个选项，**而分治搜索每轮可以排除一半选项**。
+
+### 基于分治实现二分
+
+在之前的章节中，二分查找是基于递推（迭代）实现的。现在我们基于分治（递归）来实现它。
+
+!!! 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` 或区间为空时返回。
+
+下图展示了在数组中二分查找元素 $6$ 的分治过程。
+
+![二分查找的分治过程](binary_search_recur.assets/binary_search_recur.png)
+
+在实现代码中，我们声明一个递归函数 `dfs()` 来求解问题 $f(i, j)$ 。
+
+=== "Python"
+
+    ```python title="binary_search_recur.py"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binary_search}
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search_recur.cpp"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "Java"
+
+    ```java title="binary_search_recur.java"
+    [class]{binary_search_recur}-[func]{dfs}
+
+    [class]{binary_search_recur}-[func]{binarySearch}
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search_recur.cs"
+    [class]{binary_search_recur}-[func]{dfs}
+
+    [class]{binary_search_recur}-[func]{binarySearch}
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_recur.go"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search_recur.swift"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_search_recur.js"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_search_recur.ts"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search_recur.dart"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_search_recur.rs"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binary_search}
+    ```
+
+=== "C"
+
+    ```c title="binary_search_recur.c"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_recur.zig"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```