Polish the chapter of searching and sorting.

docs/chapter_appendix/installation.md

@@ -38,9 +38,9 @@
 ## Swift 环境
 
 1. 下载并安装 [Swift](https://www.swift.org/download/)；
-2. 在 VSCode 的插件市场中搜索 `swift`，安装 [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang)。
+2. 在 VSCode 的插件市场中搜索 `swift` ，安装 [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang)。
 
 ## Rust 环境
 
 1. 下载并安装 [Rust](https://www.rust-lang.org/tools/install)；
-2. 在 VSCode 的插件市场中搜索 `rust`，安装 [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer)。
+2. 在 VSCode 的插件市场中搜索 `rust` ，安装 [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer)。

docs/chapter_array_and_linkedlist/linked_list.md

@@ -400,7 +400,7 @@
     [class]{}-[func]{insert}
     ```
 
-在链表中删除节点也非常方便，只需改变一个节点的指针即可。如下图所示，尽管在删除操作完成后，节点 `P` 仍然指向 `n1`，但实际上 `P` 已经不再属于此链表，因为遍历此链表时无法访问到 `P`。
+在链表中删除节点也非常方便，只需改变一个节点的指针即可。如下图所示，尽管在删除操作完成后，节点 `P` 仍然指向 `n1` ，但实际上 `P` 已经不再属于此链表，因为遍历此链表时无法访问到 `P` 。
 
 ![链表删除节点](linked_list.assets/linkedlist_remove_node.png)
 

docs/chapter_array_and_linkedlist/list.md

@@ -545,7 +545,7 @@
     }
     ```
 
-**拼接两个列表**。给定一个新列表 `list1`，我们可以将该列表拼接到原列表的尾部。
+**拼接两个列表**。给定一个新列表 `list1` ，我们可以将该列表拼接到原列表的尾部。
 
 === "Java"
 

docs/chapter_computational_complexity/space_complexity.md

@@ -364,7 +364,7 @@
 
     ```
 
-**在递归函数中，需要注意统计栈帧空间**。例如，函数 `loop()` 在循环中调用了 $n$ 次 `function()`，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()`，从而占用 $O(n)$ 的栈帧空间。
+**在递归函数中，需要注意统计栈帧空间**。例如，函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
 
 === "Java"
 
@@ -824,7 +824,7 @@ $$
     [class]{}-[func]{quadratic}
     ```
 
-在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()`，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体占用 $O(n^2)$ 空间。
+在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体占用 $O(n^2)$ 空间。
 
 === "Java"
 

docs/chapter_computational_complexity/time_complexity.md

@@ -161,7 +161,7 @@ $$
 
 「时间复杂度分析」采取了一种不同的方法，其统计的不是算法运行时间，**而是算法运行时间随着数据量变大时的增长趋势**。
 
-“时间增长趋势”这个概念较为抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$，给定三个算法 `A`，`B`，`C` 。
+“时间增长趋势”这个概念较为抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法 `A` , `B` , `C` 。
 
 - 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
 - 算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大呈线性增长。此算法的时间复杂度被称为「线性阶」。

docs/chapter_data_structure/data_and_memory.md

@@ -34,7 +34,7 @@
 
 1. 整数类型 int 占用 4 bytes = 32 bits ，可以表示 $2^{32}$ 个不同的数字；
 2. 将最高位视为符号位，$0$ 代表正数，$1$ 代表负数，一共可表示 $2^{31}$ 个正数和 $2^{31}$ 个负数；
-3. 当所有 bits 为 0 时代表数字 $0$ ，从零开始增大，可得最大正数为 $2^{31} - 1$；
+3. 当所有 bits 为 0 时代表数字 $0$ ，从零开始增大，可得最大正数为 $2^{31} - 1$ ；
 4. 剩余 $2^{31}$ 个数字全部用来表示负数，因此最小负数为 $-2^{31}$ ；具体细节涉及“源码、反码、补码”的相关知识，有兴趣的同学可以查阅学习；
 
 其他整数类型 byte, short, long 的取值范围的计算方法与 int 类似，在此不再赘述。
@@ -53,7 +53,7 @@
 - 指数位 $\mathrm{E}$ ：占 8 bits ；
 - 分数位 $\mathrm{N}$ ：占 24 bits ，其中 23 位显式存储；
 
-设 32-bit 二进制数的第 $i$ 位为 $b_i$，则 float 值的计算方法定义为：
+设 32-bit 二进制数的第 $i$ 位为 $b_i$ ，则 float 值的计算方法定义为：
 
 $$
 \text { val } = (-1)^{b_{31}} \times 2^{\left(b_{30} b_{29} \ldots b_{23}\right)_2-127} \times\left(1 . b_{22} b_{21} \ldots b_0\right)_2

docs/chapter_graph/graph_operations.md

@@ -116,7 +116,7 @@
 以下是基于邻接表实现图的代码示例。细心的同学可能注意到，**我们在邻接表中使用 `Vertex` 节点类来表示顶点**，这样做的原因有：
 
 - 如果我们选择通过顶点值来区分不同顶点，那么值重复的顶点将无法被区分。
-- 如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 $i$ 的顶点，则需要遍历整个邻接表，将其中 $> i$ 的索引全部减 $1$，这样操作效率较低。
+- 如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 $i$ 的顶点，则需要遍历整个邻接表，将其中 $> i$ 的索引全部减 $1$ ，这样操作效率较低。
 - 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无需改动其余顶点了。
 
 === "Java"

docs/chapter_hashing/hash_map.md

@@ -15,7 +15,7 @@
 3. **链表**：每个节点的值为 `[学号, 姓名]` ；
 4. **二叉搜索树**：每个节点的值为 `[学号, 姓名]` ，根据学号大小来构建树；
 
-各项操作的时间复杂度如下表所示（详解可见[二叉搜索树章节](https://www.hello-algo.com/chapter_tree/binary_search_tree/)）。无论是查找元素还是增删元素，哈希表的时间复杂度都是 $O(1)$，全面胜出！
+各项操作的时间复杂度如下表所示（详解可见[二叉搜索树章节](https://www.hello-algo.com/chapter_tree/binary_search_tree/)）。无论是查找元素还是增删元素，哈希表的时间复杂度都是 $O(1)$ ，全面胜出！
 
 <div class="center-table" markdown>
 

docs/chapter_heap/build_heap.md

@@ -81,7 +81,7 @@
 - 完全二叉树中，设节点总数为 $n$ ，则叶节点数量为 $(n + 1) / 2$ ，其中 $/$ 为向下整除。因此，在排除叶节点后，需要堆化的节点数量为 $(n - 1)/2$ ，复杂度为 $O(n)$ ；
 - 在从顶至底堆化的过程中，每个节点最多堆化到叶节点，因此最大迭代次数为二叉树高度 $O(\log n)$ ；
 
-将上述两者相乘，可得到建堆过程的时间复杂度为 $O(n \log n)$。**然而，这个估算结果并不准确，因为我们没有考虑到二叉树底层节点数量远多于顶层节点的特性**。
+将上述两者相乘，可得到建堆过程的时间复杂度为 $O(n \log n)$ 。**然而，这个估算结果并不准确，因为我们没有考虑到二叉树底层节点数量远多于顶层节点的特性**。
 
 接下来我们来进行更为详细的计算。为了减小计算难度，我们假设树是一个“完美二叉树”，该假设不会影响计算结果的正确性。设二叉树（即堆）节点数量为 $n$ ，树高度为 $h$ 。上文提到，**节点堆化最大迭代次数等于该节点到叶节点的距离，而该距离正是“节点高度”**。
 

docs/chapter_heap/heap.md

@@ -627,7 +627,7 @@
 === "<10>"
     ![heap_pop_step10](heap.assets/heap_pop_step10.png)
 
-与元素入堆操作相似，堆顶元素出堆操作的时间复杂度也为 $O(\log n)$。
+与元素入堆操作相似，堆顶元素出堆操作的时间复杂度也为 $O(\log n)$ 。
 
 === "Java"
 
@@ -711,6 +711,6 @@
 
 ## 堆常见应用
 
-- **优先队列**：堆通常作为实现优先队列的首选数据结构，其入队和出队操作的时间复杂度均为 $O(\log n)$，而建队操作为 $O(n)$，这些操作都非常高效。
+- **优先队列**：堆通常作为实现优先队列的首选数据结构，其入队和出队操作的时间复杂度均为 $O(\log n)$ ，而建队操作为 $O(n)$ ，这些操作都非常高效。
 - **堆排序**：给定一组数据，我们可以用它们建立一个堆，然后依次将所有元素弹出，从而得到一个有序序列。当然，堆排序的实现方法并不需要弹出元素，而是每轮将堆顶元素交换至数组尾部并缩小堆的长度。
 - **获取最大的 $k$ 个元素**：这是一个经典的算法问题，同时也是一种典型应用，例如选择热度前 10 的新闻作为微博热搜，选取销量前 10 的商品等。

docs/chapter_heap/summary.md

@@ -5,4 +5,4 @@
 - 堆的常用操作及其对应的时间复杂度包括：元素入堆 $O(\log n)$ 、堆顶元素出堆 $O(\log n)$ 和访问堆顶元素 $O(1)$ 等。
 - 完全二叉树非常适合用数组表示，因此我们通常使用数组来存储堆。
 - 堆化操作用于维护堆的性质，在入堆和出堆操作中都会用到。
-- 输入 $n$ 个元素并建堆的时间复杂度可以优化至 $O(n)$，非常高效。
+- 输入 $n$ 个元素并建堆的时间复杂度可以优化至 $O(n)$ ，非常高效。

docs/chapter_searching/binary_search.md

@@ -1,28 +1,23 @@
 # 二分查找
 
-「二分查找 Binary Search」利用数据的有序性，通过每轮缩小一半搜索区间来查找目标元素。
-
-使用二分查找有两个前置条件：
-
-- **要求输入数据是有序的**，这样才能通过判断大小关系来排除一半的搜索区间；
-- **二分查找仅适用于数组**，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。
+「二分查找 Binary Search」利用数据的有序性，通过每轮减少一半搜索范围来定位目标元素。
 
 ## 算法实现
 
-给定一个长度为 $n$ 的排序数组 `nums` ，元素从小到大排列。数组的索引取值范围为
+给定一个长度为 $n$ 的有序数组 `nums` ，元素按从小到大的顺序排列。数组索引的取值范围为：
 
 $$
 0, 1, 2, \cdots, n-1
 $$
 
-使用「区间」来表示这个取值范围的方法主要有两种：
+我们通常使用以下两种方法来表示这个取值范围：
 
-1. **双闭区间 $[0, n-1]$** ，即两个边界都包含自身；此方法下，区间 $[0, 0]$ 仍包含一个元素；
-2. **左闭右开 $[0, n)$** ，即左边界包含自身、右边界不包含自身；此方法下，区间 $[0, 0)$ 为空；
+1. **双闭区间 $[0, n-1]$** ，即两个边界都包含自身；在此方法下，区间 $[0, 0]$ 仍包含 $1$ 个元素；
+2. **左闭右开 $[0, n)$** ，即左边界包含自身、右边界不包含自身；在此方法下，区间 $[0, 0)$ 不包含元素；
 
 ### “双闭区间”实现
 
-首先，我们先采用“双闭区间”的表示，在数组 `nums` 中查找目标元素 `target` 的对应索引。
+首先，我们采用“双闭区间”表示法，在数组 `nums` 中查找目标元素 `target` 的对应索引。
 
 === "<1>"
     ![二分查找步骤](binary_search.assets/binary_search_step1.png)
@@ -45,7 +40,7 @@ $$
 === "<7>"
     ![binary_search_step7](binary_search.assets/binary_search_step7.png)
 
-二分查找“双闭区间”表示下的代码如下所示。
+二分查找在“双闭区间”表示下的代码如下所示。
 
 === "Java"
 
@@ -109,7 +104,7 @@ $$
 
 ### “左闭右开”实现
 
-当然，我们也可以使用“左闭右开”的表示方法，写出相同功能的二分查找代码。
+此外，我们也可以采用“左闭右开”的表示法，编写具有相同功能的二分查找代码。
 
 === "Java"
 
@@ -173,7 +168,7 @@ $$
 
 ### 两种表示对比
 
-对比下来，两种表示的代码写法有以下不同点：
+对比这两种代码写法，我们可以发现以下不同点：
 
 <div class="center-table" markdown>
 
@@ -184,11 +179,11 @@ $$
 
 </div>
 
-观察发现，在“双闭区间”表示中，由于对左右两边界的定义是相同的，因此缩小区间的 $i$ , $j$ 处理方法也是对称的，这样更不容易出错。综上所述，**建议你采用“双闭区间”的写法。**
+在“双闭区间”表示法中，由于对左右两边界的定义相同，因此缩小区间的 $i$ 和 $j$ 的处理方法也是对称的，这样更不容易出错。因此，**建议采用“双闭区间”的写法**。
 
 ### 大数越界处理
 
-当数组长度很大时，加法 $i + j$ 的结果有可能会超出 `int` 类型的取值范围。在此情况下，我们需要换一种计算中点的写法。
+当数组长度非常大时，加法 $i + j$ 的结果可能会超出 `int` 类型的取值范围。在这种情况下，我们需要采用一种更安全的计算中点的方法。
 
 === "Java"
 
@@ -274,19 +269,19 @@ $$
 
 ## 复杂度分析
 
-**时间复杂度 $O(\log n)$** ：其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
+**时间复杂度 $O(\log n)$** ：其中 $n$ 为数组长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
 
 **空间复杂度 $O(1)$** ：指针 `i` , `j` 使用常数大小空间。
 
-## 优点与缺点
+## 优点与局限性
 
-二分查找效率很高，体现在：
+二分查找效率很高，主要体现在：
 
-- **二分查找时间复杂度低**。对数阶在数据量很大时具有巨大优势，例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
-- **二分查找不需要额外空间**。相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。
+- **二分查找的时间复杂度较低**。对数阶在大数据量情况下具有显著优势。例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需 $\log_2 2^{20} = 20$ 轮循环。
+- **二分查找无需额外空间**。与哈希查找相比，二分查找更加节省空间。
 
-但并不意味着所有情况下都应使用二分查找，这是因为：
+然而，并非所有情况下都可使用二分查找，原因如下：
 
-- **二分查找仅适用于有序数据**。如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
-- **二分查找仅适用于数组**。由于在二分查找中，访问索引是 “非连续” 的，因此链表或者基于链表实现的数据结构都无法使用。
-- **在小数据量下，线性查找的性能更好**。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。
+- **二分查找仅适用于有序数据**。若输入数据无序，为了使用二分查找而专门进行排序，得不偿失。因为排序算法的时间复杂度通常为 $O(n \log n)$ ，比线性查找和二分查找都更高。对于频繁插入元素的场景，为保持数组有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
+- **二分查找仅适用于数组**。二分查找需要跳跃式（非连续地）访问元素，而在链表中执行跳跃式访问的效率较低，因此不适合应用在链表或基于链表实现的数据结构。
+- **小数据量下，线性查找性能更佳**。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，当数据量 $n$ 较小时，线性查找反而比二分查找更快。

docs/chapter_searching/hashing_search.md

@@ -1,14 +1,12 @@
 # 哈希查找
 
-!!! question
+「哈希查找 Hash Searching」通过使用哈希表来存储所需的键值对，从而可在 $O(1)$ 时间内完成“键 $\rightarrow$ 值”的查找操作。
 
-    在数据量很大时，「线性查找」太慢；而「二分查找」要求数据必须是有序的，并且只能在数组中应用。那么是否有方法可以同时避免上述缺点呢？答案是肯定的，此方法被称为「哈希查找」。
-
-「哈希查找 Hash Searching」借助一个哈希表来存储需要的「键值对 Key Value Pair」，我们可以在 $O(1)$ 时间下实现“键 $\rightarrow$ 值”映射查找，体现着“以空间换时间”的算法思想。
+与线性查找相比，哈希查找通过利用额外空间来提高效率，体现了“以空间换时间”的算法思想。
 
 ## 算法实现
 
-如果我们想要给定数组中的一个目标元素 `target` ，获取该元素的索引，那么可以借助一个哈希表实现查找。
+例如，若我们想要在给定数组中找到目标元素 `target` 的索引，则可以使用哈希查找来实现。
 
 ![哈希查找数组索引](hashing_search.assets/hash_search_index.png)
 
@@ -72,7 +70,7 @@
     [class]{}-[func]{hashingSearchArray}
     ```
 
-再比如，如果我们想要给定一个目标节点值 `target` ，获取对应的链表节点对象，那么也可以使用哈希查找实现。
+同样，若要根据目标节点值 target 查找对应的链表节点对象，也可以采用哈希查找方法。
 
 ![哈希查找链表节点](hashing_search.assets/hash_search_listnode.png)
 
@@ -140,15 +138,15 @@
 
 **时间复杂度 $O(1)$** ：哈希表的查找操作使用 $O(1)$ 时间。
 
-**空间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
+**空间复杂度 $O(n)$** ：其中 $n$ 是数组或链表的长度。
 
-## 优点与缺点
+## 优点与局限性
 
-在哈希表中，**查找、插入、删除操作的平均时间复杂度都为 $O(1)$** ，这意味着无论是高频增删还是高频查找场景，哈希查找的性能表现都非常好。当然，一切的前提是保证哈希表未退化。
+哈希查找的性能表现相当优秀，查找、插入、删除操作的平均时间复杂度均为 $O(1)$ 。尽管如此，哈希查找仍然存在一些问题：
 
-即使如此，哈希查找仍存在一些问题，在实际应用中，需要根据情况灵活选择方法。
+- 辅助哈希表需要占用 $O(n)$ 的额外空间，意味着需要预留更多的计算机内存；
+- 构建和维护哈希表需要时间，因此哈希查找不适用于高频增删、低频查找的场景；
+- 当哈希冲突严重时，哈希表可能退化为链表，导致时间复杂度劣化至 $O(n)$ ；
+- 当数据量较小时，线性查找可能比哈希查找更快。这是因为计算哈希函数可能比遍历一个小型数组更慢；
 
-- 辅助哈希表 **需要使用 $O(n)$ 的额外空间**，意味着需要预留更多的计算机内存；
-- 建立和维护哈希表需要时间，因此哈希查找 **不适合高频增删、低频查找的使用场景**；
-- 当哈希冲突严重时，哈希表会退化为链表，**时间复杂度劣化至 $O(n)$** ；
-- **当数据量很小时，线性查找比哈希查找更快**。这是因为计算哈希映射函数可能比遍历一个小型数组更慢；
+因此，在实际应用中，我们需要根据具体情况灵活选择解决方案。

docs/chapter_searching/linear_search.md

@@ -1,10 +1,10 @@
 # 线性查找
 
-「线性查找 Linear Search」是一种最基础的查找方法，其从数据结构的一端开始，依次访问每个元素，直到另一端后停止。
+「线性查找 Linear Search」是一种简单的查找方法，其从数据结构的一端开始，逐个访问每个元素，直至另一端为止。
 
 ## 算法实现
 
-线性查找实质上就是遍历数据结构 + 判断条件。比如，我们想要在数组 `nums` 中查找目标元素 `target` 的对应索引，那么可以在数组中进行线性查找。
+例如，若我们想要在数组 `nums` 中查找目标元素 `target` 的对应索引，可以采用线性查找方法。
 
 ![在数组中线性查找元素](linear_search.assets/linear_search.png)
 
@@ -68,7 +68,7 @@
     [class]{}-[func]{linearSearchArray}
     ```
 
-再比如，我们想要在给定一个目标节点值 `target` ，返回此节点对象，也可以在链表中进行线性查找。
+另一个例子，若需要在链表中查找给定目标节点值 `target` 并返回该节点对象，同样可以使用线性查找。
 
 === "Java"
 
@@ -132,12 +132,12 @@
 
 ## 复杂度分析
 
-**时间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
+**时间复杂度 $O(n)$** ：其中 $n$ 代表数组或链表的长度。
 
-**空间复杂度 $O(1)$** ：无需使用额外空间。
+**空间复杂度 $O(1)$** ：无需借助额外的存储空间。
 
-## 优点与缺点
+## 优点与局限性
 
-**线性查找的通用性极佳**。由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
+**线性查找具有极佳的通用性**。由于线性查找是逐个访问元素的，没有跳跃式访问，因此适用于数组和链表的查找。
 
-**线性查找的时间复杂度太高**。在数据量 $n$ 很大时，查找效率很低。
+**线性查找的时间复杂度较高**。当数据量 $n$ 较大时，线性查找的效率较低。

docs/chapter_searching/summary.md

@@ -1,18 +1,16 @@
 # 小结
 
-- 线性查找是一种最基础的查找方法，通过遍历数据结构 + 判断条件实现查找。
-- 二分查找利用数据的有序性，通过循环不断缩小一半搜索区间来实现查找，其要求输入数据是有序的，并且仅适用于数组或基于数组实现的数据结构。
-- 哈希查找借助哈希表来实现常数阶时间复杂度的查找操作，体现以空间换时间的算法思想。
-- 下表总结对比了查找算法的各种特性和时间复杂度。
+- 线性查找通过遍历数据结构并进行条件判断来完成查找任务。
+- 二分查找依赖于数据的有序性，通过循环逐步缩减一半搜索区间来实现查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。
+- 哈希查找利用哈希表实现常数阶时间复杂度的查找操作，体现了空间换时间的算法思维。
+- 下表概括并对比了三种查找算法的特性和时间复杂度。
 
 <div class="center-table" markdown>
 
 |                                       | 线性查找                 | 二分查找                      | 哈希查找                 |
 | ------------------------------------- | ------------------------ | ----------------------------- | ------------------------ |
-| 适用数据结构                          | 数组、链表               | 数组                          | 数组、链表               |
-| 输入数据要求                          | 无                       | 有序                          | 无                       |
-| 平均时间复杂度</br>查找 / 插入 / 删除 | $O(n)$ / $O(1)$ / $O(n)$ | $O(\log n)$ / $O(n)$ / $O(n)$ | $O(1)$ / $O(1)$ / $O(1)$ |
-| 最差时间复杂度</br>查找 / 插入 / 删除 | $O(n)$ / $O(1)$ / $O(n)$ | $O(\log n)$ / $O(n)$ / $O(n)$ | $O(n)$ / $O(n)$ / $O(n)$ |
-| 空间复杂度                            | $O(1)$                   | $O(1)$                        | $O(n)$                   |
+| 适用数据结构                           | 数组、链表               | 有序数组                          | 数组、链表               |
+| 时间复杂度</br>（查找，插入，删除）        | $O(n)$ , $O(1)$ , $O(n)$ | $O(\log n)$ , $O(n)$ , $O(n)$ | $O(1)$ , $O(1)$ , $O(1)$ |
+| 空间复杂度                             | $O(1)$                   | $O(1)$                        | $O(n)$                   |
 
 </div>

docs/chapter_sorting/bubble_sort.md

@@ -1,14 +1,10 @@
 # 冒泡排序
 
-「冒泡排序 Bubble Sort」是一种基于元素交换实现排序的算法，非常适合作为第一个学习的排序算法。
+「冒泡排序 Bubble Sort」的工作原理类似于泡泡在水中的浮动。在水中，较大的泡泡会最先浮到水面。
 
-!!! question "为什么叫“冒泡”"
+「冒泡操作」利用元素交换操作模拟了上述过程，具体做法为：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。
 
-    在水中，越大的泡泡浮力越大，所以最大的泡泡会最先浮到水面。
-
-「冒泡操作」则是在模拟上述过程，具体做法为：从数组最左端开始向右遍历，依次对比相邻元素大小，若“左元素 > 右元素”则将它俩交换，最终可将最大元素移动至数组最右端。
-
-完成一次冒泡操作后，**数组最大元素已在正确位置，接下来只需排序剩余 $n - 1$ 个元素**。
+**在完成一次冒泡操作后，数组的最大元素已位于正确位置，接下来只需对剩余 $n - 1$ 个元素进行排序**。
 
 === "<1>"
     ![冒泡操作步骤](bubble_sort.assets/bubble_operation_step1.png)
@@ -33,11 +29,11 @@
 
 ## 算法流程
 
-设输入数组长度为 $n$ ，循环执行「冒泡」操作：
+设输入数组长度为 $n$ ，整个冒泡排序的步骤为：
 
-1. 完成第一轮「冒泡」后，数组最大元素已在正确位置，接下来只需排序剩余 $n - 1$ 个元素；
-2. 对剩余 $n - 1$ 个元素执行「冒泡」，可将第二大元素交换至正确位置，因而待排序元素只剩 $n - 2$ 个；
-3. 以此类推…… **循环 $n - 1$ 轮「冒泡」，即可完成整个数组的排序**；
+1. 完成第一轮「冒泡」后，数组的最大元素已位于正确位置，接下来只需对剩余 $n - 1$ 个元素进行排序；
+2. 对剩余 $n - 1$ 个元素执行冒泡操作，可将第二大元素交换至正确位置，因而待排序元素只剩 $n - 2$ 个；
+3. 如此类推，经过 $n - 1$ 轮冒泡操作，整个数组便完成排序；
 
 ![冒泡排序流程](bubble_sort.assets/bubble_sort_overview.png)
 
@@ -103,17 +99,17 @@
 
 ## 算法特性
 
-**时间复杂度 $O(n^2)$** ：各轮冒泡遍历的数组长度为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。引入下文的 `flag` 优化后，最佳时间复杂度可以达到 $O(N)$ ，因此是“自适应排序”。
+**时间复杂度 $O(n^2)$** ：各轮冒泡遍历的数组长度依次为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ ，总和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。在引入下文的 `flag` 优化后，最佳时间复杂度可达到 $O(n)$ ，所以它是“自适应排序”。
 
 **空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间，因此是“原地排序”。
 
-在冒泡操作中遇到相等元素不交换，因此是“稳定排序”。
+由于冒泡操作中遇到相等元素不交换，因此冒泡排序是“稳定排序”。
 
 ## 效率优化
 
-我们发现，若在某轮「冒泡」中未执行任何交换操作，则说明数组已经完成排序，可直接返回结果。考虑可以增加一个标志位 `flag` 来监听该情况，若出现则直接返回。
+我们发现，如果某轮冒泡操作中没有执行任何交换操作，说明数组已经完成排序，可直接返回结果。因此，可以增加一个标志位 `flag` 来监测这种情况，一旦出现就立即返回。
 
-优化后，冒泡排序的最差和平均时间复杂度仍为 $O(n^2)$ ；而在输入数组完全有序时，达到最佳时间复杂度 $O(n)$ 。 
+经过优化，冒泡排序的最差和平均时间复杂度仍为 $O(n^2)$ ；但当输入数组完全有序时，可达到最佳时间复杂度 $O(n)$ 。
 
 === "Java"
 

docs/chapter_sorting/bucket_sort.md

@@ -1,14 +1,14 @@
 # 桶排序
 
-前面介绍的几种排序算法都属于 **基于比较的排序算法**，即通过比较元素之间的大小来实现排序，此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将学习几种 **非比较排序算法** ，其时间复杂度可以达到线性级别。
+前述的几种排序算法都属于“基于比较的排序算法”，它们通过比较元素间的大小来实现排序。此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将探讨几种“非比较排序算法”，它们的时间复杂度可以达到线性水平。
 
-「桶排序 Bucket Sort」是分治思想的典型体现，其通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中，并在每个桶内部分别执行排序，最终按照桶的顺序将所有数据合并即可。
+「桶排序 Bucket Sort」是分治思想的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
 
 ## 算法流程
 
-输入一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数，桶排序流程为：
+考虑一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数。桶排序的流程如下：
 
-1. 初始化 $k$ 个桶，将 $n$ 个元素分配至 $k$ 个桶中；
+1. 初始化 $k$ 个桶，将 $n$ 个元素分配到 $k$ 个桶中；
 2. 对每个桶分别执行排序（本文采用编程语言的内置排序函数）；
 3. 按照桶的从小到大的顺序，合并结果；
 
@@ -74,28 +74,28 @@
     [class]{}-[func]{bucketSort}
     ```
 
-!!! question "桶排序的应用场景是什么？"
+!!! question "桶排序的适用场景是什么？"
 
-    桶排序一般用于排序超大体量的数据。例如输入数据包含 100 万个元素，由于空间有限，系统无法一次性将所有数据加载进内存，那么可以先将数据划分到 1000 个桶里，再依次排序每个桶，最终合并结果即可。
+    桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。
 
 ## 算法特性
 
-**时间复杂度 $O(n + k)$** ：假设元素平均分布在各个桶内，则每个桶内元素数量为 $\frac{n}{k}$ 。假设排序单个桶使用 $O(\frac{n}{k} \log\frac{n}{k})$ 时间，则排序所有桶使用 $O(n \log\frac{n}{k})$ 时间，**当桶数量 $k$ 比较大时，时间复杂度则趋向于 $O(n)$** 。最后合并结果需要遍历 $n$ 个桶，使用 $O(k)$ 时间。
+**时间复杂度 $O(n + k)$** ：假设元素在各个桶内平均分布，那么每个桶内的元素数量为 $\frac{n}{k}$ 。假设排序单个桶使用 $O(\frac{n}{k} \log\frac{n}{k})$ 时间，则排序所有桶使用 $O(n \log\frac{n}{k})$ 时间。**当桶数量 $k$ 比较大时，时间复杂度则趋向于 $O(n)$** 。合并结果时需要遍历 $n$ 个桶，花费 $O(k)$ 时间。
 
-最差情况下，所有数据被分配到一个桶中，且排序算法退化至 $O(n^2)$ ，此时使用 $O(n^2)$ 时间，因此是“自适应排序”。
+在最坏情况下，所有数据被分配到一个桶中，且排序该桶使用 $O(n^2)$ 时间，因此是“自适应排序”。
 
-**空间复杂度 $O(n + k)$** ：需要借助 $k$ 个桶和共 $n$ 个元素的额外空间，是“非原地排序”。
+**空间复杂度 $O(n + k)$** ：需要借助 $k$ 个桶和总共 $n$ 个元素的额外空间，属于“非原地排序”。
 
 桶排序是否稳定取决于排序桶内元素的算法是否稳定。
 
 ## 如何实现平均分配
 
-桶排序的时间复杂度理论上可以达到 $O(n)$ ，**难点是需要将元素均匀分配到各个桶中**，因为现实中的数据往往都不是均匀分布的。举个例子，假设我们想要把淘宝的所有商品根据价格范围平均分配到 10 个桶中，然而商品价格不是均匀分布的，100 元以下非常多、1000 元以上非常少；如果我们将价格区间平均划为 10 份，那么各个桶内的商品数量差距会非常大。
+桶排序的时间复杂度理论上可以达到 $O(n)$ ，**关键在于将元素均匀分配到各个桶中**，因为实际数据往往不是均匀分布的。例如，我们想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。
 
-为了实现平均分配，我们可以先大致设置一个分界线，将数据粗略分到 3 个桶，分配完后，**再把商品较多的桶继续划分为 3 个桶，直至所有桶内元素数量大致平均为止**。此方法本质上是生成一个递归树，让叶节点的值尽量平均。当然，不一定非要划分为 3 个桶，可以根据数据特点灵活选取。
+为实现平均分配，我们可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。**分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等**。这种方法本质上是创建一个递归树，使叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。
 
 ![递归划分桶](bucket_sort.assets/scatter_in_buckets_recursively.png)
 
-如果我们提前知道商品价格的概率分布，**那么也可以根据数据概率分布来设置每个桶的价格分界线**。注意，数据分布不一定需要特意去统计，也可以根据数据特点采用某种概率模型来近似。如下图所示，我们假设商品价格服从正态分布，就可以合理设置价格区间，将商品平均分配到各个桶中。
+如果我们提前知道商品价格的概率分布，**则可以根据数据概率分布设置每个桶的价格分界线**。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。如下图所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。
 
 ![根据概率分布划分桶](bucket_sort.assets/scatter_in_buckets_distribution.png)

docs/chapter_sorting/counting_sort.md

@@ -1,14 +1,14 @@
 # 计数排序
 
-顾名思义，「计数排序 Counting Sort」通过统计元素数量来实现排序，一般应用于整数数组。
+「计数排序 Counting Sort」通过统计元素数量来实现排序，通常应用于整数数组。
 
 ## 简单实现
 
-先看一个简单例子。给定一个长度为 $n$ 的数组 `nums` ，元素皆为 **非负整数**。计数排序的整体流程为：
+先来看一个简单的例子。给定一个长度为 $n$ 的数组 `nums` ，其中的元素都是“非负整数”。计数排序的整体流程如下：
 
-1. 遍历记录数组中的最大数字，记为 $m$ ，并建立一个长度为 $m + 1$ 的辅助数组 `counter` ；
-2. **借助 `counter` 统计 `nums` 中各数字的出现次数**，其中 `counter[num]` 对应数字 `num` 的出现次数。统计方法很简单，只需遍历 `nums` （设当前数字为 `num`），每轮将 `counter[num]` 自增 $1$ 即可。
-3. **由于 `counter` 的各个索引是天然有序的，因此相当于所有数字已经被排序好了**。接下来，我们遍历 `counter` ，根据各数字的出现次数，将各数字按从小到大的顺序填入 `nums` 即可。
+1. 遍历数组，找出数组中的最大数字，记为 $m$ ，然后创建一个长度为 $m + 1$ 的辅助数组 `counter` ；
+2. **借助 `counter` 统计 `nums` 中各数字的出现次数**，其中 `counter[num]` 对应数字 `num` 的出现次数。统计方法很简单，只需遍历 `nums`（设当前数字为 `num`），每轮将 `counter[num]` 增加 $1$ 即可。
+3. **由于 `counter` 的各个索引天然有序，因此相当于所有数字已经被排序好了**。接下来，我们遍历 `counter` ，根据各数字的出现次数，将它们按从小到大的顺序填入 `nums` 即可。
 
 ![计数排序流程](counting_sort.assets/counting_sort_overview.png)
 
@@ -74,24 +74,24 @@
 
 !!! note "计数排序与桶排序的联系"
 
-    从桶排序的角度看，我们可以把计数排序中计数数组 `counter` 的每个索引想象成一个桶，将统计数量的过程想象成把各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
+    从桶排序的角度看，我们可以将计数排序中的计数数组 `counter` 的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
 
 ## 完整实现
 
-细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。例如输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
+细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。例如，输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
 
-那么如何才能得到原数据的排序结果呢？我们首先计算 `counter` 的「前缀和」，顾名思义，索引 `i` 处的前缀和 `prefix[i]` 等于数组前 `i` 个元素之和，即
+那么如何才能得到原数据的排序结果呢？我们首先计算 `counter` 的「前缀和」。顾名思义，索引 `i` 处的前缀和 `prefix[i]` 等于数组前 `i` 个元素之和，即
 
 $$
 \text{prefix}[i] = \sum_{j=0}^i \text{counter[j]}
 $$
 
-**前缀和具有明确意义，`prefix[num] - 1` 代表元素 `num` 在结果数组 `res` 中最后一次出现的索引**。这个信息很关键，因为其给出了各个元素应该出现在结果数组的哪个位置。接下来，我们倒序遍历原数组 `nums` 的每个元素 `num` ，在每轮迭代中执行：
+**前缀和具有明确的意义，`prefix[num] - 1` 代表元素 `num` 在结果数组 `res` 中最后一次出现的索引**。这个信息非常关键，因为它告诉我们各个元素应该出现在结果数组的哪个位置。接下来，我们倒序遍历原数组 `nums` 的每个元素 `num` ，在每轮迭代中执行：
 
 1. 将 `num` 填入数组 `res` 的索引 `prefix[num] - 1` 处；
-2. 令前缀和 `prefix[num]` 自减 $1$ ，从而得到下次放置 `num` 的索引；
+2. 令前缀和 `prefix[num]` 减小 $1$ ，从而得到下次放置 `num` 的索引；
 
-完成遍历后，数组 `res` 中就是排序好的结果，最后使用 `res` 覆盖原数组 `nums` 即可；
+遍历完成后，数组 `res` 中就是排序好的结果，最后使用 `res` 覆盖原数组 `nums` 即可。
 
 === "<1>"
     ![counting_sort_step1](counting_sort.assets/counting_sort_step1.png)
@@ -181,16 +181,16 @@ $$
 
 ## 算法特性
 
-**时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，此时使用线性 $O(n)$ 时间。
+**时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，时间复杂度趋于 $O(n)$ 。
 
-**空间复杂度 $O(n + m)$** ：借助了长度分别为 $n$ , $m$ 的数组 `res` 和 `counter` ，是“非原地排序”。
+**空间复杂度 $O(n + m)$** ：借助了长度分别为 $n$ 和 $m$ 的数组 `res` 和 `counter` ，因此是“非原地排序”。
 
-**稳定排序**：由于向 `res` 中填充元素的顺序是“从右向左”的，因此倒序遍历 `nums` 可以避免改变相等元素之间的相对位置，从而实现“稳定排序”；其实正序遍历 `nums` 也可以得到正确的排序结果，但结果“非稳定”。
+**稳定排序**：由于向 `res` 中填充元素的顺序是“从右向左”的，因此倒序遍历 `nums` 可以避免改变相等元素之间的相对位置，从而实现“稳定排序”。实际上，正序遍历 `nums` 也可以得到正确的排序结果，但结果是“非稳定”的。
 
 ## 局限性
 
-看到这里，你也许会觉得计数排序太妙了，咔咔一通操作，时间复杂度就下来了。然而，使用计数排序的前置条件比较苛刻。
+看到这里，你也许会觉得计数排序非常巧妙，仅通过统计数量就可以实现高效的排序工作。然而，使用计数排序的前置条件相对较为严格。
 
-**计数排序只适用于非负整数**。若想要用在其他类型数据上，则要求该数据必须可以被转化为非负整数，并且不能改变各个元素之间的相对大小关系。例如，对于包含负数的整数数组，可以先给所有数字加上一个常数，将全部数字转化为正数，排序完成后再转换回去即可。
+**计数排序只适用于非负整数**。若想要将其用于其他类型的数据，需要确保这些数据可以被转换为非负整数，并且在转换过程中不能改变各个元素之间的相对大小关系。例如，对于包含负数的整数数组，可以先给所有数字加上一个常数，将全部数字转化为正数，排序完成后再转换回去即可。
 
-**计数排序适用于数据量大但数据范围不大的情况**。比如，上述示例中 $m$ 不能太大，否则占用空间太多；而当 $n \ll m$ 时，计数排序使用 $O(m)$ 时间，有可能比 $O(n \log n)$ 的排序算法还要慢。
+**计数排序适用于数据量大但数据范围较小的情况**。比如，在上述示例中 $m$ 不能太大，否则会占用过多空间。而当 $n \ll m$ 时，计数排序使用 $O(m)$ 时间，可能比 $O(n \log n)$ 的排序算法还要慢。

docs/chapter_sorting/insertion_sort.md

@@ -1,20 +1,18 @@
 # 插入排序
 
-「插入排序 Insertion Sort」是一种基于 **数组插入操作** 的排序算法。
+「插入排序 Insertion Sort」是一种基于数组插入操作的排序算法。具体来说，选择一个待排序的元素作为基准值 `base` ，将 `base` 与其左侧已排序区间的元素逐一比较大小，并将其插入到正确的位置。
 
-「插入操作」原理：选定某个待排序元素为基准数 `base`，将 `base` 与其左侧已排序区间元素依次对比大小，并插入到正确位置。
-
-回忆数组插入操作，我们需要将从目标索引到 `base` 之间的所有元素向右移动一位，然后再将 `base` 赋值给目标索引。
+回顾数组插入操作，我们需要将从目标索引到 `base` 之间的所有元素向右移动一位，然后再将 `base` 赋值给目标索引。
 
 ![单次插入操作](insertion_sort.assets/insertion_operation.png)
 
 ## 算法流程
 
-循环执行插入操作：
+插入排序的整体流程如下：
 
-1. 先选取数组的 **第 2 个元素** 为 `base` ，执行插入操作后，**数组前 2 个元素已完成排序**。
-2. 选取 **第 3 个元素** 为 `base` ，执行插入操作后，**数组前 3 个元素已完成排序**。
-3. 以此类推……最后一轮选取 **数组尾元素** 为 `base` ，执行插入操作后，**所有元素已完成排序**。
+1. 首先，选取数组的第 2 个元素作为 `base` ，执行插入操作后，**数组的前 2 个元素已排序**。
+2. 接着，选取第 3 个元素作为 `base` ，执行插入操作后，**数组的前 3 个元素已排序**。
+3. 以此类推，在最后一轮中，选取数组尾元素作为 `base` ，执行插入操作后，**所有元素均已排序**。
 
 ![插入排序流程](insertion_sort.assets/insertion_sort_overview.png)
 
@@ -80,22 +78,22 @@
 
 ## 算法特性
 
-**时间复杂度 $O(n^2)$** ：最差情况下，各轮插入操作循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，使用 $O(n^2)$ 时间。输入数组完全有序下，达到最佳时间复杂度 $O(n)$ ，因此是“自适应排序”。
+**时间复杂度 $O(n^2)$** ：最差情况下，每次插入操作分别需要循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和得到 $\frac{(n - 1) n}{2}$ ，因此时间复杂度为 $O(n^2)$ 。当输入数组完全有序时，插入排序达到最佳时间复杂度 $O(n)$ ，因此是“自适应排序”。
 
-**空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间，因此是“原地排序”。
+**空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间，所以插入排序是“原地排序”。
 
-在插入操作中，我们会将元素插入到相等元素的右边，不会改变它们的次序，因此是“稳定排序”。
+在插入操作过程中，我们会将元素插入到相等元素的右侧，不会改变它们的顺序，因此是“稳定排序”。
 
 ## 插入排序优势
 
-回顾「冒泡排序」和「插入排序」的复杂度分析，两者的循环轮数都是 $\frac{(n - 1) n}{2}$ 。但不同的是：
+回顾冒泡排序和插入排序的复杂度分析，两者的循环轮数都是 $\frac{(n - 1) n}{2}$ 。然而，它们之间存在以下差异：
 
-- 冒泡操作基于 **元素交换** 实现，需要借助一个临时变量实现，共 3 个单元操作；
-- 插入操作基于 **元素赋值** 实现，只需 1 个单元操作；
+- 冒泡操作基于元素交换实现，需要借助一个临时变量，共涉及 3 个单元操作；
+- 插入操作基于元素赋值实现，仅需 1 个单元操作；
 
-粗略估计，冒泡排序的计算开销约为插入排序的 3 倍，因此插入排序更受欢迎，许多编程语言（例如 Java）的内置排序函数都使用到了插入排序，大致思路为：
+粗略估计下来，冒泡排序的计算开销约为插入排序的 3 倍，因此插入排序更受欢迎。实际上，许多编程语言（如 Java）的内置排序函数都采用了插入排序，大致思路为：
 
-- 对于 **长数组**，采用基于分治的排序算法，例如「快速排序」，时间复杂度为 $O(n \log n)$ ；
-- 对于 **短数组**，直接使用「插入排序」，时间复杂度为 $O(n^2)$ ；
+- 对于长数组，采用基于分治的排序算法，例如「快速排序」，时间复杂度为 $O(n \log n)$ ；
+- 对于短数组，直接使用「插入排序」，时间复杂度为 $O(n^2)$ ；
 
-虽然插入排序比快速排序的时间复杂度更高，**但实际上在数据量较小时插入排序更快**，这是因为复杂度中的常数项（即每轮中的单元操作数量）占主导作用。这个现象与「线性查找」和「二分查找」的情况类似。
+尽管插入排序的时间复杂度高于快速排序，**但在数据量较小的情况下，插入排序实际上更快**。这是因为在数据量较小时，复杂度中的常数项（即每轮中的单元操作数量）起主导作用。这个现象与「线性查找」和「二分查找」的情况相似。

docs/chapter_sorting/intro_to_sort.md

@@ -1,19 +1,21 @@
 # 排序简介
 
-「排序算法 Sorting Algorithm」使得列表中的所有元素按照从小到大的顺序排列。
+「排序算法 Sorting Algorithm」使列表中的所有元素按照升序排列。
 
-- 待排序的列表的 **元素类型** 可以是整数、浮点数、字符、或字符串；
-- 排序算法可以根据需要设定 **判断规则**，例如数字大小、字符 ASCII 码顺序、自定义规则；
+- 待排序列表的元素类型可以是整数、浮点数、字符或字符串等；
+- 排序算法可根据需求设定判断规则，如数字大小、字符 ASCII 码顺序或自定义规则；
 
 ![排序中不同的元素类型和判断规则](intro_to_sort.assets/sorting_examples.png)
 
 ## 评价维度
 
-**运行效率**：我们希望排序算法的时间复杂度尽可能低，并且总体操作数量更少（即时间复杂度中的常数项更低）。在大数据量下，运行效率尤为重要。
+**运行效率**：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。
 
-**就地性**：顾名思义，「原地排序」直接在原数组上操作实现排序，而不用借助额外辅助数组，节约内存；并且一般情况下，原地排序的数据搬运操作较少，运行速度也更快。
+**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无需借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
 
-**稳定性**：「稳定排序」在完成排序后，相等元素在数组中的相对顺序 **不会发生改变**。假设我们有一个存储学生信息的表格，第 1, 2 列分别是姓名和年龄。那么在以下示例中，「非稳定排序」会导致输入数据的有序性丢失。稳定性是排序算法很好的特性，**在多级排序中是必须的**。
+**稳定性**：「稳定排序」在完成排序后，相等元素在数组中的相对顺序不发生改变。稳定排序是优良特性，也是多级排序场景的必要条件。
+
+假设我们有一个存储学生信息的表格，第 1, 2 列分别是姓名和年龄。在这种情况下，「非稳定排序」可能导致输入数据的有序性丧失。
 
 ```shell
 # 输入数据是按照姓名排序好的
@@ -34,12 +36,14 @@
   ('E', 23)
 ```
 
-**自适应性**：「自适应排序」的时间复杂度受输入数据影响，即最佳、最差、平均时间复杂度不全部相等。自适应性也要分情况对待，若最差时间复杂度差于平均时间复杂度，代表排序算法会在某些数据下发生劣化，因此是负面性质；而若最佳时间复杂度优于平均时间复杂度，则是正面性质。
+**自适应性**：「自适应排序」的时间复杂度会受输入数据的影响，即最佳、最差、平均时间复杂度并不完全相等。
+
+自适应性需要根据具体情况来评估。如果最差时间复杂度差于平均时间复杂度，说明排序算法在某些数据下性能可能劣化，因此被视为负面属性；而如果最佳时间复杂度优于平均时间复杂度，则被视为正面属性。
 
-**是否基于比较**：「比较排序」是根据比较算子（$<$ , $=$ , $>$）来判断元素的相对顺序，进而排序整个数组，理论最优时间复杂度为 $O(n \log n)$ 。「非比较排序」不采用，时间复杂度可以达到 $O(n)$ ，但通用性相对较差。
+**是否基于比较**：「基于比较的排序」依赖于比较运算符（$<$ , $=$ , $>$）来判断元素的相对顺序，从而排序整个数组，理论最优时间复杂度为 $O(n \log n)$ 。而「非比较排序」不使用比较运算符，时间复杂度可达 $O(n)$ ，但其通用性相对较差。
 
 ## 理想排序算法
 
-**运行快、原地、稳定、正向自适应、通用性好**。显然，**目前没有发现具备以上所有特性的排序算法**，排序算法的选型使用取决于具体的数据特点与问题特征。
+**运行快、原地、稳定、正向自适应、通用性好**。显然，迄今为止尚未发现兼具以上所有特性的排序算法。因此，在选择排序算法时，需要根据具体的数据特点和问题需求来决定。
 
-接下来，我们将一起学习各种排序算法，并基于以上评价维度展开分析各个排序算法的优缺点。
+接下来，我们将共同学习各种排序算法，并基于上述评价维度对各个排序算法的优缺点进行分析。

docs/chapter_sorting/merge_sort.md

@@ -1,22 +1,20 @@
 # 归并排序
 
-「归并排序 Merge Sort」是算法中“分治思想”的典型体现，其有「划分」和「合并」两个阶段：
+「归并排序 Merge Sort」基于分治思想实现排序，包含“划分”和“合并”两个阶段：
 
-1. **划分阶段**：通过递归不断 **将数组从中点位置划分开**，将长数组的排序问题转化为短数组的排序问题；
-2. **合并阶段**：划分到子数组长度为 1 时，开始向上合并，不断将 **左、右两个短排序数组** 合并为 **一个长排序数组**，直至合并至原数组时完成排序；
+1. **划分阶段**：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题；
+2. **合并阶段**：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束；
 
 ![归并排序的划分与合并阶段](merge_sort.assets/merge_sort_overview.png)
 
 ## 算法流程
 
-**「递归划分」** 从顶至底递归地 **将数组从中点切为两个子数组**，直至长度为 1 ；
+“划分阶段”从顶至底递归地将数组从中点切为两个子数组，直至长度为 1 ；
 
 1. 计算数组中点 `mid` ，递归划分左子数组（区间 `[left, mid]` ）和右子数组（区间 `[mid + 1, right]` ）；
-2. 递归执行 `1.` 步骤，直至子数组区间长度为 1 时，终止递归划分；
+2. 递归执行步骤 `1.` ，直至子数组区间长度为 1 时，终止递归划分；
 
-**「回溯合并」** 从底至顶地将左子数组和右子数组合并为一个 **有序数组** ；
-
-需要注意，由于从长度为 1 的子数组开始合并，所以 **每个子数组都是有序的**。因此，合并任务本质是要 **将两个有序子数组合并为一个有序数组**。
+“合并阶段”从底至顶地将左子数组和右子数组合并为一个有序数组。需要注意的是，从长度为 1 的子数组开始合并，合并阶段中的每个子数组都是有序的。
 
 === "<1>"
     ![归并排序步骤](merge_sort.assets/merge_sort_step1.png)
@@ -48,10 +46,10 @@
 === "<10>"
     ![merge_sort_step10](merge_sort.assets/merge_sort_step10.png)
 
-观察发现，归并排序的递归顺序就是二叉树的「后序遍历」。
+观察发现，归并排序的递归顺序与二叉树的后序遍历相同，具体来看：
 
-- **后序遍历**：先递归左子树、再递归右子树、最后处理根节点。
-- **归并排序**：先递归左子树、再递归右子树、最后处理合并。
+- **后序遍历**：先递归左子树，再递归右子树，最后处理根节点。
+- **归并排序**：先递归左子数组，再递归右子数组，最后处理合并。
 
 === "Java"
 
@@ -131,30 +129,24 @@
     [class]{}-[func]{mergeSort}
     ```
 
-下面重点解释一下合并方法 `merge()` 的流程：
-
-1. 初始化一个辅助数组 `tmp` 暂存待合并区间 `[left, right]` 内的元素，后续通过覆盖原数组 `nums` 的元素来实现合并；
-2. 初始化指针 `i` , `j` , `k` 分别指向左子数组、右子数组、原数组的首元素；
-3. 循环判断 `tmp[i]` 和 `tmp[j]` 的大小，将较小的先覆盖至 `nums[k]` ，指针 `i` , `j` 根据判断结果交替前进（指针 `k` 也前进），直至两个子数组都遍历完，即可完成合并。
-
-合并方法 `merge()` 代码中的主要难点：
+合并方法 `merge()` 代码中的难点包括：
 
-- `nums` 的待合并区间为 `[left, right]` ，而因为 `tmp` 只复制了 `nums` 该区间元素，所以 `tmp` 对应区间为 `[0, right - left]` ，**需要特别注意代码中各个变量的含义**。
-- 判断 `tmp[i]` 和 `tmp[j]` 的大小的操作中，还 **需考虑当子数组遍历完成后的索引越界问题**，即 `i > leftEnd` 和 `j > rightEnd` 的情况，索引越界的优先级是最高的，例如如果左子数组已经被合并完了，那么不用继续判断，直接合并右子数组元素即可。
+- **在阅读代码时，需要特别注意各个变量的含义**。`nums` 的待合并区间为 `[left, right]` ，但由于 `tmp` 仅复制了 `nums` 该区间的元素，因此 `tmp` 对应区间为 `[0, right - left]` 。
+- 在比较 `tmp[i]` 和 `tmp[j]` 的大小时，**还需考虑子数组遍历完成后的索引越界问题**，即 `i > leftEnd` 和 `j > rightEnd` 的情况。索引越界的优先级是最高的，如果左子数组已经被合并完了，那么不需要继续比较，直接合并右子数组元素即可。
 
 ## 算法特性
 
-**时间复杂度 $O(n \log n)$** ：划分形成高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，总体使用 $O(n \log n)$ 时间。
+**时间复杂度 $O(n \log n)$** ：划分产生高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，因此总体时间复杂度为 $O(n \log n)$ 。
 
-**空间复杂度 $O(n)$** ：需借助辅助数组实现合并，使用 $O(n)$ 大小的额外空间；递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间，因此是“非原地排序”。
+**空间复杂度 $O(n)$** ：递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间；合并操作需要借助辅助数组实现，使用 $O(n)$ 大小的额外空间；因此是“非原地排序”。
 
-在合并时，不改变相等元素的次序，是“稳定排序”。
+在合并过程中，相等元素的次序保持不变，因此归并排序是“稳定排序”。
 
 ## 链表排序 *
 
-归并排序有一个很特别的优势，用于排序链表时有很好的性能表现，**空间复杂度可被优化至 $O(1)$** ，这是因为：
+归并排序在排序链表时具有显著优势，空间复杂度可以优化至 $O(1)$ ，原因如下：
 
-- 由于链表可仅通过改变指针来实现节点增删，因此“将两个短有序链表合并为一个长有序链表”无需使用额外空间，即回溯合并阶段不用像排序数组一样建立辅助数组 `tmp` ；
-- 通过使用「迭代」代替「递归划分」，可省去递归使用的栈帧空间；
+- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无需创建辅助链表。
+- 通过使用“迭代划分”替代“递归划分”，可省去递归使用的栈帧空间；
 
-> 详情参考：[148. 排序链表](https://leetcode-cn.com/problems/sort-list/solution/sort-list-gui-bing-pai-xu-lian-biao-by-jyd/)
+具体实现细节比较复杂，有兴趣的同学可以查阅相关资料进行学习。

docs/chapter_sorting/quick_sort.md

@@ -1,14 +1,14 @@
 # 快速排序
 
-「快速排序 Quick Sort」是一种基于“分治思想”的排序算法，速度很快、应用很广。
+「快速排序 Quick Sort」是一种基于分治思想的排序算法，运行高效，应用广泛。
 
-快速排序的核心操作为「哨兵划分」，其目标为：选取数组某个元素为 **基准数**，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。「哨兵划分」的实现流程为：
+快速排序的核心操作是「哨兵划分」，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。具体来说，哨兵划分的流程为：
 
-1. 以数组最左端元素作为基准数，初始化两个指针 `i` , `j` 指向数组两端；
-2. 设置一个循环，每轮中使用 `i` / `j` 分别寻找首个比基准数大 / 小的元素，并交换此两元素；
-3. 不断循环步骤 `2.` ，直至 `i` , `j` 相遇时跳出，最终把基准数交换至两个子数组的分界线；
+1. 选取数组最左端元素作为基准数，初始化两个指针 `i` 和 `j` 分别指向数组的两端；
+2. 设置一个循环，在每轮中使用 `i`（`j`）分别寻找第一个比基准数大（小）的元素，然后交换这两个元素；
+3. 循环执行步骤 `2.` ，直到 `i` 和 `j` 相遇时停止，最后将基准数交换至两个子数组的分界线；
 
-「哨兵划分」执行完毕后，原数组被划分成两个部分，即 **左子数组** 和 **右子数组**，且满足 **左子数组任意元素 < 基准数 < 右子数组任意元素**。因此，接下来我们只需要排序两个子数组即可。
+哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 $\leq$ 基准数 $\leq$ 右子数组任意元素”。因此，我们接下来只需对这两个子数组进行排序。
 
 === "<1>"
     ![哨兵划分步骤](quick_sort.assets/pivot_division_step1.png)
@@ -39,7 +39,7 @@
 
 !!! note "快速排序的分治思想"
 
-    哨兵划分的实质是将 **一个长数组的排序问题** 简化为 **两个短数组的排序问题**。
+    哨兵划分的实质是将一个较长数组的排序问题简化为两个较短数组的排序问题。
 
 === "Java"
 
@@ -117,11 +117,9 @@
 
 ## 算法流程
 
-1. 首先，对数组执行一次「哨兵划分」，得到待排序的 **左子数组** 和 **右子数组**；
-2. 接下来，对 **左子数组** 和 **右子数组** 分别 **递归执行**「哨兵划分」……
-3. 直至子数组长度为 1 时 **终止递归**，即可完成对整个数组的排序；
-
-观察发现，快速排序和「二分查找」的原理类似，都是以对数阶的时间复杂度来缩小处理区间。
+1. 首先，对原数组执行一次「哨兵划分」，得到待排序的左子数组和右子数组；
+2. 然后，对左子数组和右子数组分别递归执行「哨兵划分」；
+3. 持续递归，直至子数组长度为 1 时终止，从而完成整个数组的排序；
 
 ![快速排序流程](quick_sort.assets/quick_sort_overview.png)
 
@@ -187,29 +185,31 @@
 
 ## 算法特性
 
-**时间复杂度 $O(n \log n)$** ：平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
+**时间复杂度 $O(n \log n)$** ：在平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
 
-最差情况下，每轮哨兵划分操作都将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间，因此是“非稳定排序”。
+在最差情况下，每轮哨兵划分操作都将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间；因此快速排序是“自适应排序”。
 
-**空间复杂度 $O(n)$** ：输入数组完全倒序下，达到最差递归深度 $n$ 。由于未借助辅助数组空间，因此是“原地排序”。
+**空间复杂度 $O(n)$** ：在输入数组完全倒序的情况下，达到最差递归深度 $n$ 。由于未使用辅助数组，因此算法是“原地排序”。
 
-**非稳定排序**：哨兵划分最后一步可能会将基准数交换至相等元素的右边。
+在哨兵划分的最后一步，基准数可能会被交换至相等元素的右侧，因此是“非稳定排序”。
 
 ## 快排为什么快？
 
-从命名能够看出，快速排序在效率方面一定“有两把刷子”。快速排序的平均时间复杂度虽然与「归并排序」和「堆排序」一致，但实际 **效率更高**，这是因为：
+从名称上就能看出，快速排序在效率方面应该具有一定的优势。尽管快速排序的平均时间复杂度与「归并排序」和「堆排序」相同，但通常快速排序的效率更高，原因如下：
 
-- **出现最差情况的概率很低**：虽然快速排序的最差时间复杂度为 $O(n^2)$ ，不如归并排序，但绝大部分情况下，快速排序可以达到 $O(n \log n)$ 的复杂度。
-- **缓存使用效率高**：哨兵划分操作时，将整个子数组加载入缓存中，访问元素效率很高。而诸如「堆排序」需要跳跃式访问元素，因此不具有此特性。
-- **复杂度的常数系数低**：在提及的三种算法中，快速排序的 **比较**、**赋值**、**交换** 三种操作的总体数量最少（类似于「插入排序」快于「冒泡排序」的原因）。
+- **出现最差情况的概率很低**：虽然快速排序的最差时间复杂度为 $O(n^2)$ ，没有归并排序稳定，但在绝大多数情况下，快速排序能在 $O(n \log n)$ 的时间复杂度下运行。
+- **缓存使用效率高**：在执行哨兵划分操作时，系统可将整个子数组加载到缓存，因此访问元素的效率较高。而像「堆排序」这类算法需要跳跃式访问元素，从而缺乏这一特性。
+- **复杂度的常数系数低**：在上述三种算法中，快速排序的比较、赋值、交换等操作的总数量最少。这与「插入排序」比「冒泡排序」更快的原因类似。
 
 ## 基准数优化
 
-**普通快速排序在某些输入下的时间效率变差**。举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
+**快速排序在某些输入下的时间效率可能降低**。举一个极端例子，假设输入数组是完全倒序的，由于我们选择最左端元素作为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，导致左子数组长度为 $n - 1$ 、右子数组长度为 $0$ 。如此递归下去，每轮哨兵划分后的右子数组长度都为 $0$ ，分治策略失效，快速排序退化为「冒泡排序」。
+
+为了尽量避免这种情况发生，**我们可以优化哨兵划分中的基准数的选取策略**。例如，我们可以随机选取一个元素作为基准数。然而，如果运气不佳，每次都选到不理想的基准数，效率仍然不尽如人意。
 
-为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数**。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
+需要注意的是，编程语言通常生成的是“伪随机数”。如果我们针对伪随机数序列构建一个特定的测试样例，那么快速排序的效率仍然可能劣化。
 
-进一步地，我们可以在数组中选取 3 个候选元素（一般为数组的首、尾、中点元素），**并将三个候选元素的中位数作为基准数**，这样基准数“既不大也不小”的概率就大大提升了。当然，如果数组很长的话，我们也可以选取更多候选元素，来进一步提升算法的稳健性。采取该方法后，时间复杂度劣化至 $O(n^2)$ 的概率极低。
+为了进一步改进，我们可以在数组中选取三个候选元素（通常为数组的首、尾、中点元素），**并将这三个候选元素的中位数作为基准数**。这样一来，基准数“既不太小也不太大”的概率将大幅提升。当然，我们还可以选取更多候选元素，以进一步提高算法的稳健性。采用这种方法后，时间复杂度劣化至 $O(n^2)$ 的概率大大降低。
 
 === "Java"
 
@@ -293,9 +293,9 @@
 
 ## 尾递归优化
 
-**普通快速排序在某些输入下的空间效率变差**。仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
+**在某些输入下，快速排序可能占用空间较多**。以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 $0$ ，递归树的高度会达到 $n - 1$ ，此时需要占用 $O(n)$ 大小的栈帧空间。
 
-为了避免栈帧空间的累积，我们可以在每轮哨兵排序完成后，判断两个子数组的长度大小，仅递归排序较短的子数组。由于较短的子数组长度不会超过 $\frac{n}{2}$ ，因此这样做能保证递归深度不超过 $\log n$ ，即最差空间复杂度被优化至 $O(\log n)$ 。
+为了防止栈帧空间的累积，我们可以在每轮哨兵排序完成后，比较两个子数组的长度，**仅对较短的子数组进行递归**。由于较短子数组的长度不会超过 $\frac{n}{2}$ ，因此这种方法能确保递归深度不超过 $\log n$ ，从而将最差空间复杂度优化至 $O(\log n)$ 。
 
 === "Java"
 
@@ -361,8 +361,8 @@
 
     不行，当我们以最左端元素为基准数时，必须先“从右往左查找”再“从左往右查找”。这个结论有些反直觉，我们来剖析一下原因。
 
-    哨兵划分 `partition()` 的最后一步是交换 `nums[left]` 和 `nums[i]` ，完成交换后，基准数左边的元素都 `<=` 基准数，**这就要求最后一步交换前 `nums[left] >= nums[i]` 必须成立**。假设我们先“从左往右查找”，那么如果找不到比基准数更小的元素，**则会在 `i == j` 时跳出循环，此时可能 `nums[j] == nums[i] > nums[left]`** ；也就是说，此时最后一步交换操作会把一个比基准数更大的元素交换至数组最左端，导致哨兵划分失败。
+    哨兵划分 `partition()` 的最后一步是交换 `nums[left]` 和 `nums[i]` 。完成交换后，基准数左边的元素都 `<=` 基准数，**这就要求最后一步交换前 `nums[left] >= nums[i]` 必须成立**。假设我们先“从左往右查找”，那么如果找不到比基准数更小的元素，**则会在 `i == j` 时跳出循环，此时可能 `nums[j] == nums[i] > nums[left]`**。也就是说，此时最后一步交换操作会把一个比基准数更大的元素交换至数组最左端，导致哨兵划分失败。
 
-    举个例子，给定数组 `[0, 0, 0, 0, 1]` ，如果先“从左向右查找”，哨兵划分后数组为 `[1, 0, 0, 0, 0]` ，这个结果是不对的。
+    举个例子，给定数组 `[0, 0, 0, 0, 1]` ，如果先“从左向右查找”，哨兵划分后数组为 `[1, 0, 0, 0, 0]` ，这个结果是不正确的。
 
-    再深想一步，如果我们选择 `nums[right]` 为基准数，那么正好反过来，必须先“从左往右查找”。
+    再深入思考一下，如果我们选择 `nums[right]` 为基准数，那么正好反过来，必须先“从左往右查找”。

docs/chapter_sorting/radix_sort.md

@@ -1,28 +1,28 @@
 # 基数排序
 
-上节介绍的计数排序适用于数据量 $n$ 大但数据范围 $m$ 不大的情况。假设需要排序 $n = 10^6$ 个学号数据，学号是 $8$ 位数字，那么数据范围 $m = 10^8$ 很大，使用计数排序则需要开辟巨大的内存空间，而基数排序则可以避免这种情况。
+上一节我们介绍了计数排序，它适用于数据量 $n$ 较大但数据范围 $m$ 较小的情况。假设我们需要对 $n = 10^6$ 个学号进行排序，而学号是一个 $8$ 位数字，这意味着数据范围 $m = 10^8$ 非常大，使用计数排序需要分配大量内存空间，而基数排序可以避免这种情况。
 
-「基数排序 Radix Sort」主体思路与计数排序一致，也通过统计出现次数实现排序，**并在此基础上利用位与位之间的递进关系，依次对每一位执行排序**，从而获得排序结果。
+「基数排序 Radix Sort」的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序**，从而得到最终的排序结果。
 
 ## 算法流程
 
-以上述的学号数据为例，设数字最低位为第 $1$ 位、最高位为第 $8$ 位，基数排序的流程为：
+以学号数据为例，假设数字的最低位是第 $1$ 位，最高位是第 $8$ 位，基数排序的步骤如下：
 
 1. 初始化位数 $k = 1$ ；
-2. 对学号的第 $k$ 位执行「计数排序」，完成后，数据即按照第 $k$ 位从小到大排序；
-3. 将 $k$ 自增 $1$ ，并返回第 `2.` 步继续迭代，直至排序完所有位后结束；
+2. 对学号的第 $k$ 位执行「计数排序」。完成后，数据会根据第 $k$ 位从小到大排序；
+3. 将 $k$ 增加 $1$ ，然后返回步骤 `2.` 继续迭代，直到所有位都排序完成后结束；
 
 ![基数排序算法流程](radix_sort.assets/radix_sort_overview.png)
 
-下面来剖析代码实现。对于一个 $d$ 进制的数字 $x$ ，其第 $k$ 位 $x_k$ 的计算公式为
+下面来剖析代码实现。对于一个 $d$ 进制的数字 $x$ ，要获取其第 $k$ 位 $x_k$ ，可以使用以下计算公式：
 
 $$
 x_k = \lfloor\frac{x}{d^{k-1}}\rfloor \mod d
 $$
 
-其中 $\lfloor a \rfloor$ 代表对浮点数 $a$ 执行向下取整，$\mod d$ 代表对 $d$ 取余。学号数据的 $d = 10$ , $k \in [1, 8]$ 。
+其中 $\lfloor a \rfloor$ 表示对浮点数 $a$ 向下取整，而 $\mod d$ 表示对 $d$ 取余。对于学号数据，$d = 10$ 且 $k \in [1, 8]$ 。
 
-此外，我们需要小幅改动计数排序代码，使之可以根据数字第 $k$ 位执行排序。
+此外，我们需要小幅改动计数排序代码，使之可以根据数字的第 $k$ 位进行排序。
 
 === "Java"
 
@@ -126,12 +126,12 @@ $$
 
 !!! question "为什么从最低位开始排序？"
 
-    对于先后两轮排序，第二轮排序可能会覆盖第一轮排序的结果，比如第一轮认为 $a < b$ ，而第二轮认为 $a > b$ ，则第二轮会取代第一轮的结果。由于数字高位比低位的优先级更高，所以要先排序低位再排序高位。
+    在连续的排序轮次中，后一轮排序会覆盖前一轮排序的结果。举例来说，如果第一轮排序结果 $a < b$ ，而第二轮排序结果 $a > b$ ，那么第二轮的结果将取代第一轮的结果。由于数字的高位优先级高于低位，我们应该先排序低位再排序高位。
 
 ## 算法特性
 
-**时间复杂度 $O(n k)$** ：设数据量为 $n$ 、数据为 $d$ 进制、最大为 $k$ 位，则对某一位执行计数排序使用 $O(n + d)$ 时间，排序 $k$ 位使用 $O((n + d)k)$ 时间；一般情况下 $d$ 和 $k$ 都比较小，此时时间复杂度近似为 $O(n)$ 。
+**时间复杂度 $O(nk)$** ：设数据量为 $n$ 、数据为 $d$ 进制、最大位数为 $k$ ，则对某一位执行计数排序使用 $O(n + d)$ 时间，排序所有 $k$ 位使用 $O((n + d)k)$ 时间。通常情况下，$d$ 和 $k$ 都相对较小，时间复杂度趋向 $O(n)$ 。
 
-**空间复杂度 $O(n + d)$** ：与计数排序一样，借助了长度分别为 $n$ , $d$ 的数组 `res` 和 `counter` ，因此是“非原地排序”。
+**空间复杂度 $O(n + d)$** ：与计数排序相同，基数排序需要借助长度为 $n$ 和 $d$ 的数组 `res` 和 `counter` ，因此它是一种“非原地排序”。
 
-与计数排序一致，基数排序也是稳定排序。相比于计数排序，基数排序可适用于数值范围较大的情况，**但前提是数据必须可以被表示为固定位数的格式，且位数不能太大**。比如浮点数就不适合使用基数排序，因为其位数 $k$ 太大，可能时间复杂度 $O(nk) \gg O(n^2)$ 。
+基数排序与计数排序一样，都属于稳定排序。相较于计数排序，基数排序适用于数值范围较大的情况，**但前提是数据必须可以表示为固定位数的格式，且位数不能过大**。例如，浮点数不适合使用基数排序，因为其位数 $k$ 过大，可能导致时间复杂度 $O(nk) \gg O(n^2)$ 。

docs/chapter_sorting/summary.md

@@ -1,13 +1,14 @@
 # 小结
 
-- 冒泡排序通过交换相邻元素来实现排序。通过增加标志位实现提前返回，我们可将冒泡排序的最佳时间复杂度优化至 $O(N)$ 。
-- 插入排序每轮将待排序区间内元素插入至已排序区间的正确位置，从而实现排序。插入排序的时间复杂度虽为 $O(N^2)$ ，但因为总体操作少而很受欢迎，一般用于小数据量的排序工作。
-- 快速排序基于哨兵划分操作实现排序。在哨兵划分中，有可能每次都选取到最差的基准数，从而导致时间复杂度劣化至 $O(N^2)$ ，通过引入中位数基准数或随机基准数可大大降低劣化概率。尾递归方法可以有效减小递归深度，将空间复杂度优化至 $O(\log N)$ 。
-- 归并排序包含划分和合并两个阶段，是分而治之的标准体现。对于归并排序，排序数组需要借助辅助数组，空间复杂度为 $O(N)$ ；而排序链表的空间复杂度可以被优化至 $O(1)$ 。
-- 桶排序分为三步，数据分桶、桶内排序、合并结果，体现分治策略，适用于体量很大的数据。桶排序的难点在于数据的平均划分。
-- 计数排序是桶排序的一种特例，通过统计数据出现次数来实现排序；适用于数据量大但数据范围不大的情况，并且要求数据可以被转化为正整数。
-- 基数排序通过依次排序各位来实现数据排序，要求数据可以被表示为固定位数的数字。
+- 冒泡排序通过交换相邻元素来实现排序。通过添加一个标志位来实现提前返回，我们可以将冒泡排序的最佳时间复杂度优化到 $O(n)$ 。
+- 插入排序每轮将待排序区间内的元素插入到已排序区间的正确位置，从而完成排序。虽然插入排序的时间复杂度为 $O(n^2)$ ，但由于单元操作相对较少，它在小数据量的排序任务中非常受欢迎。
+- 快速排序基于哨兵划分操作实现排序。在哨兵划分中，有可能每次都选取到最差的基准数，导致时间复杂度劣化至 $O(n^2)$ 。引入中位数基准数或随机基准数可以降低这种劣化的概率。尾递归方法可以有效地减少递归深度，将空间复杂度优化到 $O(\log n)$ 。
+- 归并排序包括划分和合并两个阶段，典型地体现了分治策略。在归并排序中，排序数组需要创建辅助数组，空间复杂度为 $O(n)$ ；然而排序链表的空间复杂度可以优化至 $O(1)$ 。
+- 桶排序包含三个步骤：数据分桶、桶内排序和合并结果。它同样体现了分治策略，适用于数据体量很大的情况。桶排序的关键在于对数据进行平均分配。
+- 计数排序是桶排序的一个特例，它通过统计数据出现的次数来实现排序。计数排序适用于数据量大但数据范围有限的情况，并且要求数据能够转换为正整数。
+- 基数排序通过逐位排序来实现数据排序，要求数据能够表示为固定位数的数字。
 
 ![排序算法对比](summary.assets/sorting_algorithms_comparison.png)
 
 - 总体来看，我们追求运行快、稳定、原地、正向自适应性的排序。显然，如同其他数据结构与算法一样，同时满足这些条件的排序算法并不存在，我们需要根据问题特点来选择排序算法。
+- 总的来说，我们希望找到一种排序算法，具有高效率、稳定、原地以及正向自适应性等优点。然而，正如其他数据结构和算法一样，没有一种排序算法能够同时满足所有这些条件。在实际应用中，我们需要根据数据的特性来选择合适的排序算法。