build

chapter_array_and_linkedlist/array.md

@@ -109,7 +109,9 @@ comments: true
 === "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];
     ```
 
 ## 4.1.1. &nbsp; 数组优点

chapter_array_and_linkedlist/linked_list.md

@@ -172,7 +172,14 @@ comments: true
 === "Rust"
 
     ```rust title=""
-
+    use std::rc::Rc;
+    use std::cell::RefCell;
+    /* 链表节点类 */
+    #[derive(Debug)]
+    struct ListNode {
+        val: i32, // 节点值
+        next: Option<Rc<RefCell<ListNode>>>, // 指向下一节点的指针（引用）
+    }
     ```
 
 我们将链表的首个节点称为「头节点」，最后一个节点称为「尾节点」。尾节点指向的是“空”，在 Java, C++, Python 中分别记为 $\text{null}$ , $\text{nullptr}$ , $\text{None}$ 。在不引起歧义的前提下，本书都使用 $\text{None}$ 来表示空。
@@ -369,7 +376,19 @@ comments: true
 === "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());
     ```
 
 在编程语言中，数组整体是一个变量，比如数组 `nums` 包含元素 `nums[0]` , `nums[1]` 等。而链表是由多个分散的节点对象组成，**我们通常将头节点当作链表的代称**，比如以上代码中的链表可被记做链表 `n0` 。
@@ -1249,7 +1268,27 @@ comments: true
 === "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,
+            }
+        }
+    }
     ```
 
 ![常见链表种类](linked_list.assets/linkedlist_common_types.png)

chapter_array_and_linkedlist/list.md

@@ -123,7 +123,11 @@ comments: true
 === "Rust"
 
     ```rust title="list.rs"
-
+    /* 初始化列表 */
+    // 无初始值
+    let list1: Vec<i32> = Vec::new();
+    // 有初始值
+    let list2: Vec<i32> = vec![1, 3, 2, 5, 4];
     ```
 
 **访问与更新元素**。由于列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问和更新元素，效率很高。
@@ -237,7 +241,10 @@ comments: true
 === "Rust"
 
     ```rust title="list.rs"
-
+    /* 访问元素 */
+    let num: i32 = list[1];    // 访问索引 1 处的元素
+    /* 更新元素 */
+    list[1] = 0;               // 将索引 1 处的元素更新为 0
     ```
 
 **在列表中添加、插入、删除元素**。相较于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但插入和删除元素的效率仍与数组相同，时间复杂度为 $O(N)$ 。
@@ -451,7 +458,21 @@ comments: true
 === "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 处的元素
     ```
 
 **遍历列表**。与数组一样，列表可以根据索引遍历，也可以直接遍历各元素。
@@ -624,7 +645,17 @@ comments: true
 === "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;
+    }
     ```
 
 **拼接两个列表**。给定一个新列表 `list1` ，我们可以将该列表拼接到原列表的尾部。
@@ -721,7 +752,9 @@ comments: true
 === "Rust"
 
     ```rust title="list.rs"
-
+    /* 拼接两个列表 */
+    let list1: Vec<i32> = vec![6, 8, 7, 10, 9];
+    list.extend(list1);
     ```
 
 **排序列表**。排序也是常用的方法之一。完成列表排序后，我们便可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法。
@@ -805,7 +838,8 @@ comments: true
 === "Rust"
 
     ```rust title="list.rs"
-
+    /* 排序列表 */
+    list.sort(); // 排序后，列表元素从小到大排列
     ```
 
 ## 4.3.2. &nbsp; 列表实现 *

chapter_computational_complexity/performance_evaluation.md

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

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,12 +294,14 @@ comments: true
 
 ## 2.3.2.   推算方法
 
-空间复杂度的推算方法与时间复杂度大致相同，只是将统计对象从“计算操作数量”转为“使用空间大小”。与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**，这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
+空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“计算操作数量”转为“使用空间大小”。
 
-**最差空间复杂度中的“最差”有两层含义**，分别是输入数据的最差分布和算法运行过程中的最差时间点。
+而与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
 
-- **以最差输入数据为准**。当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但当 $n > 10$ 时，初始化的数组 `nums` 占用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ 。
+观察以下代码，最差空间复杂度中的“最差”有两层含义。
-- **以算法运行过程中的峰值内存为准**。例如，程序在执行最后一行之前，占用 $O(1)$ 空间；当初始化数组 `nums` 时，程序占用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ 。
+
+1. **以最差输入数据为准**：当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但当 $n > 10$ 时，初始化的数组 `nums` 占用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ 。
+2. **以算法运行中的峰值内存为准**：例如，程序在执行最后一行之前，占用 $O(1)$ 空间；当初始化数组 `nums` 时，程序占用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ 。
 
 === "Java"
 
@@ -430,7 +432,10 @@ comments: true
 
     ```
 
-**在递归函数中，需要注意统计栈帧空间**。例如，函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
+**在递归函数中，需要注意统计栈帧空间**。例如以下代码：
+
+- 函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。
+- 递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
 
 === "Java"
 
@@ -653,7 +658,7 @@ comments: true
 
 ## 2.3.3. &nbsp; 常见类型
 
-设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
+设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）：
 
 $$
 \begin{aligned}
@@ -668,7 +673,7 @@ $$
 
 !!! tip
 
-    部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果遇到看不懂的地方无需担心，可以在学习完后面章节后再来复习，现阶段我们先专注于理解空间复杂度的含义和推算方法。
+    部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学习完后面章节后再来复习。
 
 ### 常数阶 $O(1)$
 
@@ -679,6 +684,12 @@ $$
 === "Java"
 
     ```java title="space_complexity.java"
+    /* 函数 */
+    int function() {
+        // do something
+        return 0;
+    }
+
     /* 常数阶 */
     void constant(int n) {
         // 常量、变量、对象占用 O(1) 空间
@@ -700,6 +711,12 @@ $$
 === "C++"
 
     ```cpp title="space_complexity.cpp"
+    /* 函数 */
+    int func() {
+        // do something
+        return 0;
+    }
+
     /* 常数阶 */
     void constant(int n) {
         // 常量、变量、对象占用 O(1) 空间
@@ -721,6 +738,11 @@ $$
 === "Python"
 
     ```python title="space_complexity.py"
+    def function() -> int:
+        """函数"""
+        # do something
+        return 0
+
     def constant(n: int):
         """常数阶"""
         # 常量、变量、对象占用 O(1) 空间
@@ -738,6 +760,12 @@ $$
 === "Go"
 
     ```go title="space_complexity.go"
+    /* 函数 */
+    func function() int {
+        // do something...
+        return 0
+    }
+
     /* 常数阶 */
     func spaceConstant(n int) {
         // 常量、变量、对象占用 O(1) 空间
@@ -761,6 +789,12 @@ $$
 === "JS"
 
     ```javascript title="space_complexity.js"
+    /* 函数 */
+    function constFunc() {
+        // do something
+        return 0;
+    }
+
     /* 常数阶 */
     function constant(n) {
         // 常量、变量、对象占用 O(1) 空间
@@ -782,6 +816,12 @@ $$
 === "TS"
 
     ```typescript title="space_complexity.ts"
+    /* 函数 */
+    function constFunc(): number {
+        // do something
+        return 0;
+    }
+
     /* 常数阶 */
     function constant(n: number): void {
         // 常量、变量、对象占用 O(1) 空间
@@ -803,6 +843,12 @@ $$
 === "C"
 
     ```c title="space_complexity.c"
+    /* 函数 */
+    int func() {
+        // do something
+        return 0;
+    }
+
     /* 常数阶 */
     void constant(int n) {
         // 常量、变量、对象占用 O(1) 空间
@@ -825,6 +871,12 @@ $$
 === "C#"
 
     ```csharp title="space_complexity.cs"
+    /* 函数 */
+    int function() {
+        // do something
+        return 0;
+    }
+
     /* 常数阶 */
     void constant(int n) {
         // 常量、变量、对象占用 O(1) 空间
@@ -846,6 +898,13 @@ $$
 === "Swift"
 
     ```swift title="space_complexity.swift"
+    /* 函数 */
+    @discardableResult
+    func function() -> Int {
+        // do something
+        return 0
+    }
+
     /* 常数阶 */
     func constant(n: Int) {
         // 常量、变量、对象占用 O(1) 空间
@@ -867,6 +926,8 @@ $$
 === "Zig"
 
     ```zig title="space_complexity.zig"
+    [class]{}-[func]{function}
+
     // 常数阶
     fn constant(n: i32) void {
         // 常量、变量、对象占用 O(1) 空间
@@ -895,6 +956,12 @@ $$
 === "Dart"
 
     ```dart title="space_complexity.dart"
+    /* 函数 */
+    int function() {
+      // do something
+      return 0;
+    }
+
     /* 常数阶 */
     void constant(int n) {
       // 常量、变量、对象占用 O(1) 空间
@@ -916,6 +983,12 @@ $$
 === "Rust"
 
     ```rust title="space_complexity.rs"
+    /* 函数 */
+    fn function() ->i32 {
+        // do something
+        return 0;
+    }
+
     /* 常数阶 */
     #[allow(unused)]
     fn constant(n: i32) {
@@ -987,9 +1060,9 @@ $$
         # 长度为 n 的列表占用 O(n) 空间
         nums = [0] * n
         # 长度为 n 的哈希表占用 O(n) 空间
-        mapp = dict[int, str]()
+        hmap = dict[int, str]()
         for i in range(n):
-            mapp[i] = str(i)
+            hmap[i] = str(i)
     ```
 
 === "Go"

chapter_computational_complexity/summary.md

@@ -44,6 +44,8 @@ comments: true
 
 !!! question "图片“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？"
 
-    不是，该图片展示的是空间复杂度（即增长趋势），而不是占用空间的绝对大小。每个曲线都包含一个常数项，用来把所有曲线的取值范围压缩到一个视觉舒适的范围内。
+    不是，该图片展示的是空间复杂度，其反映的是即增长趋势，而不是占用空间的绝对大小。
     
-    实际中，因为我们通常不知道每个方法的“常数项”复杂度是多少，所以一般无法仅凭复杂度来选择 $n = 8$ 之下的最优解法；但相对地 $n = 8^5$ 就很好选了，这是复杂度占主导的情况。
+    假设取 $n = 8$ ，你可能会发现每条曲线的值与函数对应不上。这是因为每条曲线都包含一个常数项，用于将取值范围压缩到一个视觉舒适的范围内。
+
+    在实际中，因为我们通常不知道每个方法的“常数项”复杂度是多少，所以一般无法仅凭复杂度来选择 $n = 8$ 之下的最优解法。但对于 $n = 8^5$ 就很好选了，这时增长趋势已经占主导了。

chapter_computational_complexity/time_complexity.md

@@ -4,15 +4,13 @@ comments: true
 
 # 2.2.   时间复杂度
 
-## 2.2.1.   统计算法运行时间
+运行时间可以直观且准确地反映算法的效率。如果我们想要准确预估一段代码的运行时间，应该如何操作呢？
-
-运行时间可以直观且准确地反映算法的效率。然而，如果我们想要准确预估一段代码的运行时间，应该如何操作呢？
 
 1. **确定运行平台**，包括硬件配置、编程语言、系统环境等，这些因素都会影响代码的运行效率。
 2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作需要 5 ns 等。
 3. **统计代码中所有的计算操作**，并将所有操作的执行时间求和，从而得到运行时间。
 
-例如以下代码，输入数据大小为 $n$ ，根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。
+例如以下代码，输入数据大小为 $n$ 。根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。
 
 $$
 1 + 1 + 10 + (1 + 5) \times n = 6n + 12
@@ -175,20 +173,25 @@ $$
 === "Rust"
 
     ```rust title=""
-
+    // 在某运行平台下
+    fn algorithm(n: i32) {
+        let mut a = 2;      // 1 ns
+        a = a + 1;          // 1 ns
+        a = a * 2;          // 10 ns
+        // 循环 n 次
+        for _ in 0..n {     // 1 ns ，每轮都要执行 i++
+            println!("{}", 0);  // 5 ns
+        }
+    }
     ```
 
-然而实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
+但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
 
-## 2.2.2.   统计时间增长趋势
+## 2.2.1.   统计时间增长趋势
 
 「时间复杂度分析」采取了一种不同的方法，其统计的不是算法运行时间，**而是算法运行时间随着数据量变大时的增长趋势**。
 
-“时间增长趋势”这个概念较为抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法 `A` , `B` , `C` 。
+“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` , `B` , `C` 。
-
-- 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
-- 算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大呈线性增长。此算法的时间复杂度被称为「线性阶」。
-- 算法 `C` 中的打印操作需要循环 $1000000$ 次，但运行时间仍与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
 
 === "Java"
 
@@ -407,28 +410,45 @@ $$
 === "Rust"
 
     ```rust title=""
-
+    // 算法 A 时间复杂度：常数阶
+    fn algorithm_A(n: i32) {
+        println!("{}", 0);
+    }
+    // 算法 B 时间复杂度：线性阶
+    fn algorithm_B(n: i32) {
+        for _ in 0..n {
+            println!("{}", 0);
+        }
+    }
+    // 算法 C 时间复杂度：常数阶
+    fn algorithm_C(n: i32) {
+        for _ in 0..1000000 {
+            println!("{}", 0);
+        }
+    }
     ```
 
+算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
+
+算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大呈线性增长。此算法的时间复杂度被称为「线性阶」。
+
+算法 `C` 中的打印操作需要循环 $1000000$ 次，虽然运行时间很长，但它与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
+
 ![算法 A, B, C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
 
 <p align="center"> Fig. 算法 A, B, C 的时间增长趋势 </p>
 
-相较于直接统计算法运行时间，时间复杂度分析有哪些优势和局限性呢？
+相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？
 
-**时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 慢，在 $n > 1000000$ 时比算法 `C` 慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这正是时间增长趋势所表达的含义。
+**时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。
 
-**时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样的简化方法大大降低了估算难度。
+**时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。
 
 **时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
 
-## 2.2.3. &nbsp; 函数渐近上界
+## 2.2.2. &nbsp; 函数渐近上界
 
-设算法的计算操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以下算法的操作数量为
+给定一个函数 `algorithm()` ：
-
-$$
-T(n) = 3 + 2n
-$$
 
 === "Java"
 
@@ -577,14 +597,29 @@ $$
 === "Rust"
 
     ```rust title=""
+    fn algorithm(n: i32) {
+        let mut a = 1;   // +1
+        a = a + 1;      // +1
+        a = a * 2;      // +1
 
+        // 循环 n 次
+        for _ in 0..n { // +1（每轮都执行 i ++）
+            println!("{}", 0); // +1
+        }
+    }
     ```
 
-$T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得出时间复杂度是线性阶。
+设算法的计算操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
+
+$$
+T(n) = 3 + 2n
+$$
+
+$T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时间复杂度是线性阶。
 
 我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 Big-$O$ Notation」，表示函数 $T(n)$ 的「渐近上界 Asymptotic Upper Bound」。
 
-推算时间复杂度本质上是计算“操作数量函数 $T(n)$”的渐近上界。接下来，我们来看函数渐近上界的数学定义。
+时间复杂度分析本质上是计算“操作数量函数 $T(n)$”的渐近上界。接下来，我们来看函数渐近上界的数学定义。
 
 !!! abstract "函数渐近上界"
 
@@ -601,9 +636,9 @@ $T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得
 
 <p align="center"> Fig. 函数的渐近上界 </p>
 
-从本质上讲，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
+也就是说，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
 
-## 2.2.4. &nbsp; 推算方法
+## 2.2.3. &nbsp; 推算方法
 
 渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无需担心。因为在实际使用中，我们只需要掌握推算方法，数学意义可以逐渐领悟。
 
@@ -613,11 +648,11 @@ $T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得
 
 针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧：
 
-1. **忽略与 $n$ 无关的操作**。因为它们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。
+1. **忽略 $T(n)$ 中的常数项**。因为它们都与 $n$ 无关，所以对时间复杂度不产生影响。
 2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次等，都可以简化记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度没有影响。
 3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
 
-以下示例展示了使用上述技巧前、后的统计结果。
+以下示例展示了使用上述技巧前、后的统计结果。两者推出的时间复杂度相同，即为 $O(n^2)$ 。
 
 $$
 \begin{aligned}
@@ -627,8 +662,6 @@ T(n) & = n^2 + n & \text{偷懒统计 (o.O)}
 \end{aligned}
 $$
 
-最终，两者都能推出相同的时间复杂度结果，即 $O(n^2)$ 。
-
 === "Java"
 
     ```java title=""
@@ -824,7 +857,22 @@ $$
 === "Rust"
 
     ```rust title=""
+    fn algorithm(n: i32) {
+        let mut a = 1;     // +0（技巧 1）
+        a = a + n;        // +0（技巧 1）
 
+        // +n（技巧 2）
+        for i in 0..(5 * n + 1) {
+            println!("{}", 0);
+        }
+
+        // +n*n（技巧 3）
+        for i in 0..(2 * n) {
+            for j in 0..(n + 1) {
+                println!("{}", 0);
+            }
+        }
+    }
     ```
 
 ### 第二步：判断渐近上界
@@ -845,7 +893,7 @@ $$
 
 </div>
 
-## 2.2.5. &nbsp; 常见类型
+## 2.2.4. &nbsp; 常见类型
 
 设输入数据大小为 $n$ ，常见的时间复杂度类型包括（按照从低到高的顺序排列）：
 
@@ -862,7 +910,7 @@ $$
 
 !!! tip
 
-    部分示例代码需要一些预备知识，包括数组、递归算法等。如果遇到不理解的部分，请不要担心，可以在学习完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
+    部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学习完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
 
 ### 常数阶 $O(1)$
 
@@ -1187,10 +1235,6 @@ $$
 
 遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
 
-!!! question "如何确定输入数据大小 $n$ ？"
-
-    **数据大小 $n$ 需根据输入数据的类型来具体确定**。例如，在上述示例中，我们直接将 $n$ 视为输入数据大小；在下面遍历数组的示例中，数据大小 $n$ 为数组的长度。
-
 === "Java"
 
     ```java title="time_complexity.java"
@@ -1357,6 +1401,8 @@ $$
     }
     ```
 
+值得注意的是，**数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。
+
 ### 平方阶 $O(n^2)$
 
 平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ 。
@@ -1836,11 +1882,9 @@ $$
 
 ### 指数阶 $O(2^n)$
 
-!!! note
-
 生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。
 
-指数阶增长非常迅速，在实际应用中通常是不可接受的。若一个问题使用「暴力枚举」求解的时间复杂度为 $O(2^n)$ ，那么通常需要使用「动态规划」或「贪心算法」等方法来解决。
+以下代码模拟了细胞分裂的过程。
 
 === "Java"
 
@@ -1848,7 +1892,7 @@ $$
     /* 指数阶（循环实现） */
     int exponential(int n) {
         int count = 0, base = 1;
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for (int i = 0; i < n; i++) {
             for (int j = 0; j < base; j++) {
                 count++;
@@ -1866,7 +1910,7 @@ $$
     /* 指数阶（循环实现） */
     int exponential(int n) {
         int count = 0, base = 1;
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for (int i = 0; i < n; i++) {
             for (int j = 0; j < base; j++) {
                 count++;
@@ -1885,7 +1929,7 @@ $$
         """指数阶（循环实现）"""
         count = 0
         base = 1
-        # cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        # 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for _ in range(n):
             for _ in range(base):
                 count += 1
@@ -1900,7 +1944,7 @@ $$
     /* 指数阶（循环实现）*/
     func exponential(n int) int {
         count, base := 0, 1
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for i := 0; i < n; i++ {
             for j := 0; j < base; j++ {
                 count++
@@ -1919,7 +1963,7 @@ $$
     function exponential(n) {
         let count = 0,
             base = 1;
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for (let i = 0; i < n; i++) {
             for (let j = 0; j < base; j++) {
                 count++;
@@ -1938,7 +1982,7 @@ $$
     function exponential(n: number): number {
         let count = 0,
             base = 1;
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for (let i = 0; i < n; i++) {
             for (let j = 0; j < base; j++) {
                 count++;
@@ -1957,7 +2001,7 @@ $$
     int exponential(int n) {
         int count = 0;
         int bas = 1;
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for (int i = 0; i < n; i++) {
             for (int j = 0; j < bas; j++) {
                 count++;
@@ -1975,7 +2019,7 @@ $$
     /* 指数阶（循环实现） */
     int exponential(int n) {
         int count = 0, bas = 1;
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for (int i = 0; i < n; i++) {
             for (int j = 0; j < bas; j++) {
                 count++;
@@ -1994,7 +2038,7 @@ $$
     func exponential(n: Int) -> Int {
         var count = 0
         var base = 1
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for _ in 0 ..< n {
             for _ in 0 ..< base {
                 count += 1
@@ -2014,7 +2058,7 @@ $$
         var count: i32 = 0;
         var bas: i32 = 1;
         var i: i32 = 0;
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         while (i < n) : (i += 1) {
             var j: i32 = 0;
             while (j < bas) : (j += 1) {
@@ -2033,7 +2077,7 @@ $$
     /* 指数阶（循环实现） */
     int exponential(int n) {
       int count = 0, base = 1;
-      // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+      // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
       for (var i = 0; i < n; i++) {
         for (var j = 0; j < base; j++) {
           count++;
@@ -2052,7 +2096,7 @@ $$
     fn exponential(n: i32) -> i32 {
         let mut count = 0;
         let mut base = 1;
-        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
         for _ in 0..n {
             for _ in 0..base {
                 count += 1
@@ -2068,7 +2112,7 @@ $$
 
 <p align="center"> Fig. 指数阶的时间复杂度 </p>
 
-在实际算法中，指数阶常出现于递归函数。例如以下代码，不断地一分为二，经过 $n$ 次分裂后停止。
+在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止。
 
 === "Java"
 
@@ -2199,13 +2243,11 @@ $$
     }
     ```
 
+指数阶增长非常迅速，在穷举法（暴力搜索、回溯等）中比较常见。对于数据规模较大的问题，指数阶是不可接受的，通常需要使用「动态规划」或「贪心」等算法来解决。
+
 ### 对数阶 $O(\log n)$
 
-与指数阶相反，对数阶反映了“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长缓慢，是理想的时间复杂度。
+与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
-
-对数阶常出现于「二分查找」和「分治算法」中，体现了“一分为多”和“化繁为简”的算法思想。
-
-设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
 
 === "Java"
 
@@ -2511,6 +2553,8 @@ $$
     }
     ```
 
+对数阶常出现于基于「分治」的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。
+
 ### 线性对数阶 $O(n \log n)$
 
 线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
@@ -2705,7 +2749,7 @@ $$
 
 ### 阶乘阶 $O(n!)$
 
-阶乘阶对应数学上的「全排列」问题。给定 $n$ 个互不重复的元素，求其所有可能的排列方案，方案数量为：
+阶乘阶对应数学上的“全排列”问题。给定 $n$ 个互不重复的元素，求其所有可能的排列方案，方案数量为：
 
 $$
 n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1
@@ -2905,14 +2949,16 @@ $$
 
 <p align="center"> Fig. 阶乘阶的时间复杂度 </p>
 
-## 2.2.6. &nbsp; 最差、最佳、平均时间复杂度
+请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长地更快，在 $n$ 较大时也是不可接受的。
 
-**某些算法的时间复杂度不是固定的，而是与输入数据的分布有关**。例如，假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
+## 2.2.5. &nbsp; 最差、最佳、平均时间复杂度
 
-- 当 `nums = [?, ?, ..., 1]` ，即当末尾元素是 $1$ 时，需要完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** 。
+**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论：
-- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** 。
 
-“函数渐近上界”使用大 $O$ 记号表示，代表「最差时间复杂度」。相应地，“函数渐近下界”用 $\Omega$ 记号来表示，代表「最佳时间复杂度」。
+- 当 `nums = [?, ?, ..., 1]` ，即当末尾元素是 $1$ 时，需要完整遍历数组，**达到最差时间复杂度 $O(n)$** 。
+- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。
+
+「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示。
 
 === "Java"
 
@@ -3264,15 +3310,13 @@ $$
     }
     ```
 
-!!! tip
+值得说明的是，我们在实际中很少使用「最佳时间复杂度」，因为通常只有在很小概率下才能达到，可能会带来一定的误导性。**而「最差时间复杂度」更为实用，因为它给出了一个效率安全值**，让我们可以放心地使用算法。
 
-    实际应用中我们很少使用「最佳时间复杂度」，因为通常只有在很小概率下才能达到，可能会带来一定的误导性。相反，「最差时间复杂度」更为实用，因为它给出了一个“效率安全值”，让我们可以放心地使用算法。
+从上述示例可以看出，最差或最佳时间复杂度只出现于“特殊的数据分布”，这些情况的出现概率可能很小，并不能真实地反映算法运行效率。相比之下，**「平均时间复杂度」可以体现算法在随机输入数据下的运行效率**，用 $\Theta$ 记号来表示。
-
-从上述示例可以看出，最差或最佳时间复杂度只出现在“特殊分布的数据”中，这些情况的出现概率可能很小，因此并不能最真实地反映算法运行效率。相较之下，**「平均时间复杂度」可以体现算法在随机输入数据下的运行效率**，用 $\Theta$ 记号来表示。
 
 对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数则是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
 
-但在实际应用中，尤其是较为复杂的算法，计算平均时间复杂度比较困难，因为很难简便地分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。
+但对于较为复杂的算法，计算平均时间复杂度往往是比较困难的，因为很难分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。
 
 !!! question "为什么很少看到 $\Theta$ 符号？"
 

chapter_hashing/hash_map.md

@@ -4,7 +4,7 @@ comments: true
 
 # 6.1.   哈希表
 
-「哈希表 Hash Table」通过建立键 `key` 与值 `value` 之间的映射，实现高效的元素查询。具体而言，我们向哈希表输入一个 `key` ，则可以在 $O(1)$ 时间内获取对应的 `value` 。
+散列表，又称「哈希表 Hash Table」，其通过建立键 `key` 与值 `value` 之间的映射，实现高效的元素查询。具体而言，我们向哈希表输入一个键 `key` ，则可以在 $O(1)$ 时间内获取对应的值 `value` 。
 
 以一个包含 $n$ 个学生的数据库为例，每个学生都有“姓名”和“学号”两项数据。假如我们希望实现“输入一个学号，返回对应的姓名”的查询功能，则可以采用哈希表来实现。
 
@@ -84,46 +84,46 @@ comments: true
 
     ```python title="hash_map.py"
     # 初始化哈希表
-    mapp: Dict = {}
+    hmap: Dict = {}
     
     # 添加操作
     # 在哈希表中添加键值对 (key, value)
-    mapp[12836] = "小哈"
+    hmap[12836] = "小哈"
-    mapp[15937] = "小啰"
+    hmap[15937] = "小啰"
-    mapp[16750] = "小算"
+    hmap[16750] = "小算"
-    mapp[13276] = "小法"
+    hmap[13276] = "小法"
-    mapp[10583] = "小鸭"
+    hmap[10583] = "小鸭"
     
     # 查询操作
     # 向哈希表输入键 key ，得到值 value
-    name: str = mapp[15937]
+    name: str = hmap[15937]
     
     # 删除操作
     # 在哈希表中删除键值对 (key, value)
-    mapp.pop(10583)
+    hmap.pop(10583)
     ```
 
 === "Go"
 
     ```go title="hash_map.go"
     /* 初始化哈希表 */
-    mapp := make(map[int]string)
+    hmap := make(map[int]string)
     
     /* 添加操作 */
     // 在哈希表中添加键值对 (key, value)
-    mapp[12836] = "小哈"
+    hmap[12836] = "小哈"
-    mapp[15937] = "小啰"
+    hmap[15937] = "小啰"
-    mapp[16750] = "小算"
+    hmap[16750] = "小算"
-    mapp[13276] = "小法"
+    hmap[13276] = "小法"
-    mapp[10583] = "小鸭"
+    hmap[10583] = "小鸭"
     
     /* 查询操作 */
     // 向哈希表输入键 key ，得到值 value
-    name := mapp[15937]
+    name := hmap[15937]
     
     /* 删除操作 */
     // 在哈希表中删除键值对 (key, value)
-    delete(mapp, 10583)
+    delete(hmap, 10583)
     ```
 
 === "JS"
@@ -305,13 +305,13 @@ comments: true
     ```python title="hash_map.py"
     # 遍历哈希表
     # 遍历键值对 key->value
-    for key, value in mapp.items():
+    for key, value in hmap.items():
         print(key, "->", value)
     # 单独遍历键 key
-    for key in mapp.keys():
+    for key in hmap.keys():
         print(key)
     # 单独遍历值 value
-    for value in mapp.values():
+    for value in hmap.values():
         print(value)
     ```
 
@@ -320,15 +320,15 @@ comments: true
     ```go title="hash_map_test.go"
     /* 遍历哈希表 */
     // 遍历键值对 key->value
-    for key, value := range mapp {
+    for key, value := range hmap {
         fmt.Println(key, "->", value)
     }
     // 单独遍历键 key
-    for key := range mapp {
+    for key := range hmap {
         fmt.Println(key)
     }
     // 单独遍历值 value
-    for _, value := range mapp {
+    for _, value := range hmap {
         fmt.Println(value)
     }
     ```

chapter_introduction/algorithms_are_everywhere.md

@@ -34,16 +34,15 @@ comments: true
 **例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下：
 
 1. 将扑克牌划分为“有序”和“无序”两部分，并假设初始状态下最左 1 张扑克牌已经有序。
-2. 在无序区间抽出一张扑克牌，插入至有序区间的正确位置；完成后最左 2 张扑克已经有序。
+2. 在无序部分抽出一张扑克牌，插入至有序部分的正确位置；完成后最左 2 张扑克已经有序。
-3. 在无序区间抽出一张扑克牌，插入至有序区间的正确位置；完成后最左 3 张扑克已经有序。
+3. 不断循环步骤 `2.` ，每一轮将一张扑克牌从无序部分插入至有序部分，直至所有扑克牌都有序。
-4. 不断循环以上操作，直至所有扑克牌都有序后终止。
-
-以上整理扑克牌的方法本质上就是「插入排序」算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。
 
 ![扑克排序步骤](algorithms_are_everywhere.assets/playing_cards_sorting.png)
 
 <p align="center"> Fig. 扑克排序步骤 </p>
 
+上述整理扑克牌的方法本质上是「插入排序」算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。
+
 **例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要给我们找 $31$ 元。他会很自然地完成以下思考：
 
 1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ , $5$ , $10$ , $20$ 元。
@@ -52,14 +51,14 @@ comments: true
 4. 从剩余可选项中拿出最大的 $1$ 元，剩余 $1 - 1 = 0$ 元。
 5. 完成找零，方案为 $20 + 10 + 1 = 31$ 元。
 
-在以上步骤中，我们每一步都采取当前看来最好的选择（尽可能用大面额的货币），最终得到了可行的找零方案。从数据结构与算法的角度看，这种方法本质上是「贪心算法」。
-
 ![货币找零过程](algorithms_are_everywhere.assets/greedy_change.png)
 
 <p align="center"> Fig. 货币找零过程 </p>
 
+在以上步骤中，我们每一步都采取当前看来最好的选择（尽可能用大面额的货币），最终得到了可行的找零方案。从数据结构与算法的角度看，这种方法本质上是「贪心算法」。
+
 小到烹饪一道菜，大到星际航行，几乎所有问题的解决都离不开算法。计算机的出现使我们能够通过编程将数据结构存储在内存中，同时编写代码调用 CPU 和 GPU 执行算法。这样一来，我们就能把生活中的问题转移到计算机上，以更高效的方式解决各种复杂问题。
 
 !!! tip
 
-    阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，那么太好了！因为这正是本书存在的意义。接下来，这本书将一步步引导你深入数据结构与算法的知识殿堂。
+    阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，那么太好了！因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。

chapter_introduction/what_is_dsa.md

@@ -6,7 +6,7 @@ comments: true
 
 ## 1.2.1.   算法定义
 
-「算法 Algorithm」是在有限时间内解决特定问题的一组指令或操作步骤。算法具有以下特性：
+「算法 Algorithm」是在有限时间内解决特定问题的一组指令或操作步骤。它具有以下特性：
 
 - 问题是明确的，包含清晰的输入和输出定义。
 - 具有可行性，能够在有限步骤、时间和内存空间下完成。
@@ -14,17 +14,20 @@ comments: true
 
 ## 1.2.2.   数据结构定义
 
-「数据结构 Data Structure」是计算机中组织和存储数据的方式。为了提高数据存储和操作性能，数据结构的设计目标包括：
+「数据结构 Data Structure」是计算机中组织和存储数据的方式。它的设计目标包括：
 
 - 空间占用尽量减少，节省计算机内存。
 - 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
 - 提供简洁的数据表示和逻辑信息，以便使得算法高效运行。
 
-数据结构设计是一个充满权衡的过程，这意味着要在某方面取得优势，往往需要在另一方面作出妥协。例如，链表相较于数组，在数据添加和删除操作上更加便捷，但牺牲了数据访问速度；图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。
+**数据结构设计是一个充满权衡的过程**。如果想要在某方面取得提升，往往需要在另一方面作出妥协，例如：
+
+- 链表相较于数组，在数据添加和删除操作上更加便捷，但牺牲了数据访问速度。
+- 图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。
 
 ## 1.2.3.   数据结构与算法的关系
 
-「数据结构」与「算法」高度相关且紧密结合，具体表现在：
+数据结构与算法高度相关、紧密结合，具体表现在：
 
 - 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。
 - 算法是数据结构发挥的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。
@@ -34,7 +37,7 @@ comments: true
 
 <p align="center"> Fig. 数据结构与算法的关系 </p>
 
-我们可以把数据结构与算法类比为拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
+数据结构与算法犹如拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
 
 ![拼装积木](what_is_dsa.assets/assembling_blocks.jpg)
 
@@ -53,8 +56,8 @@ comments: true
 
 </div>
 
-值得注意的是，数据结构与算法独立于编程语言。正因如此，本书得以提供多种编程语言的实现。
+值得说明的是，数据结构与算法是独立于编程语言的。正因如此，本书得以提供多种编程语言的实现。
 
 !!! tip "约定俗成的简称"
 
-    在实际讨论时，我们通常会将「数据结构与算法」简称为「算法」。例如，众所周知的 LeetCode 算法题目，实际上同时考察了数据结构和算法两方面的知识。
+    在实际讨论时，我们通常会将「数据结构与算法」简称为「算法」。比如众所周知的 LeetCode 算法题目，实际上同时考察了数据结构和算法两方面的知识。

chapter_preface/suggestions.md

@@ -166,7 +166,7 @@ comments: true
 
 ## 0.2.2.   在动画图解中高效学习
 
-相较于文字，视频和图片具有更高的信息密度和结构化程度，因此更易于理解。在本书中，**重点和难点知识将主要通过动画和图解形式展示**，而文字则作为动画和图片的解释与补充。
+相较于文字，视频和图片具有更高的信息密度和结构化程度，更易于理解。在本书中，**重点和难点知识将主要通过动画和图解形式展示**，而文字则作为动画和图片的解释与补充。
 
 在阅读本书时，如果发现某段内容提供了动画或图解，**建议以图为主线**，以文字（通常位于图像上方）为辅，综合两者来理解内容。
 
@@ -176,9 +176,11 @@ comments: true
 
 ## 0.2.3.   在代码实践中加深理解
 
-本书的配套代码托管在[GitHub 仓库](https://github.com/krahets/hello-algo)，**源代码包含详细注释，并附有测试样例，可直接运行**。
+本书的配套代码被托管在 [GitHub 仓库](https://github.com/krahets/hello-algo)。**源代码附有测试样例，可一键运行**。
 
-如果学习时间有限，建议你至少通读并运行所有代码。如果时间充裕，**建议参照代码自行敲一遍**。与仅阅读代码相比，编写代码的过程往往能带来更多收获。
+如果时间允许，**建议你参照代码自行敲一遍**。如果学习时间有限，请至少通读并运行所有代码。
+
+与阅读代码相比，编写代码的过程往往能带来更多收获。**动手学，才是真的学**。
 
 ![运行代码示例](../index.assets/running_code.gif)