Modify 。** to **。 for better visualization.

docs/chapter_array_and_linkedlist/array.md

@@ -14,7 +14,7 @@ comments: true
 
     观察上图，我们发现 **数组首元素的索引为 $0$** 。你可能会想，这并不符合日常习惯，首个元素的索引为什么不是 $1$ 呢，这不是更加自然吗？我认同你的想法，但请先记住这个设定，后面讲内存地址计算时，我会尝试解答这个问题。
 
-**数组有多种初始化写法。** 根据实际需要，选代码最短的那一种就好。
+**数组有多种初始化写法**。根据实际需要，选代码最短的那一种就好。
 
 === "Java"
 
@@ -83,7 +83,7 @@ comments: true
 
 ## 数组优点
 
-**在数组中访问元素非常高效。** 这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
+**在数组中访问元素非常高效**。这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
 
 ![array_memory_location_calculation](array.assets/array_memory_location_calculation.png)
 
@@ -195,7 +195,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 ## 数组缺点
 
-**数组在初始化后长度不可变。** 由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
+**数组在初始化后长度不可变**。由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
 
 === "Java"
 
@@ -317,7 +317,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
-**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
+**数组中插入或删除元素效率低下**。假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
 
 - **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
 - **丢失元素：** 由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
@@ -488,7 +488,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 ## 数组常用操作
 
-**数组遍历。** 以下介绍两种常用的遍历方法。
+**数组遍历**。以下介绍两种常用的遍历方法。
 
 === "Java"
 
@@ -611,7 +611,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
-**数组查找。** 通过遍历数组，查找数组内的指定元素，并输出对应索引。
+**数组查找**。通过遍历数组，查找数组内的指定元素，并输出对应索引。
 
 === "Java"
 
@@ -715,8 +715,8 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 ## 数组典型应用
 
-**随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
+**随机访问**。如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
 
-**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
+**二分查找**。例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
 
-**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
+**深度学习**。神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。

docs/chapter_array_and_linkedlist/linked_list.md

@@ -114,7 +114,7 @@ comments: true
 
 **尾结点指向什么？** 我们一般将链表的最后一个结点称为「尾结点」，其指向的是「空」，在 Java / C++ / Python 中分别记为 `null` / `nullptr` / `None` 。在不引起歧义下，本书都使用 `null` 来表示空。
 
-**链表初始化方法。** 建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。
+**链表初始化方法**。建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。
 
 !!! tip
 
@@ -248,7 +248,7 @@ comments: true
 
 ## 链表优点
 
-**在链表中，插入与删除结点的操作效率高。** 例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
+**在链表中，插入与删除结点的操作效率高**。例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
 
 ![linkedlist_insert_remove_node](linked_list.assets/linkedlist_insert_remove_node.png)
 
@@ -412,7 +412,7 @@ comments: true
 
 ## 链表缺点
 
-**链表访问结点效率低。** 上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。
+**链表访问结点效率低**。上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。
 
 === "Java"
 
@@ -520,11 +520,11 @@ comments: true
     }
     ```
 
-**链表的内存占用多。** 链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
+**链表的内存占用多**。链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
 
 ## 链表常用操作
 
-**遍历链表查找。** 遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
+**遍历链表查找**。遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
 
 === "Java"
 
@@ -649,11 +649,11 @@ comments: true
 
 ## 常见链表类型
 
-**单向链表。** 即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。
+**单向链表**。即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。
 
-**环形链表。** 如果我们令单向链表的尾结点指向头结点（即首尾相接），则得到一个环形链表。在环形链表中，我们可以将任意结点看作是头结点。
+**环形链表**。如果我们令单向链表的尾结点指向头结点（即首尾相接），则得到一个环形链表。在环形链表中，我们可以将任意结点看作是头结点。
 
-**双向链表。** 单向链表仅记录了一个方向的指针（引用），在双向链表的结点定义中，同时有指向下一结点（后继结点）和上一结点（前驱结点）的「指针（引用）」。双向链表相对于单向链表更加灵活，即可以朝两个方向遍历链表，但也需要占用更多的内存空间。
+**双向链表**。单向链表仅记录了一个方向的指针（引用），在双向链表的结点定义中，同时有指向下一结点（后继结点）和上一结点（前驱结点）的「指针（引用）」。双向链表相对于单向链表更加灵活，即可以朝两个方向遍历链表，但也需要占用更多的内存空间。
 
 === "Java"
 

docs/chapter_array_and_linkedlist/list.md

@@ -4,13 +4,13 @@ comments: true
 
 # 列表
 
-**由于长度不可变，数组的实用性大大降低。** 在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
+**由于长度不可变，数组的实用性大大降低**。在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
 
 为了解决此问题，诞生了一种被称为「列表 List」的数据结构。列表可以被理解为长度可变的数组，因此也常被称为「动态数组 Dynamic Array」。列表基于数组实现，继承了数组的优点，同时还可以在程序运行中实时扩容。在列表中，我们可以自由地添加元素，而不用担心超过容量限制。
 
 ## 列表常用操作
 
-**初始化列表。** 我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
+**初始化列表**。我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
 
 === "Java"
 
@@ -91,7 +91,7 @@ comments: true
     List<int> list = numbers.ToList();
     ```
 
-**访问与更新元素。** 列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
+**访问与更新元素**。列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
 
 === "Java"
 
@@ -169,7 +169,7 @@ comments: true
     list[1] = 0;  // 将索引 1 处的元素更新为 0
     ```
 
-**在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
+**在列表中添加、插入、删除元素**。相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
 
 === "Java"
 
@@ -317,7 +317,7 @@ comments: true
     list.RemoveAt(3);
     ```
 
-**遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
+**遍历列表**。与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
 
 === "Java"
 
@@ -437,7 +437,7 @@ comments: true
     }
     ```
 
-**拼接两个列表。** 再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
+**拼接两个列表**。再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
 
 === "Java"
 
@@ -502,7 +502,7 @@ comments: true
     list.AddRange(list1);  // 将列表 list1 拼接到 list 之后
     ```
 
-**排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
+**排序列表**。排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
 
 === "Java"
 

docs/chapter_computational_complexity/performance_evaluation.md

@@ -8,8 +8,8 @@ comments: true
 
 在开始学习算法之前，我们首先要想清楚算法的设计目标是什么，或者说，如何来评判算法的好与坏。整体上看，我们设计算法时追求两个层面的目标。
 
-1. **找到问题解法。** 算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
-2. **寻求最优解法。** 同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
+1. **找到问题解法**。算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
+2. **寻求最优解法**。同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
 
 换言之，在可以解决问题的前提下，算法效率则是主要评价维度，包括：
 
@@ -24,9 +24,9 @@ comments: true
 
 假设我们现在有算法 A 和 算法 B ，都能够解决同一问题，现在需要对比两个算法之间的效率。我们能够想到的最直接的方式，就是找一台计算机，把两个算法都完整跑一遍，并监控记录运行时间和内存占用情况。这种评估方式能够反映真实情况，但是也存在很大的硬伤。
 
-**难以排除测试环境的干扰因素。** 硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
+**难以排除测试环境的干扰因素**。硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
 
-**展开完整测试非常耗费资源。** 随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
+**展开完整测试非常耗费资源**。随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
 
 ### 理论估算
 
@@ -34,7 +34,7 @@ comments: true
 
 **复杂度分析评估随着输入数据量的增长，算法的运行时间和占用空间的增长趋势** 。根据时间和空间两方面，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
 
-**复杂度分析克服了实际测试方法的弊端。** 一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
+**复杂度分析克服了实际测试方法的弊端**。一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
 
 ## 复杂度分析的重要性
 

docs/chapter_computational_complexity/space_complexity.md

@@ -208,8 +208,8 @@ comments: true
 
 **最差空间复杂度中的“最差”有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。
 
-- **以最差输入数据为准。** 当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
-- **以算法运行过程中的峰值内存为准。** 程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
+- **以最差输入数据为准**。当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
+- **以算法运行过程中的峰值内存为准**。程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
 
 === "Java"
 
@@ -301,7 +301,7 @@ 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"
 

docs/chapter_computational_complexity/space_time_tradeoff.md

@@ -6,7 +6,7 @@ comments: true
 
 理想情况下，我们希望算法的时间复杂度和空间复杂度都能够达到最优，而实际上，同时优化时间复杂度和空间复杂度是非常困难的。
 
-**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然。** 我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。
+**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然**。我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。
 
 大多数情况下，时间都是比空间更宝贵的，只要空间复杂度不要太离谱、能接受就行，**因此以空间换时间最为常用**。
 

docs/chapter_computational_complexity/time_complexity.md

@@ -153,7 +153,7 @@ $$
     }
     ```
 
-但实际上， **统计算法的运行时间既不合理也不现实。** 首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。
+但实际上， **统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。
 
 ## 统计时间增长趋势
 
@@ -363,11 +363,11 @@ $$
 
 相比直接统计算法运行时间，时间复杂度分析的做法有什么好处呢？以及有什么不足？
 
-**时间复杂度可以有效评估算法效率。** 算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。
+**时间复杂度可以有效评估算法效率**。算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。
 
-**时间复杂度的推算方法更加简便。** 在时间复杂度分析中，我们可以将统计「计算操作的运行时间」简化为统计「计算操作的数量」，这是因为，无论是运行平台还是计算操作类型，都与算法运行时间的增长趋势无关。因而，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”，这样的简化做法大大降低了估算难度。
+**时间复杂度的推算方法更加简便**。在时间复杂度分析中，我们可以将统计「计算操作的运行时间」简化为统计「计算操作的数量」，这是因为，无论是运行平台还是计算操作类型，都与算法运行时间的增长趋势无关。因而，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”，这样的简化做法大大降低了估算难度。
 
-**时间复杂度也存在一定的局限性。** 比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。对于以上情况，我们很难仅凭时间复杂度来判定算法效率高低。然而，即使存在这些问题，计算复杂度仍然是评判算法效率的最有效且常用的方法。
+**时间复杂度也存在一定的局限性**。比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。对于以上情况，我们很难仅凭时间复杂度来判定算法效率高低。然而，即使存在这些问题，计算复杂度仍然是评判算法效率的最有效且常用的方法。
 
 ## 函数渐近上界
 
@@ -538,9 +538,9 @@ $T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得
 
 对着代码，从上到下一行一行地计数即可。然而，**由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数偷懒技巧：
 
-1. **跳过数量与 $n$ 无关的操作。** 因为他们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。
-2. **省略所有系数。** 例如，循环 $2n$ 次、$5n + 1$ 次、……，都可以化简记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度也不产生影响。
-3. **循环嵌套时使用乘法。** 总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
+1. **跳过数量与 $n$ 无关的操作**。因为他们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。
+2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次、……，都可以化简记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度也不产生影响。
+3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
 
 根据以下示例，使用上述技巧前、后的统计结果分别为
 
@@ -1004,7 +1004,7 @@ $$
 
 !!! tip
 
-    **数据大小 $n$ 是根据输入数据的类型来确定的。** 比如，在上述示例中，我们直接将 $n$ 看作输入数据大小；以下遍历数组示例中，数据大小 $n$ 为数组的长度。
+    **数据大小 $n$ 是根据输入数据的类型来确定的**。比如，在上述示例中，我们直接将 $n$ 看作输入数据大小；以下遍历数组示例中，数据大小 $n$ 为数组的长度。
 
 === "Java"
 
@@ -2308,7 +2308,7 @@ $$
 
 ## 最差、最佳、平均时间复杂度
 
-**某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关。** 举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
+**某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关**。举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
 
 - 当 `nums = [?, ?, ..., 1]`，即当末尾元素是 $1$ 时，则需完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** ；
 - 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** ；

docs/chapter_data_structure/classification_of_data_structure.md

@@ -8,7 +8,7 @@ comments: true
 
 ## 逻辑结构：线性与非线性
 
-**「逻辑结构」反映了数据之间的逻辑关系。** 数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
+**「逻辑结构」反映了数据之间的逻辑关系**。数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
 
 我们一般将逻辑结构分为「线性」和「非线性」两种。“线性”这个概念很直观，即表明数据在逻辑关系上是排成一条线的；而如果数据之间的逻辑关系是非线形的（例如是网状或树状的），那么就是非线性数据结构。
 
@@ -25,13 +25,13 @@ comments: true
 
     若感到阅读困难，建议先看完下个章节「数组与链表」，再回过头来理解物理结构的含义。
 
-**「物理结构」反映了数据在计算机内存中的存储方式。** 从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
+**「物理结构」反映了数据在计算机内存中的存储方式**。从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
 
 ![classification_phisical_structure](classification_of_data_structure.assets/classification_phisical_structure.png)
 
 <p align="center"> Fig. 连续空间存储与离散空间存储 </p>
 
-**所有数据结构都是基于数组、或链表、或两者组合实现的。** 例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
+**所有数据结构都是基于数组、或链表、或两者组合实现的**。例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
 
 - **基于数组可实现：** 栈、队列、堆、哈希表、矩阵、张量（维度 $\geq 3$ 的数组）等；
 - **基于链表可实现：** 栈、队列、堆、哈希表、树、图等；

docs/chapter_data_structure/data_and_memory.md

@@ -128,12 +128,12 @@ comments: true
 
 在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度更快，但容量较小（通常为 GB 级别）。
 
-**算法运行中，相关数据都被存储在内存中。** 下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
+**算法运行中，相关数据都被存储在内存中**。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
 
-**系统通过「内存地址 Memory Location」来访问目标内存位置的数据。** 计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
+**系统通过「内存地址 Memory Location」来访问目标内存位置的数据**。计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
 
 ![computer_memory_location](data_and_memory.assets/computer_memory_location.png)
 
 <p align="center"> Fig. 内存条、内存空间、内存地址 </p>
 
-**内存资源是设计数据结构与算法的重要考虑因素。** 内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。
+**内存资源是设计数据结构与算法的重要考虑因素**。内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。

docs/chapter_heap/heap.md

@@ -0,0 +1,32 @@
+# 堆
+
+「堆 Heap」是一种特殊的树状数据结构，并且是一颗「完全二叉树」。堆主要分为两种：
+
+- 「大顶堆 Max Heap」，任意父结点的值 > 其子结点的值，因此根结点的值最大；
+- 「小顶堆 Min Heap」，任意父结点的值 < 其子结点的值，因此根结点的值最小；
+
+（图）
+
+!!! tip ""
+
+    大顶堆和小顶堆的定义、性质、操作本质上是一样的。区别只是大顶堆在求最大值，小顶堆在求最小值。在下文中，我们将统一用「大顶堆」来举例，「小顶堆」的用法与实现可以简单地将所有 $>$ ($<$) 替换为 $<$ ($>$) 即可。
+
+## 堆常用操作
+
+堆的初始化。
+
+获取堆顶元素。
+
+添加与删除元素。
+
+## 堆的实现
+
+在二叉树章节中，我们讲过二叉树的数组表示方法，并且提到完全二叉树非常适合用数组来表示，因此我们一般使用「数组」来存储「堆」。
+
+
+
+## 堆常见应用
+
+- 优先队列。
+- 堆排序。
+- 获取数据 Top K 大（小）元素。

docs/chapter_introduction/algorithms_are_everywhere.md

@@ -6,13 +6,13 @@ comments: true
 
 听到“算法”这个词，我们一般会联想到数学。但实际上，大多数算法并不包含复杂的数学，而更像是在考察基本逻辑，而这些逻辑在我们日常生活中处处可见。
 
-在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中。** 接下来，我将介绍两个具体例子来佐证。
+在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中**。接下来，我将介绍两个具体例子来佐证。
 
-**例一：拼积木。** 一套积木，除了有许多部件之外，还会附送详细的拼装说明书。我们按照说明书上一步步操作，即可拼出复杂的积木模型。
+**例一：拼积木**。一套积木，除了有许多部件之外，还会附送详细的拼装说明书。我们按照说明书上一步步操作，即可拼出复杂的积木模型。
 
 如果从数据结构与算法的角度看，大大小小的「积木」就是数据结构，而「拼装说明书」上的一系列步骤就是算法。
 
-**例二：查字典。** 在字典中，每个汉字都有一个对应的拼音，而字典是按照拼音的英文字母表顺序排列的。假设需要在字典中查询任意一个拼音首字母为 $r$ 的字，一般我们会这样做：
+**例二：查字典**。在字典中，每个汉字都有一个对应的拼音，而字典是按照拼音的英文字母表顺序排列的。假设需要在字典中查询任意一个拼音首字母为 $r$ 的字，一般我们会这样做：
 
 1. 打开字典大致一半页数的位置，查看此页的首字母是什么（假设为 $m$ ）；
 2. 由于在英文字母表中 $r$ 在 $m$ 的后面，因此应排除字典前半部分，查找范围仅剩后半部分；

docs/chapter_preface/about_the_book.md

@@ -199,19 +199,19 @@ comments: true
 
 ??? abstract "默认折叠，可以跳过"
 
-    **以实践为主。** 我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。
+    **以实践为主**。我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。
     
     本书的理论部分占少量篇幅，主要分为两类：一是基础且必要的概念知识，以培养读者对于算法的感性认识；二是重要的分类、对比或总结，这是为了帮助你站在更高视角俯瞰各个知识点，形成连点成面的效果。
     
     实践部分主要由示例和代码组成。代码配有简要注释，复杂示例会尽可能地使用视觉化的形式呈现。我强烈建议读者对照着代码自己敲一遍，如果时间有限，也至少逐行读、复制并运行一遍，配合着讲解将代码吃透。
     
-    **视觉化学习。** 信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
+    **视觉化学习**。信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
     
     近两年，短视频成为最受欢迎的信息媒介，可以在短时间内将高密度的信息“灌”给我们，有着极其舒适的观看体验。阅读则不然，读者与书本之间天然存在一种“疏离感”，我们看书会累、会走神、会停下来想其他事、会划下喜欢的句子、会思考某一片段的含义，这种疏离感给了读者与书本之间对话的可能，拓宽了想象空间。
     
     本书作为一本入门教材，希望可以保有书本的“慢节奏”，但也会避免与读者产生过多“疏离感”，而是努力将知识完整清晰地推送到你聪明的小脑袋瓜中。我将采用视觉化的方式（例如配图、动画），尽我可能清晰易懂地讲解复杂概念和抽象示例。
     
-    **内容精简化。** 大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
+    **内容精简化**。大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
     
     引入一些生活案例或趣味内容，非常适合作为知识点的引子或者解释的补充，但当融入过多额外元素时，内容会稍显冗长，也许反而使读者容易迷失、抓不住重点，这也是本书需要避免的。
     

docs/chapter_preface/suggestions.md

@@ -54,10 +54,10 @@ git clone https://github.com/krahets/hello-algo.git
 
 ## 算法学习“三步走”
 
-**第一阶段，算法入门，也正是本书的定位。** 熟悉各种数据结构的特点、用法，学习各种算法的工作原理、用途、效率等。
+**第一阶段，算法入门，也正是本书的定位**。熟悉各种数据结构的特点、用法，学习各种算法的工作原理、用途、效率等。
 
-**第二阶段，刷算法题。** 可以先从热门题单开刷，推荐 [剑指 Offer](https://leetcode.cn/problem-list/xb9nqhhg/)、[LeetCode 热题 HOT 100](https://leetcode.cn/problem-list/2cktkvj/) ，先积累至少 100 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。
+**第二阶段，刷算法题**。可以先从热门题单开刷，推荐 [剑指 Offer](https://leetcode.cn/problem-list/xb9nqhhg/)、[LeetCode 热题 HOT 100](https://leetcode.cn/problem-list/2cktkvj/) ，先积累至少 100 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。
 
-**第三阶段，搭建知识体系。** 在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
+**第三阶段，搭建知识体系**。在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
 
 ![learning_route](suggestions.assets/learning_route.png)

docs/chapter_searching/binary_search.md

@@ -470,11 +470,11 @@ $$
 
 二分查找效率很高，体现在：
 
-- **二分查找时间复杂度低。** 对数阶在数据量很大时具有巨大优势，例如，当数据大小 $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/linear_search.md

@@ -246,6 +246,6 @@ comments: true
 
 ## 优点与缺点
 
-**线性查找的通用性极佳。** 由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
+**线性查找的通用性极佳**。由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
 
-**线性查找的时间复杂度太高。** 在数据量 $n$ 很大时，查找效率很低。
+**线性查找的时间复杂度太高**。在数据量 $n$ 很大时，查找效率很低。

docs/chapter_sorting/quick_sort.md

@@ -383,7 +383,7 @@ comments: true
 
 ## 基准数优化
 
-**普通快速排序在某些输入下的时间效率变差。** 举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$ 、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
+**普通快速排序在某些输入下的时间效率变差**。举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$ 、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
 
 为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数** 。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
 
@@ -576,7 +576,7 @@ comments: true
 
 ## 尾递归优化
 
-**普通快速排序在某些输入下的空间效率变差。** 仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
+**普通快速排序在某些输入下的空间效率变差**。仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
 
 为了避免栈帧空间的累积，我们可以在每轮哨兵排序完成后，判断两个子数组的长度大小，仅递归排序较短的子数组。由于较短的子数组长度不会超过 $\frac{n}{2}$ ，因此这样做能保证递归深度不超过 $\log n$ ，即最差空间复杂度被优化至 $O(\log n)$ 。
 

docs/chapter_stack_and_queue/deque.md

@@ -12,7 +12,7 @@ comments: true
 
 ## 双向队列常用操作
 
-双向队列的常用操作见下表，方法名需根据编程语言设定来具体确定。
+双向队列的常用操作见下表（方法命名以 Java 为例）。
 
 <p align="center"> Table. 双向队列的常用操作 </p>
 
@@ -38,25 +38,25 @@ comments: true
     ```java title="deque.java"
     /* 初始化双向队列 */
     Deque<Integer> deque = new LinkedList<>();
-
+    
     /* 元素入队 */
     deque.offerLast(2);   // 添加至队尾
     deque.offerLast(5);
     deque.offerLast(4);
     deque.offerFirst(3);  // 添加至队首
     deque.offerFirst(1);
-
+    
     /* 访问元素 */
     int peekFirst = deque.peekFirst();  // 队首元素
     int peekLast = deque.peekLast();    // 队尾元素
-
+    
     /* 元素出队 */
     int pollFirst = deque.pollFirst();  // 队首元素出队
     int pollLast = deque.pollLast();    // 队尾元素出队
-
+    
     /* 获取双向队列的长度 */
     int size = deque.size();
-
+    
     /* 判断双向队列是否为空 */
     boolean isEmpty = deque.isEmpty();
     ```
@@ -66,25 +66,25 @@ comments: true
     ```cpp title="deque.cpp"
     /* 初始化双向队列 */
     deque<int> deque;
-
+    
     /* 元素入队 */
     deque.push_back(2);   // 添加至队尾
     deque.push_back(5);
     deque.push_back(4);
     deque.push_front(3);  // 添加至队首
     deque.push_front(1);
-
+    
     /* 访问元素 */
     int front = deque.front(); // 队首元素
     int back = deque.back();   // 队尾元素
-
+    
     /* 元素出队 */
     deque.pop_front();  // 队首元素出队
     deque.pop_back();   // 队尾元素出队
-
+    
     /* 获取双向队列的长度 */
     int size = deque.size();
-
+    
     /* 判断双向队列是否为空 */
     bool empty = deque.empty();
     ```
@@ -94,25 +94,25 @@ comments: true
     ```python title="deque.py"
     """ 初始化双向队列 """
     duque = deque()
-
+    
     """ 元素入队 """
     duque.append(2)      # 添加至队尾
     duque.append(5)
     duque.append(4)
     duque.appendleft(3)  # 添加至队首
     duque.appendleft(1)
-
+    
     """ 访问元素 """
     front = duque[0]  # 队首元素
     rear = duque[-1]  # 队尾元素
-
+    
     """ 元素出队 """
     pop_front = duque.popleft()  # 队首元素出队
     pop_rear = duque.pop()       # 队尾元素出队
-
+    
     """ 获取双向队列的长度 """
     size = len(duque)
-
+    
     """ 判断双向队列是否为空 """
     is_empty = len(duque) == 0
     ```
@@ -123,25 +123,25 @@ comments: true
     /* 初始化双向队列 */
     // 在 Go 中，将 list 作为双向队列使用
     deque := list.New()
-
+    
     /* 元素入队 */
     deque.PushBack(2)      // 添加至队尾
     deque.PushBack(5)
     deque.PushBack(4)
     deque.PushFront(3)     // 添加至队首
     deque.PushFront(1)
-
+    
     /* 访问元素 */
     front := deque.Front() // 队首元素
     rear := deque.Back()   // 队尾元素
-
+    
     /* 元素出队 */
     deque.Remove(front)    // 队首元素出队
     deque.Remove(rear)     // 队尾元素出队
-
+    
     /* 获取双向队列的长度 */
     size := deque.Len()
-
+    
     /* 判断双向队列是否为空 */
     isEmpty := deque.Len() == 0
     ```
@@ -149,19 +149,19 @@ comments: true
 === "JavaScript"
 
     ```js title="deque.js"
-
+    
     ```
 
 === "TypeScript"
 
     ```typescript title="deque.ts"
-
+    
     ```
 
 === "C"
 
     ```c title="deque.c"
-
+    
     ```
 
 === "C#"
@@ -170,25 +170,25 @@ comments: true
     /* 初始化双向队列 */
     // 在 C# 中，将链表 LinkedList 看作双向队列来使用
     LinkedList<int> deque = new LinkedList<int>();
-
+    
     /* 元素入队 */
     deque.AddLast(2);   // 添加至队尾
     deque.AddLast(5);
     deque.AddLast(4);
     deque.AddFirst(3);  // 添加至队首
     deque.AddFirst(1);
-
+    
     /* 访问元素 */
     int peekFirst = deque.First.Value;  // 队首元素
     int peekLast = deque.Last.Value;    // 队尾元素
-
+    
     /* 元素出队 */
     deque.RemoveFirst();  // 队首元素出队
     deque.RemoveLast();   // 队尾元素出队
-
+    
     /* 获取双向队列的长度 */
     int size = deque.Count;
-
+    
     /* 判断双向队列是否为空 */
     bool isEmpty = deque.Count == 0;
     ```

docs/chapter_stack_and_queue/queue.md

@@ -14,7 +14,7 @@ comments: true
 
 ## 队列常用操作
 
-队列的常用操作见下表，方法命名需根据编程语言的设定来具体确定。
+队列的常用操作见下表（方法命名以 Java 为例）。
 
 <p align="center"> Table. 队列的常用操作 </p>
 
@@ -37,23 +37,23 @@ comments: true
     ```java title="queue.java"
     /* 初始化队列 */
     Queue<Integer> queue = new LinkedList<>();
-
+    
     /* 元素入队 */
     queue.offer(1);
     queue.offer(3);
     queue.offer(2);
     queue.offer(5);
     queue.offer(4);
-
+    
     /* 访问队首元素 */
     int peek = queue.peek();
-
+    
     /* 元素出队 */
     int poll = queue.poll();
-
+    
     /* 获取队列的长度 */
     int size = queue.size();
-
+    
     /* 判断队列是否为空 */
     boolean isEmpty = queue.isEmpty();
     ```
@@ -91,23 +91,23 @@ comments: true
     # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
     # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
     que = collections.deque()
-
+    
     """ 元素入队 """
     que.append(1)
     que.append(3)
     que.append(2)
     que.append(5)
     que.append(4)
-
+    
     """ 访问队首元素 """
     front = que[0];
-
+    
     """ 元素出队 """
     pop = que.popleft()
-
+    
     """ 获取队列的长度 """
     size = len(que)
-
+    
     """ 判断队列是否为空 """
     is_empty = len(que) == 0
     ```
@@ -118,24 +118,24 @@ comments: true
     /* 初始化队列 */
     // 在 Go 中，将 list 作为队列来使用
     queue := list.New()
-
+    
     /* 元素入队 */
     queue.PushBack(1)
     queue.PushBack(3)
     queue.PushBack(2)
     queue.PushBack(5)
     queue.PushBack(4)
-
+    
     /* 访问队首元素 */
     peek := queue.Front()
-
+    
     /* 元素出队 */
     poll := queue.Front()
     queue.Remove(poll)
-
+    
     /* 获取队列的长度 */
     size := queue.Len()
-
+    
     /* 判断队列是否为空 */
     isEmpty := queue.Len() == 0
     ```
@@ -146,24 +146,24 @@ comments: true
     /* 初始化队列 */
     // JavaScript 没有内置的队列，可以把 Array 当作队列来使用
     const queue = [];
-
+    
     /* 元素入队 */
     queue.push(1);
     queue.push(3);
     queue.push(2);
     queue.push(5);
     queue.push(4);
-
+    
     /* 访问队首元素 */
     const peek = queue[0];
-
+    
     /* 元素出队 */
     // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
     const poll = queue.shift();
-
+    
     /* 获取队列的长度 */
     const size = queue.length;
-
+    
     /* 判断队列是否为空 */
     const empty = queue.length === 0;
     ```
@@ -174,24 +174,24 @@ comments: true
     /* 初始化队列 */
     // TypeScript 没有内置的队列，可以把 Array 当作队列来使用 
     const queue: number[] = [];
-
+    
     /* 元素入队 */
     queue.push(1);
     queue.push(3);
     queue.push(2);
     queue.push(5);
     queue.push(4);
-
+    
     /* 访问队首元素 */
     const peek = queue[0];
-
+    
     /* 元素出队 */
     // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
     const poll = queue.shift();
-
+    
     /* 获取队列的长度 */
     const size = queue.length;
-
+    
     /* 判断队列是否为空 */
     const empty = queue.length === 0;
     ```
@@ -199,7 +199,7 @@ comments: true
 === "C"
 
     ```c title="queue.c"
-
+    
     ```
 
 === "C#"
@@ -207,23 +207,23 @@ comments: true
     ```csharp title="queue.cs"
     /* 初始化队列 */
     Queue<int> queue = new();
-
+    
     /* 元素入队 */
     queue.Enqueue(1);
     queue.Enqueue(3);
     queue.Enqueue(2);
     queue.Enqueue(5);
     queue.Enqueue(4);
-
+    
     /* 访问队首元素 */
     int peek = queue.Peek();
-
+    
     /* 元素出队 */
     int poll = queue.Dequeue();
-
+    
     /* 获取队列的长度 */
     int size = queue.Count();
-
+    
     /* 判断队列是否为空 */
     bool isEmpty = queue.Count() == 0;
     ```
@@ -243,7 +243,7 @@ comments: true
     class LinkedListQueue {
         private ListNode front, rear;  // 头结点 front ，尾结点 rear 
         private int queSize = 0;
-
+    
         public LinkedListQueue() {
             front = null;
             rear = null;
@@ -296,7 +296,7 @@ comments: true
     private:
         ListNode *front, *rear;  // 头结点 front ，尾结点 rear 
         int queSize;
-
+    
     public:
         LinkedListQueue() {
             front = nullptr;
@@ -355,15 +355,15 @@ comments: true
             self.__front = None  # 头结点 front
             self.__rear = None   # 尾结点 rear
             self.__size = 0
-
+    
         """ 获取队列的长度 """
         def size(self):
             return self.__size
-
+    
         """ 判断队列是否为空 """
         def is_empty(self):
             return not self.__front
-
+    
         """ 入队 """
         def push(self, num):
             # 尾结点后添加 num
@@ -377,7 +377,7 @@ comments: true
                 self.__rear.next = node
                 self.__rear = node
             self.__size += 1
-
+    
         """ 出队 """
         def poll(self):
             num = self.peek()
@@ -385,7 +385,7 @@ comments: true
             self.__front = self.__front.next
             self.__size -= 1
             return num
-
+    
         """ 访问队首元素 """
         def peek(self):
             if self.size() == 0:
@@ -548,7 +548,7 @@ comments: true
 === "C"
 
     ```c title="linkedlist_queue.c"
-
+    
     ```
 
 === "C#"
@@ -630,7 +630,7 @@ comments: true
         private int[] nums;     // 用于存储队列元素的数组
         private int front = 0;  // 头指针，指向队首
         private int rear = 0;   // 尾指针，指向队尾 + 1
-
+    
         public ArrayQueue(int capacity) {
             // 初始化数组
             nums = new int[capacity];
@@ -686,7 +686,7 @@ comments: true
         int cap;        // 队列容量
         int front = 0;  // 头指针，指向队首
         int rear = 0;   // 尾指针，指向队尾 + 1
-
+    
     public:
         ArrayQueue(int capacity) {
             // 初始化数组
@@ -741,20 +741,20 @@ comments: true
             self.__nums = [0] * size  # 用于存储队列元素的数组
             self.__front = 0             # 头指针，指向队首
             self.__rear = 0              # 尾指针，指向队尾 + 1
-
+    
         """ 获取队列的容量 """
         def capacity(self):
             return len(self.__nums)
-
+    
         """ 获取队列的长度 """
         def size(self):
             # 由于将数组看作为环形，可能 rear < front ，因此需要取余数
             return (self.capacity() + self.__rear - self.__front) % self.capacity()
-
+    
         """ 判断队列是否为空 """
         def is_empty(self):
             return (self.__rear - self.__front) == 0
-
+    
         """ 入队 """
         def push(self, val):
             if self.size() == self.capacity():
@@ -764,21 +764,21 @@ comments: true
             self.__nums[self.__rear] = val
             # 尾指针向后移动一位，越过尾部后返回到数组头部
             self.__rear = (self.__rear + 1) % self.capacity()
-
+    
         """ 出队 """
         def poll(self):
             num = self.peek()
             # 队头指针向后移动一位，若越过尾部则返回到数组头部
             self.__front = (self.__front + 1) % self.capacity()
             return num
-
+    
         """ 访问队首元素 """
         def peek(self):
             if self.is_empty():
                 print("队列为空")
                 return False
             return self.__nums[self.__front]
-
+    
         """ 返回列表用于打印 """
         def to_list(self):
             res = [0] * self.size()
@@ -950,7 +950,7 @@ comments: true
 === "C"
 
     ```c title="array_queue.c"
-
+    
     ```
 
 === "C#"
@@ -1017,5 +1017,5 @@ comments: true
 
 ## 队列典型应用
 
-- **淘宝订单。** 购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
-- **各种待办事项。** 例如打印机的任务队列、餐厅的出餐队列等等。
+- **淘宝订单**。购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
+- **各种待办事项**。例如打印机的任务队列、餐厅的出餐队列等等。

docs/chapter_stack_and_queue/stack.md

@@ -16,7 +16,7 @@ comments: true
 
 ## 栈常用操作
 
-栈的常用操作见下表，方法名需根据编程语言设定来具体确定。
+栈的常用操作见下表（方法命名以 Java 为例）。
 
 <p align="center"> Table. 栈的常用操作 </p>
 
@@ -40,23 +40,23 @@ comments: true
     /* 初始化栈 */
     // 在 Java 中，推荐将 LinkedList 当作栈来使用
     LinkedList<Integer> stack = new LinkedList<>();
-
+    
     /* 元素入栈 */
     stack.addLast(1);
     stack.addLast(3);
     stack.addLast(2);
     stack.addLast(5);
     stack.addLast(4);
-
+    
     /* 访问栈顶元素 */
     int peek = stack.peekLast();
-
+    
     /* 元素出栈 */
     int pop = stack.removeLast();
-
+    
     /* 获取栈的长度 */
     int size = stack.size();
-
+    
     /* 判断是否为空 */
     boolean isEmpty = stack.isEmpty();
     ```
@@ -66,23 +66,23 @@ comments: true
     ```cpp title="stack.cpp"
     /* 初始化栈 */
     stack<int> stack;
-
+    
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-
+    
     /* 访问栈顶元素 */
     int top = stack.top();
-
+    
     /* 元素出栈 */
     stack.pop();
-
+    
     /* 获取栈的长度 */
     int size = stack.size();
-
+    
     /* 判断是否为空 */
     bool empty = stack.empty();
     ```
@@ -93,23 +93,23 @@ comments: true
     """ 初始化栈 """
     # Python 没有内置的栈类，可以把 List 当作栈来使用 
     stack = []
-
+    
     """ 元素入栈 """
     stack.append(1)
     stack.append(3)
     stack.append(2)
     stack.append(5)
     stack.append(4)
-
+    
     """ 访问栈顶元素 """
     peek = stack[-1]
-
+    
     """ 元素出栈 """
     pop = stack.pop()
-
+    
     """ 获取栈的长度 """
     size = len(stack)
-
+    
     """ 判断是否为空 """
     is_empty = len(stack) == 0
     ```
@@ -120,24 +120,24 @@ comments: true
     /* 初始化栈 */
     // 在 Go 中，推荐将 Slice 当作栈来使用
     var stack []int
-
+    
     /* 元素入栈 */
     stack = append(stack, 1)
     stack = append(stack, 3)
     stack = append(stack, 2)
     stack = append(stack, 5)
     stack = append(stack, 4)
-
+    
     /* 访问栈顶元素 */
     peek := stack[len(stack)-1]
-
+    
     /* 元素出栈 */
     pop := stack[len(stack)-1]
     stack = stack[:len(stack)-1]
-
+    
     /* 获取栈的长度 */
     size := len(stack)
-
+    
     /* 判断是否为空 */
     isEmpty := len(stack) == 0
     ```
@@ -148,23 +148,23 @@ comments: true
     /* 初始化栈 */
     // Javascript 没有内置的栈类，可以把 Array 当作栈来使用 
     const stack = [];
-
+    
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-
+    
     /* 访问栈顶元素 */
     const peek = stack[stack.length-1];
-
+    
     /* 元素出栈 */
     const pop = stack.pop();
-
+    
     /* 获取栈的长度 */
     const size = stack.length;
-
+    
     /* 判断是否为空 */
     const is_empty = stack.length === 0;
     ```
@@ -175,23 +175,23 @@ comments: true
     /* 初始化栈 */
     // Typescript 没有内置的栈类，可以把 Array 当作栈来使用 
     const stack: number[] = [];
-
+    
     /* 元素入栈 */
     stack.push(1);
     stack.push(3);
     stack.push(2);
     stack.push(5);
     stack.push(4);
-
+    
     /* 访问栈顶元素 */
     const peek = stack[stack.length - 1];
-
+    
     /* 元素出栈 */
     const pop = stack.pop();
-
+    
     /* 获取栈的长度 */
     const size = stack.length;
-
+    
     /* 判断是否为空 */
     const is_empty = stack.length === 0;
     ```
@@ -199,7 +199,7 @@ comments: true
 === "C"
 
     ```c title="stack.c"
-
+    
     ```
 
 === "C#"
@@ -207,23 +207,23 @@ comments: true
     ```csharp title="stack.cs"
     /* 初始化栈 */
     Stack<int> stack = new ();
-
+    
     /* 元素入栈 */
     stack.Push(1);
     stack.Push(3);
     stack.Push(2);
     stack.Push(5);
     stack.Push(4);
-
+    
     /* 访问栈顶元素 */
     int peek = stack.Peek();
-
+    
     /* 元素出栈 */
     int pop = stack.Pop();
-
+    
     /* 获取栈的长度 */
     int size = stack.Count();
-
+    
     /* 判断是否为空 */
     bool isEmpty = stack.Count()==0;
     ```
@@ -291,7 +291,7 @@ comments: true
     private:
         ListNode* stackTop; // 将头结点作为栈顶
         int stkSize;        // 栈的长度
-
+    
     public:
         LinkedListStack() {
             stackTop = nullptr;
@@ -338,29 +338,29 @@ comments: true
         def __init__(self):
             self.__peek = None
             self.__size = 0
-
+    
         """ 获取栈的长度 """
         def size(self):
             return self.__size
-
+    
         """ 判断栈是否为空 """
         def is_empty(self):
             return not self.__peek
-
+    
         """ 入栈 """
         def push(self, val):
             node = ListNode(val)
             node.next = self.__peek
             self.__peek = node
             self.__size += 1
-
+    
         """ 出栈 """
         def pop(self):
             num = self.peek()
             self.__peek = self.__peek.next
             self.__size -= 1
             return num
-
+    
         """ 访问栈顶元素 """
         def peek(self):
             # 判空处理
@@ -420,21 +420,21 @@ comments: true
     class LinkedListStack {
         #stackPeek;  // 将头结点作为栈顶
         #stkSize = 0;   // 栈的长度
-
+    
         constructor() {
             this.#stackPeek = null;
         }
-
+    
         /* 获取栈的长度 */
         get size() {
             return this.#stkSize;
         }
-
+    
         /* 判断栈是否为空 */
         isEmpty() {
             return this.size == 0;
         }
-
+    
         /* 入栈 */
         push(num) {
             const node = new ListNode(num);
@@ -442,7 +442,7 @@ comments: true
             this.#stackPeek = node;
             this.#stkSize++;
         }
-
+    
         /* 出栈 */
         pop() {
             const num = this.peek();
@@ -453,7 +453,7 @@ comments: true
             this.#stkSize--;
             return num;
         }
-
+    
         /* 访问栈顶元素 */
         peek() {
             if (!this.#stackPeek) {
@@ -461,7 +461,7 @@ comments: true
             }
             return this.#stackPeek.val;
         }
-
+    
         /* 将链表转化为 Array 并返回 */
         toArray() {
             let node = this.#stackPeek;
@@ -482,21 +482,21 @@ comments: true
     class LinkedListStack {
         private stackPeek: ListNode | null;  // 将头结点作为栈顶
         private stkSize: number = 0;   // 栈的长度
-
+    
         constructor() {
             this.stackPeek = null;
         }
-
+    
         /* 获取栈的长度 */
         get size(): number {
             return this.stkSize;
         }
-
+    
         /* 判断栈是否为空 */
         isEmpty(): boolean {
             return this.size == 0;
         }
-
+    
         /* 入栈 */
         push(num: number): void {
             const node = new ListNode(num);
@@ -504,7 +504,7 @@ comments: true
             this.stackPeek = node;
             this.stkSize++;
         }
-
+    
         /* 出栈 */
         pop(): number {
             const num = this.peek();
@@ -515,7 +515,7 @@ comments: true
             this.stkSize--;
             return num;
         }
-
+    
         /* 访问栈顶元素 */
         peek(): number {
             if (!this.stackPeek) {
@@ -523,7 +523,7 @@ comments: true
             }
             return this.stackPeek.val;
         }
-
+    
         /* 将链表转化为 Array 并返回 */
         toArray(): number[] {
             let node = this.stackPeek;
@@ -540,7 +540,7 @@ comments: true
 === "C"
 
     ```c title="linkedlist_stack.c"
-
+    
     ```
 
 === "C#"
@@ -676,24 +676,24 @@ comments: true
     class ArrayStack:
         def __init__(self):
             self.__stack = []
-
+    
         """ 获取栈的长度 """
         def size(self):
             return len(self.__stack)
-
+    
         """ 判断栈是否为空 """
         def is_empty(self):
             return self.__stack == []
-
+    
         """ 入栈 """
         def push(self, item):
             self.__stack.append(item)
-
+    
         """ 出栈 """
         def pop(self):
             assert not self.is_empty(), "栈为空"
             return self.__stack.pop()
-
+    
         """ 访问栈顶元素 """
         def peek(self):
             assert not self.is_empty(), "栈为空"
@@ -821,7 +821,7 @@ comments: true
 === "C"
 
     ```c title="array_stack.c"
-
+    
     ```
 
 === "C#"
@@ -876,5 +876,5 @@ comments: true
 
 ## 栈典型应用
 
-- **浏览器中的后退与前进、软件中的撤销与反撤销。** 每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
-- **程序内存管理。** 每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。
+- **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
+- **程序内存管理**。每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。

docs/chapter_tree/avl_tree.md

@@ -253,7 +253,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 ## AVL 树旋转
 
-AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影响二叉树中序遍历序列的前提下，使失衡结点重新恢复平衡。** 换言之，旋转操作既可以使树保持为「二叉搜索树」，也可以使树重新恢复为「平衡二叉树」。
+AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影响二叉树中序遍历序列的前提下，使失衡结点重新恢复平衡**。换言之，旋转操作既可以使树保持为「二叉搜索树」，也可以使树重新恢复为「平衡二叉树」。
 
 我们将平衡因子的绝对值 $> 1$ 的结点称为「失衡结点」。根据结点的失衡情况，旋转操作分为 **右旋、左旋、先右旋后左旋、先左旋后右旋**，接下来我们来一起来看看它们是如何操作的。
 

docs/chapter_tree/binary_search_tree.md

@@ -430,15 +430,15 @@ comments: true
 
 与插入结点一样，我们需要在删除操作后维持二叉搜索树的“左子树 < 根结点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
 
-**待删除结点的子结点数量 $= 0$ 。** 表明待删除结点是叶结点，直接删除即可。
+**待删除结点的子结点数量 $= 0$ **。表明待删除结点是叶结点，直接删除即可。
 
 ![bst_remove_case1](binary_search_tree.assets/bst_remove_case1.png)
 
-**待删除结点的子结点数量 $= 1$ 。** 将待删除结点替换为其子结点。
+**待删除结点的子结点数量 $= 1$ **。将待删除结点替换为其子结点。
 
 ![bst_remove_case2](binary_search_tree.assets/bst_remove_case2.png)
 
-**待删除结点的子结点数量 $= 2$ 。** 删除操作分为三步：
+**待删除结点的子结点数量 $= 2$ **。删除操作分为三步：
 
 1. 找到待删除结点在 **中序遍历序列** 中的下一个结点，记为 `nex` ；
 2. 在树中递归删除结点 `nex` ；

docs/chapter_tree/binary_tree.md

@@ -137,7 +137,7 @@ comments: true
 
 ## 二叉树基本操作
 
-**初始化二叉树。** 与链表类似，先初始化结点，再构建引用指向（即指针）。
+**初始化二叉树**。与链表类似，先初始化结点，再构建引用指向（即指针）。
 
 === "Java"
 
@@ -263,7 +263,7 @@ comments: true
     n2.right = n5;
     ```
 
-**插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。
+**插入与删除结点**。与链表类似，插入与删除结点都可以通过修改指针实现。
 
 ![binary_tree_add_remove](binary_tree.assets/binary_tree_add_remove.png)
 
@@ -497,7 +497,7 @@ comments: true
 
 ![array_representation_with_empty](binary_tree.assets/array_representation_with_empty.png)
 
-回顾「完全二叉树」的满足条件，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。“便于使用数组表示”也是完全二叉树受欢迎的原因之一。
+回顾「完全二叉树」的定义，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。因此，完全二叉树非常适合使用数组来表示。
 
 ![array_representation_complete_binary_tree](binary_tree.assets/array_representation_complete_binary_tree.png)