build

chapter_appendix/installation.md

@@ -15,7 +15,7 @@ comments: true
 
 ## 16.1.3   C/C++ 环境
 
-1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)（[配置教程](https://blog.csdn.net/qq_33698226/article/details/129031241)），MacOS 自带 Clang 无需安装。
+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 }` 。
 

chapter_array_and_linkedlist/array.md

@@ -472,7 +472,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 同理，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。
 
-请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无需特意去修改它。
+请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。
 
 ![数组删除元素](array.assets/array_remove_element.png)
 
@@ -1208,7 +1208,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 数组存储在连续的内存空间内，且元素类型相同。这包含丰富的先验信息，系统可以利用这些信息来优化操作和运行效率，包括：
 
-- **空间效率高**: 数组为数据分配了连续的内存块，无需额外的结构开销。
+- **空间效率高**: 数组为数据分配了连续的内存块，无须额外的结构开销。
 - **支持随机访问**: 数组允许在 $O(1)$ 时间内访问任何元素。
 - **缓存局部性**: 当访问数组元素时，计算机不仅会加载它，还会缓存其周围的其他数据，从而借助高速缓存来提升后续操作的执行速度。
 

chapter_array_and_linkedlist/linked_list.md

@@ -6,7 +6,7 @@ comments: true
 
 内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。
 
-「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无需连续的。
+「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。
 
 ![链表定义与存储方式](linked_list.assets/linkedlist_definition.png)
 

chapter_array_and_linkedlist/list.md

@@ -6,7 +6,7 @@ comments: true
 
 **数组长度不可变导致实用性降低**。在实际中，我们可能事先无法确定需要存储多少数据，这使数组长度的选择变得困难。若长度过小，需要在持续添加数据时频繁扩容数组；若长度过大，则会造成内存空间的浪费。
 
-为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无需担心超过容量限制。
+为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无须担心超过容量限制。
 
 ## 4.3.1   列表常用操作
 

chapter_array_and_linkedlist/summary.md

@@ -59,7 +59,7 @@ comments: true
 
     假如把列表元素换成链表节点 `n = [n1, n2, n3, n4, n5]` ，通常情况下这五个节点对象也是被分散存储在内存各处的。然而，给定一个列表索引，我们仍然可以在 $O(1)$ 时间内获取到节点内存地址，从而访问到对应的节点。这是因为数组中存储的是节点的引用，而非节点本身。
 
-    与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无需连续的。
+    与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无须连续的。
 
 !!! question "C++ STL 里面的 std::list 已经实现了双向链表，但好像一些算法的书上都不怎么直接用这个，是不是有什么局限性呢?"
 

chapter_backtracking/subset_sum_problem.md

@@ -19,7 +19,7 @@ comments: true
 
 类似于全排列问题，我们可以把子集的生成过程想象成一系列选择的结果，并在选择过程中实时更新“元素和”，当元素和等于 `target` 时，就将子集记录至结果列表。
 
-而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无需借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。
+而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无须借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。
 
 === "Java"
 

chapter_computational_complexity/index.md

@@ -13,9 +13,9 @@ icon: material/timer-sand
 
 !!! abstract
 
-    复杂度犹如浩瀚的算法宇宙中的指南针。
+    复杂度犹如浩瀚的算法宇宙中的时空向导。
     
-    它引导我们在时间与空间的维度上深入探索，寻找更优雅的解决方案。
+    它带领我们在时间与空间这两个维度上深入探索，寻找更优雅的解决方案。
 
 ## 本章内容
 

chapter_computational_complexity/performance_evaluation.md

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

chapter_computational_complexity/space_complexity.md

@@ -4,25 +4,25 @@ comments: true
 
 # 2.3   空间复杂度
 
-「空间复杂度 Space Complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。
+「空间复杂度 space complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。
 
 ## 2.3.1   算法相关空间
 
-算法运行过程中使用的内存空间主要包括以下几种：
+算法在运行过程中使用的内存空间主要包括以下几种。
 
 - **输入空间**：用于存储算法的输入数据。
-- **暂存空间**：用于存储算法运行过程中的变量、对象、函数上下文等数据。
+- **暂存空间**：用于存储算法在运行过程中的变量、对象、函数上下文等数据。
 - **输出空间**：用于存储算法的输出数据。
 
 一般情况下，空间复杂度的统计范围是“暂存空间”加上“输出空间”。
 
-暂存空间可以进一步划分为三个部分：
+暂存空间可以进一步划分为三个部分。
 
 - **暂存数据**：用于保存算法运行过程中的各种常量、变量、对象等。
 - **栈帧空间**：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
 - **指令空间**：用于保存编译后的程序指令，在实际统计中通常忽略不计。
 
-因此在分析一段程序的空间复杂度时，**我们通常统计暂存数据、输出数据、栈帧空间三部分**。
+在分析一段程序的空间复杂度时，**我们通常统计暂存数据、栈帧空间和输出数据三部分**。
 
 ![算法使用的相关空间](space_complexity.assets/space_types.png)
 
@@ -294,7 +294,7 @@ comments: true
 
 ## 2.3.2   推算方法
 
-空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“计算操作数量”转为“使用空间大小”。
+空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“操作数量”转为“使用空间大小”。
 
 而与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
 
@@ -432,7 +432,7 @@ comments: true
 
     ```
 
-**在递归函数中，需要注意统计栈帧空间**。例如以下代码：
+**在递归函数中，需要注意统计栈帧空间**。例如在以下代码中：
 
 - 函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。
 - 递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
@@ -658,7 +658,7 @@ comments: true
 
 ## 2.3.3   常见类型
 
-设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）：
+设输入数据大小为 $n$ ，下图展示了常见的空间复杂度类型（从低到高排列）。
 
 $$
 \begin{aligned}
@@ -667,19 +667,19 @@ O(1) < O(\log n) < O(n) < O(n^2) < O(2^n) \newline
 \end{aligned}
 $$
 
-![空间复杂度的常见类型](space_complexity.assets/space_complexity_common_types.png)
+![常见的空间复杂度类型](space_complexity.assets/space_complexity_common_types.png)
 
-<p align="center"> 图：空间复杂度的常见类型 </p>
+<p align="center"> 图：常见的空间复杂度类型 </p>
 
 !!! tip
 
-    部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学习完后面章节后再来复习。
+    部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学完后面章节后再来复习。
 
 ### 1. &nbsp; 常数阶 $O(1)$
 
 常数阶常见于数量与输入数据大小 $n$ 无关的常量、变量、对象。
 
-需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ 。
+需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ ：
 
 === "Java"
 
@@ -1010,7 +1010,7 @@ $$
 
 ### 2. &nbsp; 线性阶 $O(n)$
 
-线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
+线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等：
 
 === "Java"
 
@@ -1274,7 +1274,7 @@ $$
     }
     ```
 
-以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
+以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间：
 
 === "Java"
 
@@ -1421,7 +1421,7 @@ $$
 
 ### 3. &nbsp; 平方阶 $O(n^2)$
 
-平方阶常见于矩阵和图，元素数量与 $n$ 成平方关系。
+平方阶常见于矩阵和图，元素数量与 $n$ 成平方关系：
 
 === "Java"
 
@@ -1800,7 +1800,7 @@ $$
 
 ### 4. &nbsp; 指数阶 $O(2^n)$
 
-指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间。
+指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间：
 
 === "Java"
 
@@ -1974,9 +1974,9 @@ $$
 
 对数阶常见于分治算法和数据类型转换等。
 
-例如“归并排序”算法，输入长度为 $n$ 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log n$ 的递归树，使用 $O(\log n)$ 栈帧空间。
+例如归并排序算法，输入长度为 $n$ 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log n$ 的递归树，使用 $O(\log n)$ 栈帧空间。
 
-再例如“数字转化为字符串”，输入任意正整数 $n$ ，它的位数为 $\log_{10} n$ ，即对应字符串长度为 $\log_{10} n$ ，因此空间复杂度为 $O(\log_{10} n) = O(\log n)$ 。
+再例如将数字转化为字符串，输入任意正整数 $n$ ，它的位数为 $\log_{10} n + 1$ ，即对应字符串长度为 $\log_{10} n + 1$ ，因此空间复杂度为 $O(\log_{10} n + 1) = O(\log n)$ 。
 
 ## 2.3.4 &nbsp; 权衡时间与空间
 
@@ -1984,4 +1984,4 @@ $$
 
 **降低时间复杂度通常需要以提升空间复杂度为代价，反之亦然**。我们将牺牲内存空间来提升算法运行速度的思路称为“以空间换时间”；反之，则称为“以时间换空间”。
 
-选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此以空间换时间通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。
+选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此“以空间换时间”通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。

chapter_computational_complexity/summary.md

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

chapter_computational_complexity/time_complexity.md

@@ -7,14 +7,10 @@ comments: true
 运行时间可以直观且准确地反映算法的效率。如果我们想要准确预估一段代码的运行时间，应该如何操作呢？
 
 1. **确定运行平台**，包括硬件配置、编程语言、系统环境等，这些因素都会影响代码的运行效率。
-2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作需要 5 ns 等。
+2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作 `print()` 需要 5 ns 等。
 3. **统计代码中所有的计算操作**，并将所有操作的执行时间求和，从而得到运行时间。
 
-例如以下代码，输入数据大小为 $n$ 。根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。
-
-$$
-1 + 1 + 10 + (1 + 5) \times n = 6n + 12
-$$
+例如在以下代码中，输入数据大小为 $n$ ：
 
 === "Java"
 
@@ -185,28 +181,34 @@ $$
     }
     ```
 
-但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
+根据以上方法，可以得到算法运行时间为 $6n + 12$ ns ：
+
+$$
+1 + 1 + 10 + (1 + 5) \times n = 6n + 12
+$$
+
+但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望将预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
 
 ## 2.2.1   统计时间增长趋势
 
 「时间复杂度分析」采取了一种不同的方法，其统计的不是算法运行时间，**而是算法运行时间随着数据量变大时的增长趋势**。
 
-“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` , `B` , `C` 。
+“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` 、 `B` 和 `C` ：
 
 === "Java"
 
     ```java title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithm_A(int n) {
         System.out.println(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithm_B(int n) {
         for (int i = 0; i < n; i++) {
             System.out.println(0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithm_C(int n) {
         for (int i = 0; i < 1000000; i++) {
             System.out.println(0);
@@ -217,17 +219,17 @@ $$
 === "C++"
 
     ```cpp title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithm_A(int n) {
         cout << 0 << endl;
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithm_B(int n) {
         for (int i = 0; i < n; i++) {
             cout << 0 << endl;
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithm_C(int n) {
         for (int i = 0; i < 1000000; i++) {
             cout << 0 << endl;
@@ -238,14 +240,14 @@ $$
 === "Python"
 
     ```python title=""
-    # 算法 A 时间复杂度：常数阶
+    # 算法 A 的时间复杂度：常数阶
     def algorithm_A(n: int):
         print(0)
-    # 算法 B 时间复杂度：线性阶
+    # 算法 B 的时间复杂度：线性阶
     def algorithm_B(n: int):
         for _ in range(n):
             print(0)
-    # 算法 C 时间复杂度：常数阶
+    # 算法 C 的时间复杂度：常数阶
     def algorithm_C(n: int):
         for _ in range(1000000):
             print(0)
@@ -254,17 +256,17 @@ $$
 === "Go"
 
     ```go title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     func algorithm_A(n int) {
         fmt.Println(0)
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     func algorithm_B(n int) {
         for i := 0; i < n; i++ {
             fmt.Println(0)
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     func algorithm_C(n int) {
         for i := 0; i < 1000000; i++ {
             fmt.Println(0)
@@ -275,17 +277,17 @@ $$
 === "JS"
 
     ```javascript title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     function algorithm_A(n) {
         console.log(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     function algorithm_B(n) {
         for (let i = 0; i < n; i++) {
             console.log(0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     function algorithm_C(n) {
         for (let i = 0; i < 1000000; i++) {
             console.log(0);
@@ -297,17 +299,17 @@ $$
 === "TS"
 
     ```typescript title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     function algorithm_A(n: number): void {
         console.log(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     function algorithm_B(n: number): void {
         for (let i = 0; i < n; i++) {
             console.log(0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     function algorithm_C(n: number): void {
         for (let i = 0; i < 1000000; i++) {
             console.log(0);
@@ -318,17 +320,17 @@ $$
 === "C"
 
     ```c title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithm_A(int n) {
         printf("%d", 0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithm_B(int n) {
         for (int i = 0; i < n; i++) {
             printf("%d", 0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithm_C(int n) {
         for (int i = 0; i < 1000000; i++) {
             printf("%d", 0);
@@ -339,17 +341,17 @@ $$
 === "C#"
 
     ```csharp title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithm_A(int n) {
         Console.WriteLine(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithm_B(int n) {
         for (int i = 0; i < n; i++) {
             Console.WriteLine(0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithm_C(int n) {
         for (int i = 0; i < 1000000; i++) {
             Console.WriteLine(0);
@@ -360,19 +362,19 @@ $$
 === "Swift"
 
     ```swift title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     func algorithmA(n: Int) {
         print(0)
     }
 
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     func algorithmB(n: Int) {
         for _ in 0 ..< n {
             print(0)
         }
     }
 
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     func algorithmC(n: Int) {
         for _ in 0 ..< 1000000 {
             print(0)
@@ -389,17 +391,17 @@ $$
 === "Dart"
 
     ```dart title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithmA(int n) {
       print(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithmB(int n) {
       for (int i = 0; i < n; i++) {
         print(0);
       }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithmC(int n) {
       for (int i = 0; i < 1000000; i++) {
         print(0);
@@ -410,17 +412,17 @@ $$
 === "Rust"
 
     ```rust title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     fn algorithm_A(n: i32) {
         println!("{}", 0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     fn algorithm_B(n: i32) {
         for _ in 0..n {
             println!("{}", 0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     fn algorithm_C(n: i32) {
         for _ in 0..1000000 {
             println!("{}", 0);
@@ -434,21 +436,19 @@ $$
 
 算法 `C` 中的打印操作需要循环 $1000000$ 次，虽然运行时间很长，但它与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
 
-![算法 A, B, C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
+![算法 A 、B 和 C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
 
-<p align="center"> 图：算法 A, B, C 的时间增长趋势 </p>
+<p align="center"> 图：算法 A 、B 和 C 的时间增长趋势 </p>
 
 相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？
 
-**时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。
-
-**时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。
-
-**时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
+- **时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。
+- **时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。
+- **时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率的高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
 
 ## 2.2.2 &nbsp; 函数渐近上界
 
-给定一个函数 `algorithm()` ：
+给定一个输入大小为 $n$ 的函数：
 
 === "Java"
 
@@ -609,15 +609,15 @@ $$
     }
     ```
 
-设算法的计算操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
+设算法的操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
 
 $$
 T(n) = 3 + 2n
 $$
 
-$T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时间复杂度是线性阶。
+$T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因此它的时间复杂度是线性阶。
 
-我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 Big-$O$ Notation」，表示函数 $T(n)$ 的「渐近上界 Asymptotic Upper Bound」。
+我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 big-$O$ notation」，表示函数 $T(n)$ 的「渐近上界 asymptotic upper bound」。
 
 时间复杂度分析本质上是计算“操作数量函数 $T(n)$”的渐近上界。接下来，我们来看函数渐近上界的数学定义。
 
@@ -632,27 +632,27 @@ $T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时
     T(n) = O(f(n))
     $$
 
+如下图所示，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
+
 ![函数的渐近上界](time_complexity.assets/asymptotic_upper_bound.png)
 
 <p align="center"> 图：函数的渐近上界 </p>
 
-也就是说，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
-
 ## 2.2.3 &nbsp; 推算方法
 
-渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无需担心。因为在实际使用中，我们只需要掌握推算方法，数学意义可以逐渐领悟。
+渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无须担心。因为在实际使用中，我们只需要掌握推算方法，数学意义就可以逐渐领悟。
 
 根据定义，确定 $f(n)$ 之后，我们便可得到时间复杂度 $O(f(n))$ 。那么如何确定渐近上界 $f(n)$ 呢？总体分为两步：首先统计操作数量，然后判断渐近上界。
 
 ### 1. &nbsp; 第一步：统计操作数量
 
-针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧：
+针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧。
 
 1. **忽略 $T(n)$ 中的常数项**。因为它们都与 $n$ 无关，所以对时间复杂度不产生影响。
 2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次等，都可以简化记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度没有影响。
 3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
 
-以下示例展示了使用上述技巧前、后的统计结果。两者推出的时间复杂度相同，即为 $O(n^2)$ 。
+以下代码与公式分别展示了使用上述技巧前后的统计结果。两者推出的时间复杂度相同，都为 $O(n^2)$ 。
 
 $$
 \begin{aligned}
@@ -880,7 +880,8 @@ $$
 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。
 
 以下表格展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 $n$ 趋于无穷大时，这些常数变得无足轻重。
-<p align="center"> 表：多项式时间复杂度示例 </p>
+
+<p align="center"> 表：不同操作数量对应的时间复杂度 </p>
 
 <div class="center-table" markdown>
 
@@ -905,19 +906,19 @@ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!) \newline
 \end{aligned}
 $$
 
-![时间复杂度的常见类型](time_complexity.assets/time_complexity_common_types.png)
+![常见的时间复杂度类型](time_complexity.assets/time_complexity_common_types.png)
 
-<p align="center"> 图：时间复杂度的常见类型 </p>
+<p align="center"> 图：常见的时间复杂度类型 </p>
 
 !!! tip
 
-    部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学习完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
+    部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
 
 ### 1. &nbsp; 常数阶 $O(1)$
 
 常数阶的操作数量与输入数据大小 $n$ 无关，即不随着 $n$ 的变化而变化。
 
-对于以下算法，尽管操作数量 `size` 可能很大，但由于其与数据大小 $n$ 无关，因此时间复杂度仍为 $O(1)$ 。
+对于以下算法，尽管操作数量 `size` 可能很大，但由于其与输入数据大小 $n$ 无关，因此时间复杂度仍为 $O(1)$ ：
 
 === "Java"
 
@@ -1084,7 +1085,7 @@ $$
 
 ### 2. &nbsp; 线性阶 $O(n)$
 
-线性阶的操作数量相对于输入数据大小以线性级别增长。线性阶通常出现在单层循环中。
+线性阶的操作数量相对于输入数据大小 $n$ 以线性级别增长。线性阶通常出现在单层循环中：
 
 === "Java"
 
@@ -1234,7 +1235,7 @@ $$
     }
     ```
 
-遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
+遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度：
 
 === "Java"
 
@@ -1402,11 +1403,11 @@ $$
     }
     ```
 
-值得注意的是，**数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。
+值得注意的是，**输入数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。
 
 ### 3. &nbsp; 平方阶 $O(n^2)$
 
-平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ 。
+平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ ：
 
 === "Java"
 
@@ -1599,11 +1600,13 @@ $$
     }
     ```
 
-![常数阶、线性阶、平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
+下图对比了常数阶、线性阶和平方阶三种时间复杂度。
 
-<p align="center"> 图：常数阶、线性阶、平方阶的时间复杂度 </p>
+![常数阶、线性阶和平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
 
-以「冒泡排序」为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。
+<p align="center"> 图：常数阶、线性阶和平方阶的时间复杂度 </p>
+
+以冒泡排序为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ ：
 
 $$
 O((n - 1) \frac{n}{2}) = O(n^2)
@@ -1883,9 +1886,7 @@ $$
 
 ### 4. &nbsp; 指数阶 $O(2^n)$
 
-生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。
-
-以下代码模拟了细胞分裂的过程。
+生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。相关代码如下：
 
 === "Java"
 
@@ -2109,11 +2110,13 @@ $$
     }
     ```
 
+下图展示了细胞分裂的过程。
+
 ![指数阶的时间复杂度](time_complexity.assets/time_complexity_exponential.png)
 
 <p align="center"> 图：指数阶的时间复杂度 </p>
 
-在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止。
+在实际算法中，指数阶常出现于递归函数中。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止：
 
 === "Java"
 
@@ -2248,7 +2251,7 @@ $$
 
 ### 5. &nbsp; 对数阶 $O(\log n)$
 
-与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
+与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。相关代码如下：
 
 === "Java"
 
@@ -2423,7 +2426,7 @@ $$
 
 <p align="center"> 图：对数阶的时间复杂度 </p>
 
-与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。
+与指数阶类似，对数阶也常出现于递归函数中。以下代码形成了一个高度为 $\log_2 n$ 的递归树：
 
 === "Java"
 
@@ -2554,13 +2557,11 @@ $$
     }
     ```
 
-对数阶常出现于基于「分治」的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。
+对数阶常出现于基于分治策略的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。
 
 ### 6. &nbsp; 线性对数阶 $O(n \log n)$
 
-线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
-
-主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。
+线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。相关代码如下：
 
 === "Java"
 
@@ -2748,6 +2749,8 @@ $$
 
 <p align="center"> 图：线性对数阶的时间复杂度 </p>
 
+主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。
+
 ### 7. &nbsp; 阶乘阶 $O(n!)$
 
 阶乘阶对应数学上的“全排列”问题。给定 $n$ 个互不重复的元素，求其所有可能的排列方案，方案数量为：
@@ -2756,7 +2759,7 @@ $$
 n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1
 $$
 
-阶乘通常使用递归实现。例如以下代码，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时终止分裂。
+阶乘通常使用递归实现。例如在以下代码中，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时停止分裂：
 
 === "Java"
 
@@ -2950,16 +2953,16 @@ $$
 
 <p align="center"> 图：阶乘阶的时间复杂度 </p>
 
-请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长地更快，在 $n$ 较大时也是不可接受的。
+请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长得更快，在 $n$ 较大时也是不可接受的。
 
 ## 2.2.5 &nbsp; 最差、最佳、平均时间复杂度
 
-**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论：
+**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，每个数字只出现一次，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论。
 
 - 当 `nums = [?, ?, ..., 1]` ，即当末尾元素是 $1$ 时，需要完整遍历数组，**达到最差时间复杂度 $O(n)$** 。
-- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。
+- 当 `nums = [1, ?, ?, ...]` ，即当首个元素为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。
 
-「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示。
+「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示：
 
 === "Java"
 
@@ -3315,10 +3318,10 @@ $$
 
 从上述示例可以看出，最差或最佳时间复杂度只出现于“特殊的数据分布”，这些情况的出现概率可能很小，并不能真实地反映算法运行效率。相比之下，**「平均时间复杂度」可以体现算法在随机输入数据下的运行效率**，用 $\Theta$ 记号来表示。
 
-对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数则是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
+对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数就是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
 
 但对于较为复杂的算法，计算平均时间复杂度往往是比较困难的，因为很难分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。
 
 !!! question "为什么很少看到 $\Theta$ 符号？"
 
-    可能由于 $O$ 符号过于朗朗上口，我们常常使用它来表示「平均复杂度」，但从严格意义上看，这种做法并不规范。在本书和其他资料中，若遇到类似“平均时间复杂度 $O(n)$”的表述，请将其直接理解为 $\Theta(n)$ 。
+    可能由于 $O$ 符号过于朗朗上口，我们常常使用它来表示平均时间复杂度。但从严格意义上看，这种做法并不规范。在本书和其他资料中，若遇到类似“平均时间复杂度 $O(n)$”的表述，请将其直接理解为 $\Theta(n)$ 。

chapter_data_structure/basic_data_types.md

@@ -20,7 +20,7 @@ comments: true
 - 整数类型 `byte` 占用 $1$ byte = $8$ bits ，可以表示 $2^{8}$ 个数字。
 - 整数类型 `int` 占用 $4$ bytes = $32$ bits ，可以表示 $2^{32}$ 个数字。
 
-下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无需硬背，大致理解即可，需要时可以通过查表来回忆。
+下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无须硬背，大致理解即可，需要时可以通过查表来回忆。
 <p align="center"> 表：基本数据类型的占用空间和取值范围 </p>
 
 <div class="center-table" markdown>

chapter_data_structure/number_encoding.md

@@ -88,7 +88,7 @@ $$
 
 请注意，这并不意味着计算机只能做加法。**通过将加法与一些基本逻辑运算结合，计算机能够实现各种其他的数学运算**。例如，计算减法 $a - b$ 可以转换为计算加法 $a + (-b)$ ；计算乘法和除法可以转换为计算多次加法或减法。
 
-现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无需特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。
+现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无须特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。
 
 补码的设计非常精妙，因篇幅关系我们就先介绍到这里，建议有兴趣的读者进一步深度了解。
 

chapter_divide_and_conquer/binary_search_recur.md

@@ -19,7 +19,7 @@ status: new
 
 - **问题可以被分解**：二分查找递归地将原问题（在数组中进行查找）分解为子问题（在数组的一半中进行查找），这是通过比较中间元素和目标元素来实现的。
 - **子问题是独立的**：在二分查找中，每轮只处理一个子问题，它不受另外子问题的影响。
-- **子问题的解无需合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
+- **子问题的解无须合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
 
 分治能够提升搜索效率，本质上是因为暴力搜索每轮只能排除一个选项，**而分治搜索每轮可以排除一半选项**。
 

chapter_divide_and_conquer/summary.md

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

chapter_dynamic_programming/dp_problem_features.md

@@ -435,7 +435,7 @@ $$
 
 「无后效性」是动态规划能够有效解决问题的重要特性之一，定义为：**给定一个确定的状态，它的未来发展只与当前状态有关，而与当前状态过去所经历过的所有状态无关**。
 
-以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无需考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。
+以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无须考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。
 
 然而，如果我们向爬楼梯问题添加一个约束，情况就不一样了。
 

chapter_dynamic_programming/edit_distance_problem.md

@@ -64,7 +64,7 @@ $$
 dp[i, j] = \min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1
 $$
 
-请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无需编辑当前字符**，这种情况下的状态转移方程为：
+请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无须编辑当前字符**，这种情况下的状态转移方程为：
 
 $$
 dp[i, j] = dp[i-1, j-1]

chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -929,7 +929,7 @@ $$
 
 与之相反，**动态规划是一种“从底至顶”的方法**：从最小子问题的解开始，迭代地构建更大子问题的解，直至得到原问题的解。
 
-由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无需使用递归。在以下代码中，我们初始化一个数组 `dp` 来存储子问题的解，它起到了记忆化搜索中数组 `mem` 相同的记录作用。
+由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无须使用递归。在以下代码中，我们初始化一个数组 `dp` 来存储子问题的解，它起到了记忆化搜索中数组 `mem` 相同的记录作用。
 
 === "Java"
 
@@ -1169,7 +1169,7 @@ $$
 
 ## 14.1.4   状态压缩
 
-细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。
+细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无须使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。
 
 === "Java"
 

chapter_dynamic_programming/summary.md

@@ -24,5 +24,5 @@ status: new
 **编辑距离问题**
 
 - 编辑距离（Levenshtein 距离）用于衡量两个字符串之间的相似度，其定义为从一个字符串到另一个字符串的最小编辑步数，编辑操作包括添加、删除、替换。
-- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无需编辑当前字符。
+- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无须编辑当前字符。
 - 在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此状态压缩后正序或倒序遍历都无法正确地进行状态转移。为此，我们利用一个变量暂存左上方状态，从而转化到与完全背包等价的情况，可以在状态压缩后进行正序遍历。

chapter_dynamic_programming/unbounded_knapsack_problem.md

@@ -1202,7 +1202,7 @@ $$
 dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]]
 $$
 
-当目标金额为 $0$ 时，无需选择任何硬币即可凑出目标金额，因此应将首列所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此首行所有 $dp[0, a]$ 都等于 $0$ 。
+当目标金额为 $0$ 时，无须选择任何硬币即可凑出目标金额，因此应将首列所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此首行所有 $dp[0, a]$ 都等于 $0$ 。
 
 ### 2.   代码实现
 

chapter_graph/graph_operations.md

@@ -1155,7 +1155,7 @@ comments: true
 
 - 如果我们选择通过顶点值来区分不同顶点，那么值重复的顶点将无法被区分。
 - 如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 $i$ 的顶点，则需要遍历整个邻接表，将其中 $> i$ 的索引全部减 $1$ ，这样操作效率较低。
-- 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无需改动其余顶点了。
+- 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无须改动其余顶点了。
 
 === "Java"
 

chapter_greedy/max_product_cutting_problem.md

@@ -66,7 +66,7 @@ $$
 
 ### 2.   代码实现
 
-在代码中，我们无需通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
+在代码中，我们无须通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
 
 $$
 n = 3 a + b

chapter_heap/build_heap.md

@@ -16,7 +16,7 @@ comments: true
 
 有趣的是，存在一种更高效的建堆方法，其时间复杂度可以达到 $O(n)$ 。我们先将列表所有元素原封不动添加到堆中，然后倒序遍历该堆，依次对每个节点执行“从顶至底堆化”。
 
-请注意，因为叶节点没有子节点，所以无需堆化。在代码实现中，我们从最后一个节点的父节点开始进行堆化。
+请注意，因为叶节点没有子节点，所以无须堆化。在代码实现中，我们从最后一个节点的父节点开始进行堆化。
 
 === "Java"
 

chapter_heap/heap.md

@@ -680,7 +680,7 @@ comments: true
 
 给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏。因此，**需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 Heapify」。
 
-考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无需交换的节点时结束。
+考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。
 
 === "<1>"
     ![元素入堆步骤](heap.assets/heap_push_step1.png)
@@ -729,7 +729,7 @@ comments: true
         while (true) {
             // 获取节点 i 的父节点
             int p = parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
                 break;
             // 交换两节点
@@ -756,7 +756,7 @@ comments: true
         while (true) {
             // 获取节点 i 的父节点
             int p = parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || maxHeap[i] <= maxHeap[p])
                 break;
             // 交换两节点
@@ -782,7 +782,7 @@ comments: true
         while True:
             # 获取节点 i 的父节点
             p = self.parent(i)
-            # 当“越过根节点”或“节点无需修复”时，结束堆化
+            # 当“越过根节点”或“节点无须修复”时，结束堆化
             if p < 0 or self.max_heap[i] <= self.max_heap[p]:
                 break
             # 交换两节点
@@ -807,7 +807,7 @@ comments: true
         for true {
             // 获取节点 i 的父节点
             p := h.parent(i)
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if p < 0 || h.data[i].(int) <= h.data[p].(int) {
                 break
             }
@@ -835,7 +835,7 @@ comments: true
         while (true) {
             // 获取节点 i 的父节点
             const p = this.#parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;
             // 交换两节点
             this.#swap(i, p);
@@ -861,7 +861,7 @@ comments: true
         while (true) {
             // 获取节点 i 的父节点
             const p = this.parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;
             // 交换两节点
             this.swap(i, p);
@@ -894,7 +894,7 @@ comments: true
         while (true) {
             // 获取节点 i 的父节点
             int p = parent(h, i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || h->data[i] <= h->data[p]) {
                 break;
             }
@@ -922,7 +922,7 @@ comments: true
         while (true) {
             // 获取节点 i 的父节点
             int p = parent(i);
-            // 若“越过根节点”或“节点无需修复”，则结束堆化
+            // 若“越过根节点”或“节点无须修复”，则结束堆化
             if (p < 0 || maxHeap[i] <= maxHeap[p])
                 break;
             // 交换两节点
@@ -950,7 +950,7 @@ comments: true
         while true {
             // 获取节点 i 的父节点
             let p = parent(i: i)
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if p < 0 || maxHeap[i] <= maxHeap[p] {
                 break
             }
@@ -979,7 +979,7 @@ comments: true
         while (true) {
             // 获取节点 i 的父节点
             var p = parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;
             // 交换两节点
             try self.swap(i, p);
@@ -1005,7 +1005,7 @@ comments: true
       while (true) {
         // 获取节点 i 的父节点
         int p = _parent(i);
-        // 当“越过根节点”或“节点无需修复”时，结束堆化
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
         if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {
           break;
         }
@@ -1037,7 +1037,7 @@ comments: true
             }
             // 获取节点 i 的父节点
             let p = Self::parent(i);
-            // 当“节点无需修复”时，结束堆化
+            // 当“节点无须修复”时，结束堆化
             if self.max_heap[i] <= self.max_heap[p] {
                 break;
             }
@@ -1057,7 +1057,7 @@ comments: true
 2. 交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）。
 3. 从根节点开始，**从顶至底执行堆化**。
 
-顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无需交换的节点时结束。
+顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。
 
 === "<1>"
     ![堆顶元素出堆步骤](heap.assets/heap_pop_step1.png)
@@ -1120,7 +1120,7 @@ comments: true
                 ma = l;
             if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i)
                 break;
             // 交换两节点
@@ -1153,12 +1153,12 @@ comments: true
         while (true) {
             // 判断节点 i, l, r 中值最大的节点，记为 ma
             int l = left(i), r = right(i), ma = i;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (l < size() && maxHeap[l] > maxHeap[ma])
                 ma = l;
             if (r < size() && maxHeap[r] > maxHeap[ma])
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i)
                 break;
             swap(maxHeap[i], maxHeap[ma]);
@@ -1194,7 +1194,7 @@ comments: true
                 ma = l
             if r < self.size() and self.max_heap[r] > self.max_heap[ma]:
                 ma = r
-            # 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i:
                 break
             # 交换两节点
@@ -1236,7 +1236,7 @@ comments: true
             if r < h.size() && h.data[r].(int) > h.data[max].(int) {
                 max = r
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if max == i {
                 break
             }
@@ -1274,7 +1274,7 @@ comments: true
             let ma = i;
             if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;
             if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma === i) break;
             // 交换两节点
             this.#swap(i, ma);
@@ -1310,7 +1310,7 @@ comments: true
             let ma = i;
             if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;
             if (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma === i) break;
             // 交换两节点
             this.swap(i, ma);
@@ -1355,7 +1355,7 @@ comments: true
             if (r < size(h) && h->data[r] > h->data[max]) {
                 max = r;
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (max == i) {
                 break;
             }
@@ -1438,7 +1438,7 @@ comments: true
             if r < size(), maxHeap[r] > maxHeap[ma] {
                 ma = r
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i {
                 break
             }
@@ -1477,7 +1477,7 @@ comments: true
             var ma = i;
             if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;
             if (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i) break;
             // 交换两节点
             try self.swap(i, ma);
@@ -1513,7 +1513,7 @@ comments: true
         int ma = i;
         if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;
         if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if (ma == i) break;
         // 交换两节点
         _swap(i, ma);
@@ -1553,7 +1553,7 @@ comments: true
             if r < self.size() && self.max_heap[r] > self.max_heap[ma] {
                 ma = r;
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i {
                 break;
             }

chapter_introduction/algorithms_are_everywhere.md

@@ -8,11 +8,11 @@ comments: true
 
 在正式探讨算法之前，有一个有趣的事实值得分享：**你已经在不知不觉中学会了许多算法，并习惯将它们应用到日常生活中了**。下面，我将举几个具体例子来证实这一点。
 
-**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音的英文字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会这样操作：
+**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会按照下图所示的方式实现。
 
-1. 翻开字典约一半的页数，查看该页首字母是什么，假设首字母为 $m$ 。
-2. 由于在英文字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。
-3. 不断重复步骤 1-2 ，直至找到拼音首字母为 $r$ 的页码为止。
+1. 翻开字典约一半的页数，查看该页的首字母是什么，假设首字母为 $m$ 。
+2. 由于在拼音字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。
+3. 不断重复步骤 `1.` 和 步骤 `2.` ，直至找到拼音首字母为 $r$ 的页码为止。
 
 === "<1>"
     ![查字典步骤](algorithms_are_everywhere.assets/binary_search_dictionary_step_1.png)
@@ -31,9 +31,9 @@ comments: true
 
 <p align="center"> 图：查字典步骤 </p>
 
-查阅字典这个小学生必备技能，实际上就是著名的「二分查找」。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」算法。
+查阅字典这个小学生必备技能，实际上就是著名的二分查找算法。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」。
 
-**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下：
+**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下图所示。
 
 1. 将扑克牌划分为“有序”和“无序”两部分，并假设初始状态下最左 1 张扑克牌已经有序。
 2. 在无序部分抽出一张扑克牌，插入至有序部分的正确位置；完成后最左 2 张扑克已经有序。
@@ -45,9 +45,9 @@ comments: true
 
 上述整理扑克牌的方法本质上是「插入排序」算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。
 
-**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要给我们找 $31$ 元。他会很自然地完成以下思考：
+**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要找我们 $31$ 元。他会很自然地完成如下图所示的思考。
 
-1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ , $5$ , $10$ , $20$ 元。
+1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ 元、$5$ 元、$10$ 元、$20$ 元。
 2. 从可选项中拿出最大的 $20$ 元，剩余 $31 - 20 = 11$ 元。
 3. 从剩余可选项中拿出最大的 $10$ 元，剩余 $11 - 10 = 1$ 元。
 4. 从剩余可选项中拿出最大的 $1$ 元，剩余 $1 - 1 = 0$ 元。
@@ -63,4 +63,4 @@ comments: true
 
 !!! tip
 
-    阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，那么太好了！因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。
+    阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请继续往下阅读，因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。

chapter_introduction/summary.md

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

chapter_introduction/what_is_dsa.md

@@ -6,7 +6,7 @@ comments: true
 
 ## 1.2.1   算法定义
 
-「算法 Algorithm」是在有限时间内解决特定问题的一组指令或操作步骤。它具有以下特性：
+「算法 algorithm」是在有限时间内解决特定问题的一组指令或操作步骤，它具有以下特性：
 
 - 问题是明确的，包含清晰的输入和输出定义。
 - 具有可行性，能够在有限步骤、时间和内存空间下完成。
@@ -14,7 +14,7 @@ comments: true
 
 ## 1.2.2   数据结构定义
 
-「数据结构 Data Structure」是计算机中组织和存储数据的方式。它的设计目标包括：
+「数据结构 data structure」是计算机中组织和存储数据的方式，它的设计目标如下：
 
 - 空间占用尽量减少，节省计算机内存。
 - 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
@@ -27,28 +27,29 @@ comments: true
 
 ## 1.2.3   数据结构与算法的关系
 
-数据结构与算法高度相关、紧密结合，具体表现在：
+数据结构与算法高度相关、紧密结合，具体表现在以下几个方面。
 
 - 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。
-- 算法是数据结构发挥的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。
-- 特定算法通常有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。
+- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。
+- 特定算法通常会有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。
 
 ![数据结构与算法的关系](what_is_dsa.assets/relationship_between_data_structure_and_algorithm.png)
 
 <p align="center"> 图：数据结构与算法的关系 </p>
 
-数据结构与算法犹如拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
+数据结构与算法犹如上图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
 
 ![拼装积木](what_is_dsa.assets/assembling_blocks.jpg)
 
 <p align="center"> 图：拼装积木 </p>
 
 两者的详细对应关系如下表所示。
+
 <p align="center"> 表：将数据结构与算法类比为积木 </p>
 
 <div class="center-table" markdown>
 
-| 数据结构与算法 | 积木                                |
+| 数据结构与算法 | 拼装积木                                |
 | -------------- | ---------------------------------------- |
 | 输入数据       | 未拼装的积木                             |
 | 数据结构       | 积木组织形式，包括形状、大小、连接方式等 |

chapter_searching/binary_search.md

@@ -104,7 +104,7 @@ comments: true
         i, j = 0, len(nums) - 1
         # 循环，当搜索区间为空时跳出（当 i > j 时为空）
         while i <= j:
-            # 理论上 Python 的数字可以无限大（取决于内存大小），无需考虑大数越界问题
+            # 理论上 Python 的数字可以无限大（取决于内存大小），无须考虑大数越界问题
             m = (i + j) // 2  # 计算中点索引 m
             if nums[m] < target:
                 i = m + 1  # 此情况说明 target 在区间 [m+1, j] 中
@@ -636,7 +636,7 @@ comments: true
 二分查找在时间和空间方面都有较好的性能：
 
 - 二分查找的时间效率高。在大数据量下，对数阶的时间复杂度具有显著优势。例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需 $\log_2 2^{20} = 20$ 轮循环。
-- 二分查找无需额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。
+- 二分查找无须额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。
 
 然而，二分查找并非适用于所有情况，原因如下：
 

chapter_searching/binary_search_edge.md

@@ -325,5 +325,5 @@ status: new
 
 代码在此省略，值得注意的有：
 
-- 给定数组不包含小数，这意味着我们无需关心如何处理相等的情况。
+- 给定数组不包含小数，这意味着我们无须关心如何处理相等的情况。
 - 因为该方法引入了小数，所以需要将函数中的变量 `target` 改为浮点数类型。

chapter_searching/searching_algorithm_revisited.md

@@ -20,7 +20,7 @@ comments: true
 - 「线性搜索」适用于数组和链表等线性数据结构。它从数据结构的一端开始，逐个访问元素，直到找到目标元素或到达另一端仍没有找到目标元素为止。
 - 「广度优先搜索」和「深度优先搜索」是图和树的两种遍历策略。广度优先搜索从初始节点开始逐层搜索，由近及远地访问各个节点。深度优先搜索是从初始节点开始，沿着一条路径走到头为止，再回溯并尝试其他路径，直到遍历完整个数据结构。
 
-暴力搜索的优点是简单且通用性好，**无需对数据做预处理和借助额外的数据结构**。
+暴力搜索的优点是简单且通用性好，**无须对数据做预处理和借助额外的数据结构**。
 
 然而，**此类算法的时间复杂度为 $O(n)$** ，其中 $n$ 为元素数量，因此在数据量较大的情况下性能较差。
 
@@ -68,7 +68,7 @@ comments: true
 
 **线性搜索**
 
-- 通用性较好，无需任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
+- 通用性较好，无须任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
 - 适用于体量较小的数据，此情况下时间复杂度对效率影响较小。
 - 适用于数据更新频率较高的场景，因为该方法不需要对数据进行任何额外维护。
 

chapter_searching/summary.md

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

chapter_sorting/bubble_sort.md

@@ -38,7 +38,7 @@ comments: true
 1. 首先，对 $n$ 个元素执行“冒泡”，**将数组的最大元素交换至正确位置**，
 2. 接下来，对剩余 $n - 1$ 个元素执行“冒泡”，**将第二大元素交换至正确位置**。
 3. 以此类推，经过 $n - 1$ 轮“冒泡”后，**前 $n - 1$ 大的元素都被交换至正确位置**。
-4. 仅剩的一个元素必定是最小元素，无需排序，因此数组排序完成。
+4. 仅剩的一个元素必定是最小元素，无须排序，因此数组排序完成。
 
 ![冒泡排序流程](bubble_sort.assets/bubble_sort_overview.png)
 

chapter_sorting/heap_sort.md

@@ -80,7 +80,7 @@ comments: true
                 ma = l;
             if (r < n && nums[r] > nums[ma])
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i)
                 break;
             // 交换两节点
@@ -124,7 +124,7 @@ comments: true
                 ma = l;
             if (r < n && nums[r] > nums[ma])
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i) {
                 break;
             }
@@ -165,7 +165,7 @@ comments: true
                 ma = l
             if r < n and nums[r] > nums[ma]:
                 ma = r
-            # 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i:
                 break
             # 交换两节点
@@ -202,7 +202,7 @@ comments: true
             if r < n && (*nums)[r] > (*nums)[ma] {
                 ma = r
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i {
                 break
             }
@@ -245,7 +245,7 @@ comments: true
             if (r < n && nums[r] > nums[ma]) {
                 ma = r;
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma === i) {
                 break;
             }
@@ -288,7 +288,7 @@ comments: true
             if (r < n && nums[r] > nums[ma]) {
                 ma = r;
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma === i) {
                 break;
             }
@@ -329,7 +329,7 @@ comments: true
                 ma = l;
             if (r < n && nums[r] > nums[ma])
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i) {
                 break;
             }
@@ -374,7 +374,7 @@ comments: true
                 ma = l;
             if (r < n && nums[r] > nums[ma])
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i)
                 break;
             // 交换两节点
@@ -417,7 +417,7 @@ comments: true
             if r < n, nums[r] > nums[ma] {
                 ma = r
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i {
                 break
             }
@@ -464,7 +464,7 @@ comments: true
         int ma = i;
         if (l < n && nums[l] > nums[ma]) ma = l;
         if (r < n && nums[r] > nums[ma]) ma = r;
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if (ma == i) break;
         // 交换两节点
         int temp = nums[i];
@@ -509,7 +509,7 @@ comments: true
             if r < n && nums[r] > nums[ma] {
                 ma = r;
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i {
                 break;
             }

chapter_sorting/insertion_sort.md

@@ -258,7 +258,7 @@ comments: true
 
 插入排序的时间复杂度为 $O(n^2)$ ，而我们即将学习的快速排序的时间复杂度为 $O(n \log n)$ 。尽管插入排序的时间复杂度相比快速排序更高，**但在数据量较小的情况下，插入排序通常更快**。
 
-这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元计算操作数量起到决定性因素。
+这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元操作数量起到决定性因素。
 
 实际上，许多编程语言（例如 Java）的内置排序函数都采用了插入排序，大致思路为：对于长数组，采用基于分治的排序算法，例如快速排序；对于短数组，直接使用插入排序。
 

chapter_sorting/merge_sort.md

@@ -635,7 +635,7 @@ comments: true
 
 归并排序在排序链表时具有显著优势，空间复杂度可以优化至 $O(1)$ ，原因如下：
 
-- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无需创建辅助链表。
+- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无须创建辅助链表。
 - 通过使用“迭代划分”替代“递归划分”，可省去递归使用的栈帧空间。
 
 具体实现细节比较复杂，有兴趣的同学可以查阅相关资料进行学习。

chapter_sorting/selection_sort.md

@@ -12,7 +12,7 @@ comments: true
 2. 选取区间 $[0, n-1]$ 中的最小元素，将其与索引 $0$ 处元素交换。完成后，数组前 1 个元素已排序。
 3. 选取区间 $[1, n-1]$ 中的最小元素，将其与索引 $1$ 处元素交换。完成后，数组前 2 个元素已排序。
 4. 以此类推。经过 $n - 1$ 轮选择与交换后，数组前 $n - 1$ 个元素已排序。
-5. 仅剩的一个元素必定是最大元素，无需排序，因此数组排序完成。
+5. 仅剩的一个元素必定是最大元素，无须排序，因此数组排序完成。
 
 === "<1>"
     ![选择排序步骤](selection_sort.assets/selection_sort_step1.png)

chapter_sorting/sorting_algorithm.md

@@ -16,7 +16,7 @@ comments: true
 
 **运行效率**：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。
 
-**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无需借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
+**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无须借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
 
 **稳定性**：「稳定排序」在完成排序后，相等元素在数组中的相对顺序不发生改变。稳定排序是优良特性，也是多级排序场景的必要条件。
 

chapter_stack_and_queue/stack.md

@@ -1082,7 +1082,7 @@ comments: true
 
 <p align="center"> 图：基于数组实现栈的入栈出栈操作 </p>
 
-由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无需自行处理数组扩容问题。以下为示例代码。
+由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无须自行处理数组扩容问题。以下为示例代码。
 
 === "Java"
 

chapter_tree/avl_tree.md

@@ -1139,7 +1139,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
     ```
@@ -1173,7 +1173,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
     ```
@@ -1203,7 +1203,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 # 先右旋后左旋
                 node.right = self.__right_rotate(node.right)
                 return self.__left_rotate(node)
-        # 平衡树，无需旋转，直接返回
+        # 平衡树，无须旋转，直接返回
         return node
     ```
 
@@ -1237,7 +1237,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return t.leftRotate(node)
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node
     }
     ```
@@ -1271,7 +1271,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return this.#leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
     ```
@@ -1305,7 +1305,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return this.leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
     ```
@@ -1339,7 +1339,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
     ```
@@ -1373,7 +1373,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
     ```
@@ -1407,7 +1407,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return leftRotate(node: node)
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node
     }
     ```
@@ -1441,7 +1441,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 return self.leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
     ```
@@ -1475,7 +1475,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
           return leftRotate(node);
         }
       }
-      // 平衡树，无需旋转，直接返回
+      // 平衡树，无须旋转，直接返回
       return node;
     }
     ```
@@ -1513,7 +1513,7 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
                 Self::left_rotate(Some(node))
             }
         } else {
-            // 平衡树，无需旋转，直接返回
+            // 平衡树，无须旋转，直接返回
             node
         }
     }

chapter_tree/binary_search_tree.md

@@ -1478,7 +1478,7 @@ comments: true
 
 我们知道，二叉树的中序遍历遵循“左 $\rightarrow$ 根 $\rightarrow$ 右”的遍历顺序，而二叉搜索树满足“左子节点 $<$ 根节点 $<$ 右子节点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：**二叉搜索树的中序遍历序列是升序的**。
 
-利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无需额外排序，非常高效。
+利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无须额外排序，非常高效。
 
 ![二叉搜索树的中序遍历序列](binary_search_tree.assets/bst_inorder_traversal.png)