Reconstruct the chapter of the tree.

docs/chapter_heap/build_heap.md

@@ -2,15 +2,13 @@
 
 如果我们想要根据输入列表生成一个堆，这个过程被称为「建堆」。
 
-## 两种建堆方法
-
-### 借助入堆方法实现
+## 借助入堆方法实现
 
 最直接的方法是借助“元素入堆操作”实现，首先创建一个空堆，然后将列表元素依次添加到堆中。
 
 设元素数量为 $n$ ，则最后一个元素入堆的时间复杂度为 $O(\log n)$ 。在依次添加元素时，堆的平均长度为 $\frac{n}{2}$ ，因此该方法的总体时间复杂度为 $O(n \log n)$ 。
 
-### 基于堆化操作实现
+## 基于堆化操作实现
 
 有趣的是，存在一种更高效的建堆方法，其时间复杂度仅为 $O(n)$ 。我们先将列表所有元素原封不动添加到堆中，**然后迭代地对各个节点执行“从顶至底堆化”**。当然，**我们不需要对叶节点执行堆化操作**，因为它们没有子节点。
 

docs/chapter_tree/array_representation_of_tree.md

@@ -0,0 +1,120 @@
+# 二叉树数组表示
+
+在链表表示下，二叉树的存储单元为节点 `TreeNode` ，节点之间通过指针相连接。在上节中，我们学习了在链表表示下的二叉树的各项基本操作。
+
+那么，能否用「数组」来表示二叉树呢？答案是肯定的。
+
+## 表示完美二叉树
+
+先分析一个简单案例，给定一个完美二叉树，我们将节点按照层序遍历的顺序编号（从 $0$ 开始），此时每个节点都对应唯一的索引。
+
+根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”：**若节点的索引为 $i$ ，则该节点的左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$** 。
+
+![完美二叉树的数组表示](binary_tree.assets/array_representation_mapping.png)
+
+**映射公式的作用相当于链表中的指针**。如果我们将节点按照层序遍历的顺序存储在一个数组中，那么对于数组中的任意节点，我们都可以通过映射公式来访问其子节点。
+
+## 表示任意二叉树
+
+然而，完美二叉树只是一个特例。在二叉树的中间层，通常存在许多 $\text{null}$ ，而层序遍历序列并不包含这些 $\text{null}$ 。我们无法仅凭该序列来推测 $\text{null}$ 的数量和分布位置，**这意味着存在多种二叉树结构都符合该层序遍历序列**。显然在这种情况下，上述的数组表示方法已经失效。
+
+![层序遍历序列对应多种二叉树可能性](binary_tree.assets/array_representation_without_empty.png)
+
+为了解决此问题，**我们可以考虑在层序遍历序列中显式地写出所有 $\text{null}$**。如下图所示，这样处理后，层序遍历序列就可以唯一表示二叉树了。
+
+=== "Java"
+
+    ```java title=""
+    /* 二叉树的数组表示 */
+    // 使用 int 的包装类 Integer ，就可以使用 null 来标记空位
+    Integer[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 二叉树的数组表示 */
+    // 为了符合数据类型为 int ，使用 int 最大值标记空位
+    // 该方法的使用前提是没有节点的值 = INT_MAX
+    vector<int> tree = { 1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15 };
+    ```
+
+=== "Python"
+
+    ```python title=""
+    # 二叉树的数组表示
+    # 直接使用 None 来表示空位
+    tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 二叉树的数组表示 */
+    // 使用 any 类型的切片, 就可以使用 nil 来标记空位
+    tree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title=""
+    /* 二叉树的数组表示 */
+    // 直接使用 null 来表示空位
+    let tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
+    ```
+
+=== "TypeScript"
+
+    ```typescript title=""
+    /* 二叉树的数组表示 */
+    // 直接使用 null 来表示空位
+    let tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
+    ```
+
+=== "C"
+
+    ```c title=""
+    
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 二叉树的数组表示 */
+    // 使用 int? 可空类型 ，就可以使用 null 来标记空位
+    int?[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* 二叉树的数组表示 */
+    // 使用 Int? 可空类型 ，就可以使用 nil 来标记空位
+    let tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+
+    ```
+
+![任意类型二叉树的数组表示](binary_tree.assets/array_representation_with_empty.png)
+
+## 优势与局限性
+
+二叉树的数组表示存在以下优点：
+
+- 数组存储在连续的内存空间中，缓存友好，访问与遍历速度较快；
+- 不需要存储指针，比较节省空间；
+- 允许随机访问节点；
+
+然而，数组表示也具有一些局限性：
+
+- 数组存储需要连续内存空间，因此不适合存储数据量过大的树。
+- 增删节点需要通过数组插入与删除操作实现，效率较低；
+- 当二叉树中存在大量 $\text{null}$ 时，数组中包含的节点数据比重较低，空间利用率较低。
+
+**完全二叉树非常适合使用数组来表示**。回顾完全二叉树的定义，$\text{null}$ 只出现在最底层且靠右的位置，**这意味着所有 $\text{null}$ 一定出现在层序遍历序列的末尾**。因此，在使用数组表示完全二叉树时，可以省略存储所有 $\text{null}$ 。
+
+![完全二叉树的数组表示](binary_tree.assets/array_representation_complete_binary_tree.png)

docs/chapter_tree/binary_tree.md

@@ -463,104 +463,3 @@
 | 树的节点总数为 $n$ 时的高度 | $\log_2 (n+1) - 1$ | $n - 1$     |
 
 </div>
-
-## 二叉树表示方式 *
-
-我们通常使用二叉树的「链表表示」，即存储单位为节点 `TreeNode` ，节点之间通过指针相连接。本文前述示例代码展示了二叉树在链表表示下的各项基本操作。
-
-那么，能否用「数组」来表示二叉树呢？答案是肯定的。先来分析一个简单案例，给定一个「完美二叉树」，将节点按照层序遍历的顺序编号（从 0 开始），那么可以推导得出父节点索引与子节点索引之间的“映射公式”：**若节点的索引为 $i$ ，则该节点的左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$** 。
-
-**本质上，映射公式的作用相当于链表中的指针**。对于层序遍历序列中的任意节点，我们都可以使用映射公式来访问其子节点。因此，我们可以将二叉树的层序遍历序列存储到数组中，利用以上映射公式来表示二叉树。
-
-![完美二叉树的数组表示](binary_tree.assets/array_representation_mapping.png)
-
-然而，完美二叉树只是一个特例。在二叉树的中间层，通常存在许多 $\text{null}$ ，而层序遍历序列并不包含这些 $\text{null}$ 。我们无法仅凭序列来推测空节点的数量和分布位置，**这意味着理论上存在许多种二叉树都符合该层序遍历序列**。显然，在这种情况下，我们无法使用数组来存储二叉树。
-
-![给定数组对应多种二叉树可能性](binary_tree.assets/array_representation_without_empty.png)
-
-为了解决这个问题，我们可以考虑按照完美二叉树的形式来表示所有二叉树，**并在序列中使用特殊符号来显式地表示 $\text{null}$**。如下图所示，这样处理后，层序遍历序列就可以唯一表示二叉树了。
-
-=== "Java"
-
-    ```java title=""
-    /* 二叉树的数组表示 */
-    // 使用 int 的包装类 Integer ，就可以使用 null 来标记空位
-    Integer[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
-    ```
-
-=== "C++"
-
-    ```cpp title=""
-    /* 二叉树的数组表示 */
-    // 为了符合数据类型为 int ，使用 int 最大值标记空位
-    // 该方法的使用前提是没有节点的值 = INT_MAX
-    vector<int> tree = { 1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15 };
-    ```
-
-=== "Python"
-
-    ```python title=""
-    # 二叉树的数组表示
-    # 直接使用 None 来表示空位
-    tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
-    ```
-
-=== "Go"
-
-    ```go title=""
-    /* 二叉树的数组表示 */
-    // 使用 any 类型的切片, 就可以使用 nil 来标记空位
-    tree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}
-    ```
-
-=== "JavaScript"
-
-    ```javascript title=""
-    /* 二叉树的数组表示 */
-    // 直接使用 null 来表示空位
-    let tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
-    ```
-
-=== "TypeScript"
-
-    ```typescript title=""
-    /* 二叉树的数组表示 */
-    // 直接使用 null 来表示空位
-    let tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
-    ```
-
-=== "C"
-
-    ```c title=""
-    
-    ```
-
-=== "C#"
-
-    ```csharp title=""
-    /* 二叉树的数组表示 */
-    // 使用 int? 可空类型 ，就可以使用 null 来标记空位
-    int?[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
-    ```
-
-=== "Swift"
-
-    ```swift title=""
-    /* 二叉树的数组表示 */
-    // 使用 Int? 可空类型 ，就可以使用 nil 来标记空位
-    let tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]
-    ```
-
-=== "Zig"
-
-    ```zig title=""
-
-    ```
-
-![任意类型二叉树的数组表示](binary_tree.assets/array_representation_with_empty.png)
-
-**完全二叉树非常适合使用数组来表示**。回顾「完全二叉树」的定义，$\text{null}$ 只出现在最底层，并且最底层的节点尽量靠左。这意味着，**所有空节点一定出现在层序遍历序列的末尾**。由于我们事先知道了所有 $\text{null}$ 的位置，因此在使用数组表示完全二叉树时，可以省略存储它们。
-
-![完全二叉树的数组表示](binary_tree.assets/array_representation_complete_binary_tree.png)
-
-数组表示具有两个显著优点：首先，它不需要存储指针，从而节省了空间；其次，它允许随机访问节点。然而，当二叉树中存在大量 $\text{null}$ 时，数组中包含的节点数据比重较低，导致有效空间利用率降低。

mkdocs.yml

@@ -160,9 +160,10 @@ nav:
   - 8.     树:
     - 8.1.   二叉树: chapter_tree/binary_tree.md
     - 8.2.   二叉树遍历: chapter_tree/binary_tree_traversal.md
-    - 8.3.   二叉搜索树: chapter_tree/binary_search_tree.md
-    - 8.4.   AVL 树 *: chapter_tree/avl_tree.md
-    - 8.5.   小结: chapter_tree/summary.md
+    - 8.3.   二叉树数组表示: chapter_tree/array_representation_of_tree.md
+    - 8.4.   二叉搜索树: chapter_tree/binary_search_tree.md
+    - 8.5.   AVL 树 *: chapter_tree/avl_tree.md
+    - 8.6.   小结: chapter_tree/summary.md
   - 9.     堆:
     - 9.1.   堆: chapter_heap/heap.md
     - 9.2.   建堆操作 *: chapter_heap/build_heap.md