build

2024-12-26 13:56:28 +08:00 · 2024-01-12 21:13:51 +08:00 · 2024-01-12 21:13:51 +08:00 · 10c61fd528
commit 10c61fd528
parent 97f3be5bc8
18 changed files with 45 additions and 75 deletions
--- a/docs/chapter_appendix/terminology.md
+++ b/docs/chapter_appendix/terminology.md
@ -60,7 +60,7 @@ status: new
 | 根节点         | root node                      | 剪枝           | pruning                     |
 | 叶节点         | leaf node                      | 全排列问题     | permutations problem        |
 | 边             | edge                           | 子集和问题     | subset-sum problem          |
-| 层             | level                          | N 皇后问题     | N-queens problem            |
+| 层             | level                          | n 皇后问题     | n-queens problem            |
 | 度             | degree                         | 动态规划       | dynamic programming         |
 | 高度           | height                         | 初始状态       | initial state               |
 | 深度           | depth                          | 状态转移方程   | state-trasition equation    |
--- a/docs/chapter_array_and_linkedlist/summary.md
+++ b/docs/chapter_array_and_linkedlist/summary.md
@ -9,8 +9,8 @@ comments: true
 - 数组和链表是两种基本的数据结构，分别代表数据在计算机内存中的两种存储方式：连续空间存储和分散空间存储。两者的特点呈现出互补的特性。
 - 数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变。
 - 链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、环形链表、双向链表。
- 列表是一种支持增删查改的元素有序集合，通常基于动态数组实现，它保留了数组的优势，同时可以灵活调整长度。
- 列表的出现大幅地提高了数组的实用性，但可能导致部分内存空间浪费。
+- 列表是一种支持增删查改的元素有序集合，通常基于动态数组实现。它保留了数组的优势，同时可以灵活调整长度。
+- 列表的出现大幅提高了数组的实用性，但可能导致部分内存空间浪费。
 - 程序运行时，数据主要存储在内存中。数组可提供更高的内存空间效率，而链表则在内存使用上更加灵活。
 - 缓存通过缓存行、预取机制以及空间局部性和时间局部性等数据加载机制，为 CPU 提供快速数据访问，显著提升程序的执行效率。
 - 由于数组具有更高的缓存命中率，因此它通常比链表更高效。在选择数据结构时，应根据具体需求和场景做出恰当选择。
@ -25,14 +25,14 @@ comments: true
 2. 大小限制：栈内存相对较小，堆的大小一般受限于可用内存。因此堆更加适合存储大型数组。
 3. 灵活性：栈上的数组的大小需要在编译时确定，而堆上的数组的大小可以在运行时动态确定。

-**Q**：为什么数组要求相同类型的元素，而在链表中却没有强调同类型呢？
+**Q**：为什么数组要求相同类型的元素，而在链表中却没有强调相同类型呢？

 链表由节点组成，节点之间通过引用（指针）连接，各个节点可以存储不同类型的数据，例如 `int`、`double`、`string`、`object` 等。

 相对地，数组元素则必须是相同类型的，这样才能通过计算偏移量来获取对应元素位置。例如，数组同时包含 `int` 和 `long` 两种类型，单个元素分别占用 4 字节 和 8 字节 ，此时就不能用以下公式计算偏移量了，因为数组中包含了两种“元素长度”。

 ```shell
-# 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
+# 元素内存地址 = 数组内存地址（首元素内存地址） + 元素长度 * 元素索引
 ```

 **Q**：删除节点后，是否需要把 `P.next` 设为 `None` 呢？
--- a/docs/chapter_backtracking/n_queens_problem.md
+++ b/docs/chapter_backtracking/n_queens_problem.md
@ -2,7 +2,7 @@
 comments: true
 ---

-# 13.4 &nbsp; N 皇后问题
+# 13.4 &nbsp; n 皇后问题

 !!! question

@ -64,7 +64,7 @@ comments: true
        diags1: list[bool],
        diags2: list[bool],
    ):
-        """回溯算法：N 皇后"""
+        """回溯算法：n 皇后"""
        # 当放置完所有行时，记录解
        if row == n:
            res.append([list(row) for row in state])
@ -86,7 +86,7 @@ comments: true
                cols[col] = diags1[diag1] = diags2[diag2] = False

    def n_queens(n: int) -> list[list[list[str]]]:
-        """求解 N 皇后"""
+        """求解 n 皇后"""
        # 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        state = [["#" for _ in range(n)] for _ in range(n)]
        cols = [False] * n  # 记录列是否有皇后
@ -101,7 +101,7 @@ comments: true
 === "C++"

    ```cpp title="n_queens.cpp"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
                   vector<bool> &diags1, vector<bool> &diags2) {
        // 当放置完所有行时，记录解
@ -128,7 +128,7 @@ comments: true
        }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    vector<vector<vector<string>>> nQueens(int n) {
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        vector<vector<string>> state(n, vector<string>(n, "#"));
@ -146,7 +146,7 @@ comments: true
 === "Java"

    ```java title="n_queens.java"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    void backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,
            boolean[] cols, boolean[] diags1, boolean[] diags2) {
        // 当放置完所有行时，记录解
@ -177,7 +177,7 @@ comments: true
        }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    List<List<List<String>>> nQueens(int n) {
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        List<List<String>> state = new ArrayList<>();
@ -202,7 +202,7 @@ comments: true
 === "C#"

    ```csharp title="n_queens.cs"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    void Backtrack(int row, int n, List<List<string>> state, List<List<List<string>>> res,
            bool[] cols, bool[] diags1, bool[] diags2) {
        // 当放置完所有行时，记录解
@ -233,7 +233,7 @@ comments: true
        }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    List<List<List<string>>> NQueens(int n) {
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        List<List<string>> state = [];
@ -258,38 +258,7 @@ comments: true
 === "Go"

    ```go title="n_queens.go"
-    /* 回溯算法：N 皇后 */
-    func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
-        // 当放置完所有行时，记录解
-        if row == n {
-            newState := make([][]string, len(*state))
-            for i, _ := range newState {
-                newState[i] = make([]string, len((*state)[0]))
-                copy(newState[i], (*state)[i])
-
-            }
-            *res = append(*res, newState)
-        }
-        // 遍历所有列
-        for col := 0; col < n; col++ {
-            // 计算该格子对应的主对角线和次对角线
-            diag1 := row - col + n - 1
-            diag2 := row + col
-            // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
-            if !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {
-                // 尝试：将皇后放置在该格子
-                (*state)[row][col] = "Q"
-                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true
-                // 放置下一行
-                backtrack(row+1, n, state, res, cols, diags1, diags2)
-                // 回退：将该格子恢复为空位
-                (*state)[row][col] = "#"
-                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false
-            }
-        }
-    }
-
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
        // 当放置完所有行时，记录解
        if row == n {
@ -320,6 +289,7 @@ comments: true
        }
    }

+    /* 求解 n 皇后 */
    func nQueens(n int) [][][]string {
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        state := make([][]string, n)
@ -343,7 +313,7 @@ comments: true
 === "Swift"

    ```swift title="n_queens.swift"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {
        // 当放置完所有行时，记录解
        if row == n {
@ -373,7 +343,7 @@ comments: true
        }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    func nQueens(n: Int) -> [[[String]]] {
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        var state = Array(repeating: Array(repeating: "#", count: n), count: n)
@ -391,7 +361,7 @@ comments: true
 === "JS"

    ```javascript title="n_queens.js"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    function backtrack(row, n, state, res, cols, diags1, diags2) {
        // 当放置完所有行时，记录解
        if (row === n) {
@ -417,7 +387,7 @@ comments: true
        }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    function nQueens(n) {
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        const state = Array.from({ length: n }, () => Array(n).fill('#'));
@ -434,7 +404,7 @@ comments: true
 === "TS"

    ```typescript title="n_queens.ts"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    function backtrack(
        row: number,
        n: number,
@ -468,7 +438,7 @@ comments: true
        }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    function nQueens(n: number): string[][][] {
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        const state = Array.from({ length: n }, () => Array(n).fill('#'));
@ -485,7 +455,7 @@ comments: true
 === "Dart"

    ```dart title="n_queens.dart"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    void backtrack(
      int row,
      int n,
@ -527,7 +497,7 @@ comments: true
      }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    List<List<List<String>>> nQueens(int n) {
      // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
      List<List<String>> state = List.generate(n, (index) => List.filled(n, "#"));
@ -545,7 +515,7 @@ comments: true
 === "Rust"

    ```rust title="n_queens.rs"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    fn backtrack(row: usize, n: usize, state: &mut Vec<Vec<String>>, res: &mut Vec<Vec<Vec<String>>>,
        cols: &mut [bool], diags1: &mut [bool], diags2: &mut [bool]) {
        // 当放置完所有行时，记录解
@ -576,7 +546,7 @@ comments: true
        }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    fn n_queens(n: usize) -> Vec<Vec<Vec<String>>> {
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
        let mut state: Vec<Vec<String>> = Vec::new();
@ -601,7 +571,7 @@ comments: true
 === "C"

    ```c title="n_queens.c"
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
    void backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],
                   bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {
        // 当放置完所有行时，记录解
@ -633,7 +603,7 @@ comments: true
        }
    }

-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
    char ***nQueens(int n, int *returnSize) {
        char state[MAX_SIZE][MAX_SIZE];
        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
--- a/docs/chapter_computational_complexity/performance_evaluation.md
+++ b/docs/chapter_computational_complexity/performance_evaluation.md
@ -14,7 +14,7 @@ comments: true
 - **时间效率**：算法运行速度的快慢。
 - **空间效率**：算法占用内存空间的大小。

-简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有这样我们才能将各种算法进行对比，进而指导算法设计与优化过程。
+简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有这样，我们才能将各种算法进行对比，进而指导算法设计与优化过程。

 效率评估方法主要分为两种：实际测试、理论估算。

--- a/docs/chapter_data_structure/number_encoding.md
+++ b/docs/chapter_data_structure/number_encoding.md
@ -96,7 +96,7 @@ $$

 细心的你可能会发现：`int` 和 `float` 长度相同，都是 4 字节 ，但为什么 `float` 的取值范围远大于 `int` ？这非常反直觉，因为按理说 `float` 需要表示小数，取值范围应该变小才对。

-实际上，**这是因为浮点数 `float` 采用了不同的表示方式**。记一个 32 位长度的二进制数为：
+实际上，**这是因为浮点数 `float` 采用了不同的表示方式**。记一个 32 比特长度的二进制数为：

 $$
 b_{31} b_{30} b_{29} \ldots b_2 b_1 b_0
@ -141,7 +141,7 @@ $$

 现在我们可以回答最初的问题：**`float` 的表示方式包含指数位，导致其取值范围远大于 `int`** 。根据以上计算，`float` 可表示的最大正数为 $2^{254 - 127} \times (2 - 2^{-23}) \approx 3.4 \times 10^{38}$ ，切换符号位便可得到最小负数。

-**尽管浮点数 `float` 扩展了取值范围，但其副作用是牺牲了精度**。整数类型 `int` 将全部 32 位用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 `float` 的数值越大，相邻两个数字之间的差值就会趋向越大。
+**尽管浮点数 `float` 扩展了取值范围，但其副作用是牺牲了精度**。整数类型 `int` 将全部 32 比特用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 `float` 的数值越大，相邻两个数字之间的差值就会趋向越大。

 如表 3-2 所示，指数位 $E = 0$ 和 $E = 255$ 具有特殊含义，**用于表示零、无穷大、$\mathrm{NaN}$ 等**。

--- a/docs/chapter_data_structure/summary.md
+++ b/docs/chapter_data_structure/summary.md
@ -10,7 +10,7 @@ comments: true
 - 常见的逻辑结构包括线性、树状和网状等。通常我们根据逻辑结构将数据结构分为线性（数组、链表、栈、队列）和非线性（树、图、堆）两种。哈希表的实现可能同时包含线性数据结构和非线性数据结构。
 - 当程序运行时，数据被存储在计算机内存中。每个内存空间都拥有对应的内存地址，程序通过这些内存地址访问数据。
 - 物理结构主要分为连续空间存储（数组）和分散空间存储（链表）。所有数据结构都是由数组、链表或两者的组合实现的。
- 计算机中的基本数据类型包括整数 `byte`、`short`、`int`、`long` ，浮点数 `float`、`double` ，字符 `char` 和布尔 `boolean` 。它们的取值范围取决于占用空间大小和表示方式。
+- 计算机中的基本数据类型包括整数 `byte`、`short`、`int`、`long` ，浮点数 `float`、`double` ，字符 `char` 和布尔 `bool` 。它们的取值范围取决于占用空间大小和表示方式。
 - 原码、反码和补码是在计算机中编码数字的三种方法，它们之间可以相互转换。整数的原码的最高位是符号位，其余位是数字的值。
 - 整数在计算机中是以补码的形式存储的。在补码表示下，计算机可以对正数和负数的加法一视同仁，不需要为减法操作单独设计特殊的硬件电路，并且不存在正负零歧义的问题。
 - 浮点数的编码由 1 位符号位、8 位指数位和 23 位分数位构成。由于存在指数位，因此浮点数的取值范围远大于整数，代价是牺牲了精度。
--- a/docs/chapter_divide_and_conquer/build_binary_tree_problem.md
+++ b/docs/chapter_divide_and_conquer/build_binary_tree_problem.md
@ -6,7 +6,7 @@ comments: true

 !!! question

-    给定一棵二叉树的前序遍历 `preorder` 和中序遍历 `inorder` ，请从中构建二叉树，返回二叉树的根节点。假设二叉树中没有值重复的节点，如图 12-5 所示。
+    给定一棵二叉树的前序遍历 `preorder` 和中序遍历 `inorder` ，请从中构建二叉树，返回二叉树的根节点。假设二叉树中没有值重复的节点（如图 12-5 所示）。

 ![构建二叉树的示例数据](build_binary_tree_problem.assets/build_tree_example.png){ class="animation-figure" }

--- a/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md
+++ b/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md
@ -6,7 +6,7 @@ comments: true

 在本节中，我们先求解另一个常见的背包问题：完全背包，再了解它的一种特例：零钱兑换。

-## 14.5.1 &nbsp; 完全背包
+## 14.5.1 &nbsp; 完全背包问题

 !!! question

--- a/docs/chapter_graph/graph.md
+++ b/docs/chapter_graph/graph.md
@ -20,7 +20,7 @@ $$

 <p align="center"> 图 9-1 &nbsp; 链表、树、图之间的关系 </p>

-## 9.1.1 &nbsp; 图常见类型与术语
+## 9.1.1 &nbsp; 图的常见类型与术语

 根据边是否具有方向，可分为「无向图 undirected graph」和「有向图 directed graph」，如图 9-2 所示。

--- a/docs/chapter_graph/graph_operations.md
+++ b/docs/chapter_graph/graph_operations.md
@ -2,7 +2,7 @@
 comments: true
 ---

-# 9.2 &nbsp; 图基础操作
+# 9.2 &nbsp; 图的基础操作

 图的基础操作可分为对“边”的操作和对“顶点”的操作。在“邻接矩阵”和“邻接表”两种表示方法下，实现方式有所不同。

--- a/docs/chapter_preface/about_the_book.md
+++ b/docs/chapter_preface/about_the_book.md
@ -38,13 +38,13 @@ comments: true

 本书在开源社区众多贡献者的共同努力下不断完善。感谢每一位投入时间与精力的撰稿人，他们是（按照 GitHub 自动生成的顺序）：krahets、codingonion、nuomi1、Gonglja、Reanon、justin-tse、danielsss、hpstory、S-N-O-R-L-A-X、night-cruise、msk397、gvenusleo、RiverTwilight、gyt95、zhuoqinyue、Zuoxun、Xia-Sang、mingXta、FangYuan33、GN-Yu、IsChristina、xBLACKICEx、guowei-gong、Cathay-Chen、mgisr、JoseHung、qualifier1024、pengchzn、Guanngxu、longsizhuo、L-Super、what-is-me、yuan0221、lhxsm、Slone123c、WSL0809、longranger2、theNefelibatas、xiongsp、JeffersonHuang、hongyun-robot、K3v123、yuelinxin、a16su、gaofer、malone6、Wonderdch、xjr7670、DullSword、Horbin-Magician、NI-SW、reeswell、XC-Zero、XiaChuerwu、yd-j、iron-irax、huawuque404、MolDuM、Nigh、KorsChen、foursevenlove、52coder、bubble9um、youshaoXG、curly210102、gltianwen、fanchenggang、Transmigration-zhou、FloranceYeh、FreddieLi、ShiMaRing、lipusheng、Javesun99、JackYang-hellobobo、shanghai-Jerry、0130w、Keynman、psychelzh、logan-qiu、ZnYang2018、MwumLi、1ch0、Phoenix0415、qingpeng9802、Richard-Zhang1019、QiLOL、Suremotoo、Turing-1024-Lee、Evilrabbit520、GaochaoZhu、ZJKung、linzeyan、hezhizhen、ZongYangL、beintentional、czruby、coderlef、dshlstarr、szu17dmy、fbigm、gledfish、hts0000、boloboloda、iStig、jiaxianhua、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、liuxjerry、lucaswangdev、lyl625760、chadyi、noobcodemaker、selear、siqyka、syd168、4yDX3906、tao363、wangwang105、weibk、yabo083、yi427、yishangzhang、zhouLion、baagod、ElaBosak233、xb534、luluxia、yanedie、thomasq0 和 YangXuanyi。

-本书的代码审阅工作由 codingonion, Gonglja、gvenusleo、hpstory、justin‐tse、krahets、night-cruise、nuomi1 和 Reanon 完成（按照首字母顺序排列）。感谢他们付出的时间与精力，正是他们确保了各语言代码的规范与统一。
+本书的代码审阅工作由 codingonion、Gonglja、gvenusleo、hpstory、justin-tse、krahets、night-cruise、nuomi1 和 Reanon 完成（按照首字母顺序排列）。感谢他们付出的时间与精力，正是他们确保了各语言代码的规范与统一。

 在本书的创作过程中，我得到了许多人的帮助。

 - 感谢我在公司的导师李汐博士，在一次畅谈中你鼓励我“快行动起来”，坚定了我写这本书的决心；
 - 感谢我的女朋友泡泡作为本书的首位读者，从算法小白的角度提出许多宝贵建议，使得本书更适合新手阅读；
- 感谢腾宝、琦宝、飞宝为本书起了一个富有创意的名字，唤起大家写下第一行代码 "Hello World!" 的美好回忆；
+- 感谢腾宝、琦宝、飞宝为本书起了一个富有创意的名字，唤起大家写下第一行代码“Hello World!”的美好回忆；
 - 感谢校铨在知识产权方面提供的专业帮助，这对本开源书的完善起到了重要作用；
 - 感谢苏潼为本书设计了精美的封面和 logo ，并在我的强迫症的驱使下多次耐心修改；
 - 感谢 @squidfunk 提供的排版建议，以及他开发的开源文档主题 [Material-for-MkDocs](https://github.com/squidfunk/mkdocs-material/tree/master) 。
--- a/docs/chapter_preface/suggestions.md
+++ b/docs/chapter_preface/suggestions.md
@ -175,7 +175,7 @@ comments: true

 相较于文字，视频和图片具有更高的信息密度和结构化程度，更易于理解。在本书中，**重点和难点知识将主要通过动画以图解形式展示**，而文字则作为解释与补充。

-如果你在阅读本书时，发现某段内容提供了如图 0-2 所示的动画或图解，**请以图为主、以文字为辅**，综合两者来理解内容。
+如果你在阅读本书时，发现某段内容提供了如图 0-2 所示的动画图解，**请以图为主、以文字为辅**，综合两者来理解内容。

 ![动画图解示例](../index.assets/animation.gif){ class="animation-figure" }

--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@ -339,7 +339,7 @@ comments: true
    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20binary_search%28nums%3A%20list%5Bint%5D,%20target%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE%EF%BC%88%E5%8F%8C%E9%97%AD%E5%8C%BA%E9%97%B4%EF%BC%89%22%22%22%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%8F%8C%E9%97%AD%E5%8C%BA%E9%97%B4%20%5B0,%20n-1%5D%20%EF%BC%8C%E5%8D%B3%20i,%20j%20%E5%88%86%E5%88%AB%E6%8C%87%E5%90%91%E6%95%B0%E7%BB%84%E9%A6%96%E5%85%83%E7%B4%A0%E3%80%81%E5%B0%BE%E5%85%83%E7%B4%A0%0A%20%20%20%20i,%20j%20%3D%200,%20len%28nums%29%20-%201%0A%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%EF%BC%8C%E5%BD%93%E6%90%9C%E7%B4%A2%E5%8C%BA%E9%97%B4%E4%B8%BA%E7%A9%BA%E6%97%B6%E8%B7%B3%E5%87%BA%EF%BC%88%E5%BD%93%20i%20%3E%20j%20%E6%97%B6%E4%B8%BA%E7%A9%BA%EF%BC%89%0A%20%20%20%20while%20i%20%3C%3D%20j%3A%0A%20%20%20%20%20%20%20%20%23%20%E7%90%86%E8%AE%BA%E4%B8%8A%20Python%20%E7%9A%84%E6%95%B0%E5%AD%97%E5%8F%AF%E4%BB%A5%E6%97%A0%E9%99%90%E5%A4%A7%EF%BC%88%E5%8F%96%E5%86%B3%E4%BA%8E%E5%86%85%E5%AD%98%E5%A4%A7%E5%B0%8F%EF%BC%89%EF%BC%8C%E6%97%A0%E9%A1%BB%E8%80%83%E8%99%91%E5%A4%A7%E6%95%B0%E8%B6%8A%E7%95%8C%E9%97%AE%E9%A2%98%0A%20%20%20%20%20%20%20%20m%20%3D%20%28i%20%2B%20j%29%20//%202%20%20%23%20%E8%AE%A1%E7%AE%97%E4%B8%AD%E7%82%B9%E7%B4%A2%E5%BC%95%20m%0A%20%20%20%20%20%20%20%20if%20nums%5Bm%5D%20%3C%20target%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%3D%20m%20%2B%201%20%20%23%20%E6%AD%A4%E6%83%85%E5%86%B5%E8%AF%B4%E6%98%8E%20target%20%E5%9C%A8%E5%8C%BA%E9%97%B4%20%5Bm%2B1,%20j%5D%20%E4%B8%AD%0A%20%20%20%20%20%20%20%20elif%20nums%5Bm%5D%20%3E%20target%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20j%20%3D%20m%20-%201%20%20%23%20%E6%AD%A4%E6%83%85%E5%86%B5%E8%AF%B4%E6%98%8E%20target%20%E5%9C%A8%E5%8C%BA%E9%97%B4%20%5Bi,%20m-1%5D%20%E4%B8%AD%0A%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20return%20m%20%20%23%20%E6%89%BE%E5%88%B0%E7%9B%AE%E6%A0%87%E5%85%83%E7%B4%A0%EF%BC%8C%E8%BF%94%E5%9B%9E%E5%85%B6%E7%B4%A2%E5%BC%95%0A%20%20%20%20return%20-1%20%20%23%20%E6%9C%AA%E6%89%BE%E5%88%B0%E7%9B%AE%E6%A0%87%E5%85%83%E7%B4%A0%EF%BC%8C%E8%BF%94%E5%9B%9E%20-1%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20target%20%3D%206%0A%20%20%20%20nums%20%3D%20%5B1,%203,%206,%208,%2012,%2015,%2023,%2026,%2031,%2035%5D%0A%0A%20%20%20%20%23%20%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE%EF%BC%88%E5%8F%8C%E9%97%AD%E5%8C%BA%E9%97%B4%EF%BC%89%0A%20%20%20%20index%20%3D%20binary_search%28nums,%20target%29%0A%20%20%20%20print%28%22%E7%9B%AE%E6%A0%87%E5%85%83%E7%B4%A0%206%20%E7%9A%84%E7%B4%A2%E5%BC%95%20%3D%20%22,%20index%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20binary_search%28nums%3A%20list%5Bint%5D,%20target%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE%EF%BC%88%E5%8F%8C%E9%97%AD%E5%8C%BA%E9%97%B4%EF%BC%89%22%22%22%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%8F%8C%E9%97%AD%E5%8C%BA%E9%97%B4%20%5B0,%20n-1%5D%20%EF%BC%8C%E5%8D%B3%20i,%20j%20%E5%88%86%E5%88%AB%E6%8C%87%E5%90%91%E6%95%B0%E7%BB%84%E9%A6%96%E5%85%83%E7%B4%A0%E3%80%81%E5%B0%BE%E5%85%83%E7%B4%A0%0A%20%20%20%20i,%20j%20%3D%200,%20len%28nums%29%20-%201%0A%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%EF%BC%8C%E5%BD%93%E6%90%9C%E7%B4%A2%E5%8C%BA%E9%97%B4%E4%B8%BA%E7%A9%BA%E6%97%B6%E8%B7%B3%E5%87%BA%EF%BC%88%E5%BD%93%20i%20%3E%20j%20%E6%97%B6%E4%B8%BA%E7%A9%BA%EF%BC%89%0A%20%20%20%20while%20i%20%3C%3D%20j%3A%0A%20%20%20%20%20%20%20%20%23%20%E7%90%86%E8%AE%BA%E4%B8%8A%20Python%20%E7%9A%84%E6%95%B0%E5%AD%97%E5%8F%AF%E4%BB%A5%E6%97%A0%E9%99%90%E5%A4%A7%EF%BC%88%E5%8F%96%E5%86%B3%E4%BA%8E%E5%86%85%E5%AD%98%E5%A4%A7%E5%B0%8F%EF%BC%89%EF%BC%8C%E6%97%A0%E9%A1%BB%E8%80%83%E8%99%91%E5%A4%A7%E6%95%B0%E8%B6%8A%E7%95%8C%E9%97%AE%E9%A2%98%0A%20%20%20%20%20%20%20%20m%20%3D%20%28i%20%2B%20j%29%20//%202%20%20%23%20%E8%AE%A1%E7%AE%97%E4%B8%AD%E7%82%B9%E7%B4%A2%E5%BC%95%20m%0A%20%20%20%20%20%20%20%20if%20nums%5Bm%5D%20%3C%20target%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%3D%20m%20%2B%201%20%20%23%20%E6%AD%A4%E6%83%85%E5%86%B5%E8%AF%B4%E6%98%8E%20target%20%E5%9C%A8%E5%8C%BA%E9%97%B4%20%5Bm%2B1,%20j%5D%20%E4%B8%AD%0A%20%20%20%20%20%20%20%20elif%20nums%5Bm%5D%20%3E%20target%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20j%20%3D%20m%20-%201%20%20%23%20%E6%AD%A4%E6%83%85%E5%86%B5%E8%AF%B4%E6%98%8E%20target%20%E5%9C%A8%E5%8C%BA%E9%97%B4%20%5Bi,%20m-1%5D%20%E4%B8%AD%0A%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20return%20m%20%20%23%20%E6%89%BE%E5%88%B0%E7%9B%AE%E6%A0%87%E5%85%83%E7%B4%A0%EF%BC%8C%E8%BF%94%E5%9B%9E%E5%85%B6%E7%B4%A2%E5%BC%95%0A%20%20%20%20return%20-1%20%20%23%20%E6%9C%AA%E6%89%BE%E5%88%B0%E7%9B%AE%E6%A0%87%E5%85%83%E7%B4%A0%EF%BC%8C%E8%BF%94%E5%9B%9E%20-1%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20target%20%3D%206%0A%20%20%20%20nums%20%3D%20%5B1,%203,%206,%208,%2012,%2015,%2023,%2026,%2031,%2035%5D%0A%0A%20%20%20%20%23%20%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE%EF%BC%88%E5%8F%8C%E9%97%AD%E5%8C%BA%E9%97%B4%EF%BC%89%0A%20%20%20%20index%20%3D%20binary_search%28nums,%20target%29%0A%20%20%20%20print%28%22%E7%9B%AE%E6%A0%87%E5%85%83%E7%B4%A0%206%20%E7%9A%84%E7%B4%A2%E5%BC%95%20%3D%20%22,%20index%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">全屏观看 ></a></div>

-**时间复杂度为 $O(\log n)$** ：在二分循环中，区间每轮缩小一半，循环次数为 $\log_2 n$ 。
+**时间复杂度为 $O(\log n)$** ：在二分循环中，区间每轮缩小一半，因此循环次数为 $\log_2 n$ 。

 **空间复杂度为 $O(1)$** ：指针 $i$ 和 $j$ 使用常数大小空间。

--- a/docs/chapter_sorting/heap_sort.md
+++ b/docs/chapter_sorting/heap_sort.md
@ -21,7 +21,7 @@ comments: true

 1. 输入数组并建立大顶堆。完成后，最大元素位于堆顶。
 2. 将堆顶元素（第一个元素）与堆底元素（最后一个元素）交换。完成交换后，堆的长度减 $1$ ，已排序元素数量加 $1$ 。
-3. 从堆顶元素开始，从顶到底执行堆化操作（Sift Down）。完成堆化后，堆的性质得到修复。
+3. 从堆顶元素开始，从顶到底执行堆化操作（sift down）。完成堆化后，堆的性质得到修复。
 4. 循环执行第 `2.` 步和第 `3.` 步。循环 $n - 1$ 轮后，即可完成数组排序。

 !!! tip
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@ -1725,7 +1725,7 @@ comments: true

 综上，我们不能简单地确定哪种实现更加节省内存，需要针对具体情况进行分析。

-## 5.1.4 &nbsp; 栈典型应用
+## 5.1.4 &nbsp; 栈的典型应用

 - **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就会对上一个网页执行入栈，这样我们就可以通过后退操作回到上一个网页。后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么需要两个栈来配合实现。
 - **程序内存管理**。每次调用函数时，系统都会在栈顶添加一个栈帧，用于记录函数的上下文信息。在递归函数中，向下递推阶段会不断执行入栈操作，而向上回溯阶段则会不断执行出栈操作。
--- a/docs/chapter_stack_and_queue/summary.md
+++ b/docs/chapter_stack_and_queue/summary.md
@ -24,7 +24,7 @@ comments: true

 **Q**：双向队列像是两个栈拼接在了一起，它的用途是什么？

-双向队列就像是栈和队列的组合，或两个栈拼在了一起。它表现的是栈 + 队列的逻辑，因此可以实现栈与队列的所有应用，并且更加灵活。
+双向队列就像是栈和队列的组合或两个栈拼在了一起。它表现的是栈 + 队列的逻辑，因此可以实现栈与队列的所有应用，并且更加灵活。

 **Q**：撤销（undo）和反撤销（redo）具体是如何实现的？

--- a/docs/chapter_tree/avl_tree.md
+++ b/docs/chapter_tree/avl_tree.md
@ -22,7 +22,7 @@ comments: true

 ## 7.5.1 &nbsp; AVL 树常见术语

-AVL 树既是二叉搜索树也是平衡二叉树，同时满足这两类二叉树的所有性质，因此也被称为「平衡二叉搜索树 balanced binary search tree」。
+AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二叉树的所有性质，因此也被称为「平衡二叉搜索树 balanced binary search tree」。

 ### 1. &nbsp; 节点高度

--- a/docs/index.md
+++ b/docs/index.md
@ -156,7 +156,7 @@ hide:
    </a>
 </p>

-本书的代码审阅工作由 codingonion、Gonglja、gvenusleo、hpstory、justin‐tse、krahets、night-cruise、nuomi1 和 Reanon 完成（按照首字母顺序排列）。感谢他们付出的时间与精力，正是他们确保了各语言代码的规范与统一。
+本书的代码审阅工作由 codingonion、Gonglja、gvenusleo、hpstory、justin-tse、krahets、night-cruise、nuomi1 和 Reanon 完成（按照首字母顺序排列）。感谢他们付出的时间与精力，正是他们确保了各语言代码的规范与统一。

 <div class="center-table">
    <table style="border: none;">