deploy

2026-07-18 09:46:08 +00:00 · 2023-08-21 19:32:49 +08:00
parent c0f960b443
commit c359c07fe0
67 changed files with 443 additions and 442 deletions
@@ -3430,13 +3430,14 @@
 <p>那么，我们能否用数组来表示二叉树呢？答案是肯定的。</p>
 <h2 id="731">7.3.1 &nbsp; 表示完美二叉树<a class="headerlink" href="#731" title="Permanent link">&para;</a></h2>
 <p>先分析一个简单案例。给定一个完美二叉树，我们将所有节点按照层序遍历的顺序存储在一个数组中，则每个节点都对应唯一的数组索引。</p>
-<p>根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”：<strong>若节点的索引为 <span class="arithmatex">\(i\)</span> ，则该节点的左子节点索引为 <span class="arithmatex">\(2i + 1\)</span> ，右子节点索引为 <span class="arithmatex">\(2i + 2\)</span></strong> 。</p>
+<p>根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”：<strong>若节点的索引为 <span class="arithmatex">\(i\)</span> ，则该节点的左子节点索引为 <span class="arithmatex">\(2i + 1\)</span> ，右子节点索引为 <span class="arithmatex">\(2i + 2\)</span></strong> 。下图展示了各个节点索引之间的映射关系。</p>
 <p><img alt="完美二叉树的数组表示" src="../array_representation_of_tree.assets/array_representation_binary_tree.png" /></p>
 <p align="center"> 图：完美二叉树的数组表示 </p>

 <p><strong>映射公式的角色相当于链表中的指针</strong>。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左（右）子节点。</p>
 <h2 id="732">7.3.2 &nbsp; 表示任意二叉树<a class="headerlink" href="#732" title="Permanent link">&para;</a></h2>
-<p>然而完美二叉树是一个特例，在二叉树的中间层，通常存在许多 <span class="arithmatex">\(\text{None}\)</span> 。由于层序遍历序列并不包含这些 <span class="arithmatex">\(\text{None}\)</span> ，因此我们无法仅凭该序列来推测 <span class="arithmatex">\(\text{None}\)</span> 的数量和分布位置。<strong>这意味着存在多种二叉树结构都符合该层序遍历序列</strong>。显然在这种情况下，上述的数组表示方法已经失效。</p>
+<p>完美二叉树是一个特例，在二叉树的中间层通常存在许多 <span class="arithmatex">\(\text{None}\)</span> 。由于层序遍历序列并不包含这些 <span class="arithmatex">\(\text{None}\)</span> ，因此我们无法仅凭该序列来推测 <span class="arithmatex">\(\text{None}\)</span> 的数量和分布位置。<strong>这意味着存在多种二叉树结构都符合该层序遍历序列</strong>。</p>
+<p>如下图所示，给定一个非完美二叉树，上述的数组表示方法已经失效。</p>
 <p><img alt="层序遍历序列对应多种二叉树可能性" src="../array_representation_of_tree.assets/array_representation_without_empty.png" /></p>
 <p align="center"> 图：层序遍历序列对应多种二叉树可能性 </p>

@@ -3516,7 +3517,8 @@
 <p><img alt="任意类型二叉树的数组表示" src="../array_representation_of_tree.assets/array_representation_with_empty.png" /></p>
 <p align="center"> 图：任意类型二叉树的数组表示 </p>

-<p>值得说明的是，<strong>完全二叉树非常适合使用数组来表示</strong>。回顾完全二叉树的定义，<span class="arithmatex">\(\text{None}\)</span> 只出现在最底层且靠右的位置，<strong>因此所有 <span class="arithmatex">\(\text{None}\)</span> 一定出现在层序遍历序列的末尾</strong>。这意味着使用数组表示完全二叉树时，可以省略存储所有 <span class="arithmatex">\(\text{None}\)</span> ，非常方便。</p>
+<p>值得说明的是，<strong>完全二叉树非常适合使用数组来表示</strong>。回顾完全二叉树的定义，<span class="arithmatex">\(\text{None}\)</span> 只出现在最底层且靠右的位置，<strong>因此所有 <span class="arithmatex">\(\text{None}\)</span> 一定出现在层序遍历序列的末尾</strong>。</p>
+<p>这意味着使用数组表示完全二叉树时，可以省略存储所有 <span class="arithmatex">\(\text{None}\)</span> ，非常方便。下图给出了一个例子。</p>
 <p><img alt="完全二叉树的数组表示" src="../array_representation_of_tree.assets/array_representation_complete_binary_tree.png" /></p>
 <p align="center"> 图：完全二叉树的数组表示 </p>

@@ -3621,7 +3621,7 @@
 <p><img alt="AVL 树在删除节点后发生退化" src="../avl_tree.assets/avltree_degradation_from_removing_node.png" /></p>
 <p align="center"> 图：AVL 树在删除节点后发生退化 </p>

-<p>再例如，在以下完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之恶化。</p>
+<p>再例如，在下图的完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之恶化。</p>
 <p><img alt="AVL 树在插入节点后发生退化" src="../avl_tree.assets/avltree_degradation_from_inserting_node.png" /></p>
 <p align="center"> 图：AVL 树在插入节点后发生退化 </p>

@@ -4142,7 +4142,7 @@
 </div>
 <p align="center"> 图：右旋操作步骤 </p>

-<p>此外，如果节点 <code>child</code> 本身有右子节点（记为 <code>grandChild</code> ），则需要在右旋中添加一步：将 <code>grandChild</code> 作为 <code>node</code> 的左子节点。</p>
+<p>如下图所示，当节点 <code>child</code> 有右子节点（记为 <code>grandChild</code> ）时，需要在右旋中添加一步：将 <code>grandChild</code> 作为 <code>node</code> 的左子节点。</p>
 <p><img alt="有 grandChild 的右旋操作" src="../avl_tree.assets/avltree_right_rotate_with_grandchild.png" /></p>
 <p align="center"> 图：有 grandChild 的右旋操作 </p>

@@ -4349,11 +4349,11 @@
 </div>
 </div>
 <h3 id="2_1">2. &nbsp; 左旋<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
-<p>相应的，如果考虑上述失衡二叉树的“镜像”，则需要执行“左旋”操作。</p>
+<p>相应的，如果考虑上述失衡二叉树的“镜像”，则需要执行下图所示的“左旋”操作。</p>
 <p><img alt="左旋操作" src="../avl_tree.assets/avltree_left_rotate.png" /></p>
 <p align="center"> 图：左旋操作 </p>

-<p>同理，若节点 <code>child</code> 本身有左子节点（记为 <code>grandChild</code> ），则需要在左旋中添加一步：将 <code>grandChild</code> 作为 <code>node</code> 的右子节点。</p>
+<p>同理，如下图所示，当节点 <code>child</code> 有左子节点（记为 <code>grandChild</code> ）时，需要在左旋中添加一步：将 <code>grandChild</code> 作为 <code>node</code> 的右子节点。</p>
 <p><img alt="有 grandChild 的左旋操作" src="../avl_tree.assets/avltree_left_rotate_with_grandchild.png" /></p>
 <p align="center"> 图：有 grandChild 的左旋操作 </p>

@@ -4560,12 +4560,12 @@
 </div>
 </div>
 <h3 id="3">3. &nbsp; 先左旋后右旋<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
-<p>对于下图中的失衡节点 3，仅使用左旋或右旋都无法使子树恢复平衡。此时需要先左旋后右旋，即先对 <code>child</code> 执行“左旋”，再对 <code>node</code> 执行“右旋”。</p>
+<p>对于下图中的失衡节点 3 ，仅使用左旋或右旋都无法使子树恢复平衡。此时需要先对 <code>child</code> 执行“左旋”，再对 <code>node</code> 执行“右旋”。</p>
 <p><img alt="先左旋后右旋" src="../avl_tree.assets/avltree_left_right_rotate.png" /></p>
 <p align="center"> 图：先左旋后右旋 </p>

 <h3 id="4">4. &nbsp; 先右旋后左旋<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
-<p>同理，对于上述失衡二叉树的镜像情况，需要先右旋后左旋，即先对 <code>child</code> 执行“右旋”，然后对 <code>node</code> 执行“左旋”。</p>
+<p>如下图所示，对于上述失衡二叉树的镜像情况，需要先对 <code>child</code> 执行“右旋”，然后对 <code>node</code> 执行“左旋”。</p>
 <p><img alt="先右旋后左旋" src="../avl_tree.assets/avltree_right_left_rotate.png" /></p>
 <p align="center"> 图：先右旋后左旋 </p>

@@ -4574,7 +4574,7 @@
 <p><img alt="AVL 树的四种旋转情况" src="../avl_tree.assets/avltree_rotation_cases.png" /></p>
 <p align="center"> 图：AVL 树的四种旋转情况 </p>

-<p>在代码中，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图中的哪种情况。</p>
+<p>如下表所示，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图中的哪种情况。</p>
 <p align="center"> 表：四种旋转情况的选择条件 </p>

 <div class="center-table">
@@ -1471,7 +1471,7 @@
        
          <li class="md-nav__item">
  <a href="#4" class="md-nav__link">
-    4. &nbsp; 排序
+    4. &nbsp; 中序遍历性质
  </a>
  
 </li>
@@ -3446,7 +3446,7 @@
        
          <li class="md-nav__item">
  <a href="#4" class="md-nav__link">
-    4. &nbsp; 排序
+    4. &nbsp; 中序遍历性质
  </a>
  
 </li>
@@ -3494,7 +3494,7 @@


 <h1 id="74">7.4 &nbsp; 二叉搜索树<a class="headerlink" href="#74" title="Permanent link">&para;</a></h1>
-<p>「二叉搜索树 binary search tree」满足以下条件：</p>
+<p>如下图所示，「二叉搜索树 binary search tree」满足以下条件：</p>
 <ol>
 <li>对于根节点，左子树中所有节点的值 <span class="arithmatex">\(&lt;\)</span> 根节点的值 <span class="arithmatex">\(&lt;\)</span> 右子树中所有节点的值。</li>
 <li>任意节点的左、右子树也是二叉搜索树，即同样满足条件 <code>1.</code> 。</li>
@@ -3505,7 +3505,7 @@
 <h2 id="741">7.4.1 &nbsp; 二叉搜索树的操作<a class="headerlink" href="#741" title="Permanent link">&para;</a></h2>
 <p>我们将二叉搜索树封装为一个类 <code>ArrayBinaryTree</code> ，并声明一个成员变量 <code>root</code> ，指向树的根节点。</p>
 <h3 id="1">1. &nbsp; 查找节点<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
-<p>给定目标节点值 <code>num</code> ，可以根据二叉搜索树的性质来查找。我们声明一个节点 <code>cur</code> ，从二叉树的根节点 <code>root</code> 出发，循环比较节点值 <code>cur.val</code> 和 <code>num</code> 之间的大小关系</p>
+<p>给定目标节点值 <code>num</code> ，可以根据二叉搜索树的性质来查找。如下图所示，我们声明一个节点 <code>cur</code> ，从二叉树的根节点 <code>root</code> 出发，循环比较节点值 <code>cur.val</code> 和 <code>num</code> 之间的大小关系：</p>
 <ul>
 <li>若 <code>cur.val &lt; num</code> ，说明目标节点在 <code>cur</code> 的右子树中，因此执行 <code>cur = cur.right</code> 。</li>
 <li>若 <code>cur.val &gt; num</code> ，说明目标节点在 <code>cur</code> 的左子树中，因此执行 <code>cur = cur.left</code> 。</li>
@@ -3789,15 +3789,19 @@
 </div>
 </div>
 <h3 id="2">2. &nbsp; 插入节点<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
-<p>给定一个待插入元素 <code>num</code> ，为了保持二叉搜索树“左子树 &lt; 根节点 &lt; 右子树”的性质，插入操作分为两步：</p>
+<p>给定一个待插入元素 <code>num</code> ，为了保持二叉搜索树“左子树 &lt; 根节点 &lt; 右子树”的性质，插入操作流程如下图所示。</p>
 <ol>
 <li><strong>查找插入位置</strong>：与查找操作相似，从根节点出发，根据当前节点值和 <code>num</code> 的大小关系循环向下搜索，直到越过叶节点（遍历至 <span class="arithmatex">\(\text{None}\)</span> ）时跳出循环。</li>
 <li><strong>在该位置插入节点</strong>：初始化节点 <code>num</code> ，将该节点置于 <span class="arithmatex">\(\text{None}\)</span> 的位置。</li>
 </ol>
-<p>二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回。</p>
 <p><img alt="在二叉搜索树中插入节点" src="../binary_search_tree.assets/bst_insert.png" /></p>
 <p align="center"> 图：在二叉搜索树中插入节点 </p>

+<p>在代码实现中，需要注意以下两点：</p>
+<ul>
+<li>二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回。</li>
+<li>为了实现插入节点，我们需要借助节点 <code>pre</code> 保存上一轮循环的节点。这样在遍历至 <span class="arithmatex">\(\text{None}\)</span> 时，我们可以获取到其父节点，从而完成节点插入操作。</li>
+</ul>
 <div class="tabbed-set tabbed-alternate" data-tabs="3:12"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><input id="__tabbed_3_12" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Java</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Python</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">JS</label><label for="__tabbed_3_6">TS</label><label for="__tabbed_3_7">C</label><label for="__tabbed_3_8">C#</label><label for="__tabbed_3_9">Swift</label><label for="__tabbed_3_10">Zig</label><label for="__tabbed_3_11">Dart</label><label for="__tabbed_3_12">Rust</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -4170,20 +4174,19 @@
 </div>
 </div>
 </div>
-<p>为了插入节点，我们需要利用辅助节点 <code>pre</code> 保存上一轮循环的节点，这样在遍历至 <span class="arithmatex">\(\text{None}\)</span> 时，我们可以获取到其父节点，从而完成节点插入操作。</p>
 <p>与查找节点相同，插入节点使用 <span class="arithmatex">\(O(\log n)\)</span> 时间。</p>
 <h3 id="3">3. &nbsp; 删除节点<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
 <p>与插入节点类似，我们需要在删除操作后维持二叉搜索树的“左子树 &lt; 根节点 &lt; 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除节点。接下来，根据待删除节点的子节点数量，删除操作需分为三种情况：</p>
-<p>当待删除节点的度为 <span class="arithmatex">\(0\)</span> 时，表示待删除节点是叶节点，可以直接删除。</p>
+<p>如下图所示，当待删除节点的度为 <span class="arithmatex">\(0\)</span> 时，表示待删除节点是叶节点，可以直接删除。</p>
 <p><img alt="在二叉搜索树中删除节点（度为 0）" src="../binary_search_tree.assets/bst_remove_case1.png" /></p>
 <p align="center"> 图：在二叉搜索树中删除节点（度为 0） </p>

-<p>当待删除节点的度为 <span class="arithmatex">\(1\)</span> 时，将待删除节点替换为其子节点即可。</p>
+<p>如下图所示，当待删除节点的度为 <span class="arithmatex">\(1\)</span> 时，将待删除节点替换为其子节点即可。</p>
 <p><img alt="在二叉搜索树中删除节点（度为 1）" src="../binary_search_tree.assets/bst_remove_case2.png" /></p>
 <p align="center"> 图：在二叉搜索树中删除节点（度为 1） </p>

-<p>当待删除节点的度为 <span class="arithmatex">\(2\)</span> 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左 <span class="arithmatex">\(&lt;\)</span> 根 <span class="arithmatex">\(&lt;\)</span> 右”的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。</p>
-<p>假设我们选择右子树的最小节点（即中序遍历的下一个节点），则删除操作为：</p>
+<p>当待删除节点的度为 <span class="arithmatex">\(2\)</span> 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左 <span class="arithmatex">\(&lt;\)</span> 根 <span class="arithmatex">\(&lt;\)</span> 右”的性质，<strong>因此这个节点可以是右子树的最小节点或左子树的最大节点</strong>。</p>
+<p>假设我们选择右子树的最小节点（即中序遍历的下一个节点），则删除操作如下图所示。</p>
 <ol>
 <li>找到待删除节点在“中序遍历序列”中的下一个节点，记为 <code>tmp</code> 。</li>
 <li>将 <code>tmp</code> 的值覆盖待删除节点的值，并在树中递归删除节点 <code>tmp</code> 。</li>
@@ -4898,15 +4901,16 @@ void insert(int num) {
 </div>
 </div>
 </div>
-<h3 id="4">4. &nbsp; 排序<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
-<p>我们知道，二叉树的中序遍历遵循“左 <span class="arithmatex">\(\rightarrow\)</span> 根 <span class="arithmatex">\(\rightarrow\)</span> 右”的遍历顺序，而二叉搜索树满足“左子节点 <span class="arithmatex">\(&lt;\)</span> 根节点 <span class="arithmatex">\(&lt;\)</span> 右子节点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：<strong>二叉搜索树的中序遍历序列是升序的</strong>。</p>
+<h3 id="4">4. &nbsp; 中序遍历性质<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
+<p>如下图所示，二叉树的中序遍历遵循“左 <span class="arithmatex">\(\rightarrow\)</span> 根 <span class="arithmatex">\(\rightarrow\)</span> 右”的遍历顺序，而二叉搜索树满足“左子节点 <span class="arithmatex">\(&lt;\)</span> 根节点 <span class="arithmatex">\(&lt;\)</span> 右子节点”的大小关系。</p>
+<p>这意味着在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：<strong>二叉搜索树的中序遍历序列是升序的</strong>。</p>
 <p>利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 <span class="arithmatex">\(O(n)\)</span> 时间，无须额外排序，非常高效。</p>
 <p><img alt="二叉搜索树的中序遍历序列" src="../binary_search_tree.assets/bst_inorder_traversal.png" /></p>
 <p align="center"> 图：二叉搜索树的中序遍历序列 </p>

 <h2 id="742">7.4.2 &nbsp; 二叉搜索树的效率<a class="headerlink" href="#742" title="Permanent link">&para;</a></h2>
 <p>给定一组数据，我们考虑使用数组或二叉搜索树存储。</p>
-<p>观察可知，二叉搜索树的各项操作的时间复杂度都是对数阶，具有稳定且高效的性能表现。只有在高频添加、低频查找删除的数据适用场景下，数组比二叉搜索树的效率更高。</p>
+<p>观察下表，二叉搜索树的各项操作的时间复杂度都是对数阶，具有稳定且高效的性能表现。只有在高频添加、低频查找删除的数据适用场景下，数组比二叉搜索树的效率更高。</p>
 <p align="center"> 表：数组与搜索树的效率对比 </p>

 <div class="center-table">
@@ -4938,7 +4942,7 @@ void insert(int num) {
 </table>
 </div>
 <p>在理想情况下，二叉搜索树是“平衡”的，这样就可以在 <span class="arithmatex">\(\log n\)</span> 轮循环内查找任意节点。</p>
-<p>然而，如果我们在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为链表，这时各种操作的时间复杂度也会退化为 <span class="arithmatex">\(O(n)\)</span> 。</p>
+<p>然而，如果我们在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为下图所示的链表，这时各种操作的时间复杂度也会退化为 <span class="arithmatex">\(O(n)\)</span> 。</p>
 <p><img alt="二叉搜索树的平衡与退化" src="../binary_search_tree.assets/bst_degradation.png" /></p>
 <p align="center"> 图：二叉搜索树的平衡与退化 </p>

@@ -1392,18 +1392,38 @@
    7.1.2 &nbsp; 二叉树基本操作
  </a>
  
-</li>
-      
-        <li class="md-nav__item">
-  <a href="#713" class="md-nav__link">
-    7.1.3 &nbsp; 常见二叉树类型
-  </a>
-  
-    <nav class="md-nav" aria-label="7.1.3   常见二叉树类型">
+    <nav class="md-nav" aria-label="7.1.2   二叉树基本操作">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#1" class="md-nav__link">
+    1. &nbsp; 初始化二叉树
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#713" class="md-nav__link">
+    7.1.3 &nbsp; 插入与删除节点
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#714" class="md-nav__link">
+    7.1.4 &nbsp; 常见二叉树类型
+  </a>
+  
+    <nav class="md-nav" aria-label="7.1.4   常见二叉树类型">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#1_1" class="md-nav__link">
    1. &nbsp; 完美二叉树
  </a>
  
@@ -1436,8 +1456,8 @@
 </li>
      
        <li class="md-nav__item">
-  <a href="#714" class="md-nav__link">
-    7.1.4 &nbsp; 二叉树的退化
+  <a href="#715" class="md-nav__link">
+    7.1.5 &nbsp; 二叉树的退化
  </a>
  
 </li>
@@ -3434,18 +3454,38 @@
    7.1.2 &nbsp; 二叉树基本操作
  </a>
  
-</li>
-      
-        <li class="md-nav__item">
-  <a href="#713" class="md-nav__link">
-    7.1.3 &nbsp; 常见二叉树类型
-  </a>
-  
-    <nav class="md-nav" aria-label="7.1.3   常见二叉树类型">
+    <nav class="md-nav" aria-label="7.1.2   二叉树基本操作">
      <ul class="md-nav__list">
        
          <li class="md-nav__item">
  <a href="#1" class="md-nav__link">
+    1. &nbsp; 初始化二叉树
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#713" class="md-nav__link">
+    7.1.3 &nbsp; 插入与删除节点
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#714" class="md-nav__link">
+    7.1.4 &nbsp; 常见二叉树类型
+  </a>
+  
+    <nav class="md-nav" aria-label="7.1.4   常见二叉树类型">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#1_1" class="md-nav__link">
    1. &nbsp; 完美二叉树
  </a>
  
@@ -3478,8 +3518,8 @@
 </li>
      
        <li class="md-nav__item">
-  <a href="#714" class="md-nav__link">
-    7.1.4 &nbsp; 二叉树的退化
+  <a href="#715" class="md-nav__link">
+    7.1.5 &nbsp; 二叉树的退化
  </a>
  
 </li>
@@ -3649,12 +3689,12 @@
 </div>
 </div>
 <p>每个节点都有两个引用（指针），分别指向「左子节点 left-child node」和「右子节点 right-child node」，该节点被称为这两个子节点的「父节点 parent node」。当给定一个二叉树的节点时，我们将该节点的左子节点及其以下节点形成的树称为该节点的「左子树 left subtree」，同理可得「右子树 right subtree」。</p>
-<p><strong>在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树</strong>。在以下示例中，若将“节点 2”视为父节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，右子树是“节点 5 及其以下节点形成的树”。</p>
+<p><strong>在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树</strong>。如下图所示，如果将“节点 2”视为父节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，右子树是“节点 5 及其以下节点形成的树”。</p>
 <p><img alt="父节点、子节点、子树" src="../binary_tree.assets/binary_tree_definition.png" /></p>
 <p align="center"> 图：父节点、子节点、子树 </p>

 <h2 id="711">7.1.1 &nbsp; 二叉树常见术语<a class="headerlink" href="#711" title="Permanent link">&para;</a></h2>
-<p>二叉树涉及的术语较多，建议尽量理解并记住。</p>
+<p>二叉树的常用术语如下图所示。</p>
 <ul>
 <li>「根节点 root node」：位于二叉树顶层的节点，没有父节点。</li>
 <li>「叶节点 leaf node」：没有子节点的节点，其两个指针均指向 <span class="arithmatex">\(\text{None}\)</span> 。</li>
@@ -3673,7 +3713,8 @@
 <p>请注意，我们通常将“高度”和“深度”定义为“走过边的数量”，但有些题目或教材可能会将其定义为“走过节点的数量”。在这种情况下，高度和深度都需要加 1 。</p>
 </div>
 <h2 id="712">7.1.2 &nbsp; 二叉树基本操作<a class="headerlink" href="#712" title="Permanent link">&para;</a></h2>
-<p><strong>初始化二叉树</strong>。与链表类似，首先初始化节点，然后构建引用指向（即指针）。</p>
+<h3 id="1">1. &nbsp; 初始化二叉树<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
+<p>与链表类似，首先初始化节点，然后构建引用（指针）。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:12"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><input id="__tabbed_2_12" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JS</label><label for="__tabbed_2_6">TS</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label><label for="__tabbed_2_12">Rust</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3834,7 +3875,8 @@
 </div>
 </div>
 </div>
-<p><strong>插入与删除节点</strong>。与链表类似，通过修改指针来实现插入与删除节点。</p>
+<h2 id="713">7.1.3 &nbsp; 插入与删除节点<a class="headerlink" href="#713" title="Permanent link">&para;</a></h2>
+<p>与链表类似，在二叉树中插入与删除节点可以通过修改指针来实现。下图给出了一个示例。</p>
 <p><img alt="在二叉树中插入与删除节点" src="../binary_tree.assets/binary_tree_add_remove.png" /></p>
 <p align="center"> 图：在二叉树中插入与删除节点 </p>

@@ -3952,8 +3994,8 @@
 <p class="admonition-title">Note</p>
 <p>需要注意的是，插入节点可能会改变二叉树的原有逻辑结构，而删除节点通常意味着删除该节点及其所有子树。因此，在二叉树中，插入与删除操作通常是由一套操作配合完成的，以实现有实际意义的操作。</p>
 </div>
-<h2 id="713">7.1.3 &nbsp; 常见二叉树类型<a class="headerlink" href="#713" title="Permanent link">&para;</a></h2>
-<h3 id="1">1. &nbsp; 完美二叉树<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
+<h2 id="714">7.1.4 &nbsp; 常见二叉树类型<a class="headerlink" href="#714" title="Permanent link">&para;</a></h2>
+<h3 id="1_1">1. &nbsp; 完美二叉树<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
 <p>「完美二叉树 perfect binary tree」除了最底层外，其余所有层的节点都被完全填满。在完美二叉树中，叶节点的度为 <span class="arithmatex">\(0\)</span> ，其余所有节点的度都为 <span class="arithmatex">\(2\)</span> ；若树高度为 <span class="arithmatex">\(h\)</span> ，则节点总数为 <span class="arithmatex">\(2^{h+1} - 1\)</span> ，呈现标准的指数级关系，反映了自然界中常见的细胞分裂现象。</p>
 <div class="admonition tip">
 <p class="admonition-title">Tip</p>
@@ -3963,21 +4005,21 @@
 <p align="center"> 图：完美二叉树 </p>

 <h3 id="2">2. &nbsp; 完全二叉树<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
-<p>「完全二叉树 complete binary tree」只有最底层的节点未被填满，且最底层节点尽量靠左填充。</p>
+<p>如下图所示，「完全二叉树 complete binary tree」只有最底层的节点未被填满，且最底层节点尽量靠左填充。</p>
 <p><img alt="完全二叉树" src="../binary_tree.assets/complete_binary_tree.png" /></p>
 <p align="center"> 图：完全二叉树 </p>

 <h3 id="3">3. &nbsp; 完满二叉树<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
-<p>「完满二叉树 full binary tree」除了叶节点之外，其余所有节点都有两个子节点。</p>
+<p>如下图所示，「完满二叉树 full binary tree」除了叶节点之外，其余所有节点都有两个子节点。</p>
 <p><img alt="完满二叉树" src="../binary_tree.assets/full_binary_tree.png" /></p>
 <p align="center"> 图：完满二叉树 </p>

 <h3 id="4">4. &nbsp; 平衡二叉树<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
-<p>「平衡二叉树 balanced binary tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。</p>
+<p>如下图所示，「平衡二叉树 balanced binary tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。</p>
 <p><img alt="平衡二叉树" src="../binary_tree.assets/balanced_binary_tree.png" /></p>
 <p align="center"> 图：平衡二叉树 </p>

-<h2 id="714">7.1.4 &nbsp; 二叉树的退化<a class="headerlink" href="#714" title="Permanent link">&para;</a></h2>
+<h2 id="715">7.1.5 &nbsp; 二叉树的退化<a class="headerlink" href="#715" title="Permanent link">&para;</a></h2>
 <p>当二叉树的每层节点都被填满时，达到“完美二叉树”；而当所有节点都偏向一侧时，二叉树退化为“链表”。</p>
 <ul>
 <li>完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势。</li>
@@ -3415,7 +3415,7 @@
 <p>从物理结构的角度来看，树是一种基于链表的数据结构，因此其遍历方式是通过指针逐个访问节点。然而，树是一种非线性数据结构，这使得遍历树比遍历链表更加复杂，需要借助搜索算法来实现。</p>
 <p>二叉树常见的遍历方式包括层序遍历、前序遍历、中序遍历和后序遍历等。</p>
 <h2 id="721">7.2.1 &nbsp; 层序遍历<a class="headerlink" href="#721" title="Permanent link">&para;</a></h2>
-<p>「层序遍历 level-order traversal」从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。</p>
+<p>如下图所示，「层序遍历 level-order traversal」从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。</p>
 <p>层序遍历本质上属于「广度优先遍历 breadth-first traversal」，它体现了一种“一圈一圈向外扩展”的逐层遍历方式。</p>
 <p><img alt="二叉树的层序遍历" src="../binary_tree_traversal.assets/binary_tree_bfs.png" /></p>
 <p align="center"> 图：二叉树的层序遍历 </p>
@@ -3707,11 +3707,10 @@
 <p><strong>空间复杂度</strong>：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在 <span class="arithmatex">\((n + 1) / 2\)</span> 个节点，占用 <span class="arithmatex">\(O(n)\)</span> 空间。</p>
 <h2 id="722">7.2.2 &nbsp; 前序、中序、后序遍历<a class="headerlink" href="#722" title="Permanent link">&para;</a></h2>
 <p>相应地，前序、中序和后序遍历都属于「深度优先遍历 depth-first traversal」，它体现了一种“先走到尽头，再回溯继续”的遍历方式。</p>
-<p>如下图所示，左侧是深度优先遍历的示意图，右上方是对应的递归代码。深度优先遍历就像是绕着整个二叉树的外围“走”一圈，在这个过程中，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。</p>
+<p>下图展示了对二叉树进行深度优先遍历的工作原理。<strong>深度优先遍历就像是绕着整个二叉树的外围“走”一圈</strong>，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。</p>
 <p><img alt="二叉搜索树的前、中、后序遍历" src="../binary_tree_traversal.assets/binary_tree_dfs.png" /></p>
 <p align="center"> 图：二叉搜索树的前、中、后序遍历 </p>

-<p>以下给出了实现代码，请配合上图理解深度优先遍历的递归过程。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:12"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><input id="__tabbed_2_12" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JS</label><label for="__tabbed_2_6">TS</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label><label for="__tabbed_2_12">Rust</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -4107,7 +4106,7 @@
 <p><strong>空间复杂度</strong>：在最差情况下，即树退化为链表时，递归深度达到 <span class="arithmatex">\(n\)</span> ，系统占用 <span class="arithmatex">\(O(n)\)</span> 栈帧空间。</p>
 <div class="admonition note">
 <p class="admonition-title">Note</p>
-<p>我们也可以不使用递归，仅基于迭代实现前、中、后序遍历，有兴趣的同学可以自行研究。</p>
+<p>我们也可以不使用递归，仅基于迭代实现前、中、后序遍历，有兴趣的同学可以自行实现。</p>
 </div>
 <p>下图展示了前序遍历二叉树的递归过程，其可分为“递”和“归”两个逆向的部分：</p>
 <ol>