Update the book based on the revised second edition (#1014)

* Revised the book

* Update the book with the second revised edition

* Revise base on the manuscript of the first edition

docs/chapter_heap/build_heap.md

@@ -46,7 +46,7 @@ $$
 T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1
 $$
 
-化简上式需要借助中学的数列知识，先对 $T(h)$ 乘以 $2$ ，得到：
+化简上式需要借助中学的数列知识，将对 $T(h)$ 乘以 $2$ ，得到：
 
 $$
 \begin{aligned}
@@ -71,4 +71,4 @@ T(h) & = 2 \frac{1 - 2^h}{1 - 2} - h \newline
 \end{aligned}
 $$
 
-进一步地，高度为 $h$ 的完美二叉树的节点数量为 $n = 2^{h+1} - 1$ ，易得复杂度为 $O(2^h) = O(n)$ 。以上推算表明，**输入列表并建堆的时间复杂度为 $O(n)$ ，非常高效**。
+进一步，高度为 $h$ 的完美二叉树的节点数量为 $n = 2^{h+1} - 1$ ，易得复杂度为 $O(2^h) = O(n)$ 。以上推算表明，**输入列表并建堆的时间复杂度为 $O(n)$ ，非常高效**。

docs/chapter_heap/heap.md

@@ -2,8 +2,8 @@
 
 「堆 heap」是一种满足特定条件的完全二叉树，主要可分为两种类型，如下图所示。
 
-- 「大顶堆 max heap」：任意节点的值 $\geq$ 其子节点的值。
 - 「小顶堆 min heap」：任意节点的值 $\leq$ 其子节点的值。
+- 「大顶堆 max heap」：任意节点的值 $\geq$ 其子节点的值。
 
 ![小顶堆与大顶堆](heap.assets/min_heap_and_max_heap.png)
 
@@ -11,11 +11,11 @@
 
 - 最底层节点靠左填充，其他层的节点都被填满。
 - 我们将二叉树的根节点称为“堆顶”，将底层最靠右的节点称为“堆底”。
-- 对于大顶堆（小顶堆），堆顶元素（根节点）的值分别是最大（最小）的。
+- 对于大顶堆（小顶堆），堆顶元素（根节点）的值是最大（最小）的。
 
-## 堆常用操作
+## 堆的常用操作
 
-需要指出的是，许多编程语言提供的是「优先队列 priority queue」，这是一种抽象数据结构，定义为具有优先级排序的队列。
+需要指出的是，许多编程语言提供的是「优先队列 priority queue」，这是一种抽象的数据结构，定义为具有优先级排序的队列。
 
 实际上，**堆通常用于实现优先队列，大顶堆相当于元素按从大到小的顺序出队的优先队列**。从使用角度来看，我们可以将“优先队列”和“堆”看作等价的数据结构。因此，本书对两者不做特别区分，统一称作“堆”。
 
@@ -23,13 +23,13 @@
 
 <p align="center"> 表 <id> &nbsp; 堆的操作效率 </p>
 
-| 方法名    | 描述                                         | 时间复杂度  |
-| --------- | -------------------------------------------- | ----------- |
-| push()    | 元素入堆                                     | $O(\log n)$ |
-| pop()     | 堆顶元素出堆                                 | $O(\log n)$ |
-| peek()    | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值） | $O(1)$      |
-| size()    | 获取堆的元素数量                             | $O(1)$      |
-| isEmpty() | 判断堆是否为空                               | $O(1)$      |
+| 方法名      | 描述                                             | 时间复杂度  |
+| ----------- | ------------------------------------------------ | ----------- |
+| `push()`    | 元素入堆                                         | $O(\log n)$ |
+| `pop()`     | 堆顶元素出堆                                     | $O(\log n)$ |
+| `peek()`    | 访问堆顶元素（对于大 / 小顶堆分别为最大 / 小值） | $O(1)$      |
+| `size()`    | 获取堆的元素数量                                 | $O(1)$      |
+| `isEmpty()` | 判断堆是否为空                                   | $O(1)$      |
 
 在实际应用中，我们可以直接使用编程语言提供的堆类（或优先队列类）。
 
@@ -353,7 +353,7 @@
 
 当使用数组表示二叉树时，元素代表节点值，索引代表节点在二叉树中的位置。**节点指针通过索引映射公式来实现**。
 
-如下图所示，给定索引 $i$ ，其左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$ ，父节点索引为 $(i - 1) / 2$（向下整除）。当索引越界时，表示空节点或节点不存在。
+如下图所示，给定索引 $i$ ，其左子节点的索引为 $2i + 1$ ，右子节点的索引为 $2i + 2$ ，父节点的索引为 $(i - 1) / 2$（向下整除）。当索引越界时，表示空节点或节点不存在。
 
 ![堆的表示与存储](heap.assets/representation_of_heap.png)
 
@@ -373,7 +373,7 @@
 
 ### 元素入堆
 
-给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏，**因此需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 heapify」。
+给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 `val` 可能大于堆中其他元素，堆的成立条件可能已被破坏，**因此需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 heapify」。
 
 考虑从入堆节点开始，**从底至顶执行堆化**。如下图所示，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。
 
@@ -456,7 +456,7 @@
 [file]{my_heap}-[class]{max_heap}-[func]{sift_down}
 ```
 
-## 堆常见应用
+## 堆的常见应用
 
 - **优先队列**：堆通常作为实现优先队列的首选数据结构，其入队和出队操作的时间复杂度均为 $O(\log n)$ ，而建队操作为 $O(n)$ ，这些操作都非常高效。
 - **堆排序**：给定一组数据，我们可以用它们建立一个堆，然后不断地执行元素出堆操作，从而得到有序数据。然而，我们通常会使用一种更优雅的方式实现堆排序，详见“堆排序”章节。

docs/chapter_heap/summary.md

@@ -8,10 +8,10 @@
 - 完全二叉树非常适合用数组表示，因此我们通常使用数组来存储堆。
 - 堆化操作用于维护堆的性质，在入堆和出堆操作中都会用到。
 - 输入 $n$ 个元素并建堆的时间复杂度可以优化至 $O(n)$ ，非常高效。
-- Top-K 是一个经典算法问题，可以使用堆数据结构高效解决，时间复杂度为 $O(n \log k)$ 。
+- Top-k 是一个经典算法问题，可以使用堆数据结构高效解决，时间复杂度为 $O(n \log k)$ 。
 
 ### Q & A
 
 !!! question "数据结构的“堆”与内存管理的“堆”是同一个概念吗？"
 
-    两者不是同一个概念，只是碰巧都叫堆。计算机系统内存中的堆是动态内存分配的一部分，程序在运行时可以使用它来存储数据。程序可以请求一定量的堆内存，用于存储如对象和数组等复杂结构。当这些数据不再需要时，程序需要释放这些内存，以防止内存泄漏。相较于栈内存，堆内存的管理和使用需要更谨慎，使用不当可能会导致内存泄漏和野指针等问题。
+    两者不是同一个概念，只是碰巧都叫“堆”。计算机系统内存中的堆是动态内存分配的一部分，程序在运行时可以使用它来存储数据。程序可以请求一定量的堆内存，用于存储如对象和数组等复杂结构。当这些数据不再需要时，程序需要释放这些内存，以防止内存泄漏。相较于栈内存，堆内存的管理和使用需要更谨慎，使用不当可能会导致内存泄漏和野指针等问题。

docs/chapter_heap/top_k.md

@@ -1,8 +1,8 @@
-# Top-K 问题
+# Top-k 问题
 
 !!! question
 
-    给定一个长度为 $n$ 的无序数组 `nums` ，请返回数组中前 $k$ 大的元素。
+    给定一个长度为 $n$ 的无序数组 `nums` ，请返回数组中最大的 $k$ 个元素。
 
 对于该问题，我们先介绍两种思路比较直接的解法，再介绍效率更高的堆解法。
 
@@ -28,7 +28,7 @@
 
 ## 方法三：堆
 
-我们可以基于堆更加高效地解决 Top-K 问题，流程如下图所示。
+我们可以基于堆更加高效地解决 Top-k 问题，流程如下图所示。
 
 1. 初始化一个小顶堆，其堆顶元素最小。
 2. 先将数组的前 $k$ 个元素依次入堆。
@@ -70,4 +70,4 @@
 
 总共执行了 $n$ 轮入堆和出堆，堆的最大长度为 $k$ ，因此时间复杂度为 $O(n \log k)$ 。该方法的效率很高，当 $k$ 较小时，时间复杂度趋向 $O(n)$ ；当 $k$ 较大时，时间复杂度不会超过 $O(n \log n)$ 。
 
-另外，该方法适用于动态数据流的使用场景。在不断加入数据时，我们可以持续维护堆内的元素，从而实现最大 $k$ 个元素的动态更新。
+另外，该方法适用于动态数据流的使用场景。在不断加入数据时，我们可以持续维护堆内的元素，从而实现最大的 $k$ 个元素的动态更新。