deploy

chapter_tree/binary_tree/index.html

@@ -1850,7 +1850,7 @@
 
 
 <h1 id="71">7.1. &nbsp; 二叉树<a class="headerlink" href="#71" title="Permanent link">&para;</a></h1>
-<p>「二叉树 Binary Tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑。类似于链表，二叉树也是以节点为单位存储的，节点包含「值」和两个「指针」。</p>
+<p>「二叉树 Binary Tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含一个「值」和两个「指针」。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:10"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -1956,32 +1956,32 @@
 </div>
 </div>
 </div>
-<p>节点的两个指针分别指向「左子节点」和「右子节点」，并且称该节点为两个子节点的「父节点」。给定二叉树某节点，将“左子节点及其以下节点形成的树”称为该节点的「左子树」，右子树同理。</p>
-<p>除了叶节点外，每个节点都有子节点和子树。例如，若将下图的“节点 2”看作父节点，那么其左子节点和右子节点分别为“节点 4”和“节点 5”，左子树和右子树分别为“节点 4 及其以下节点形成的树”和“节点 5 及其以下节点形成的树”。</p>
+<p>节点的两个指针分别指向「左子节点」和「右子节点」，同时该节点被称为这两个子节点的「父节点」。当给定一个二叉树的节点时，我们将该节点的左子节点及其以下节点形成的树称为该节点的「左子树」，同理可得「右子树」。</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"> Fig. 父节点、子节点、子树 </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{null}\)</span> ；</li>
-<li>节点所处「层 Level」：从顶至底依次增加，根节点所处层为 1 ；</li>
-<li>节点「度 Degree」：节点的子节点数量。二叉树中，度的范围是 0, 1, 2 ；</li>
-<li>「边 Edge」：连接两个节点的边，即节点指针；</li>
-<li>二叉树「高度」：二叉树中根节点到最远叶节点走过边的数量；</li>
-<li>节点「深度 Depth」 ：根节点到该节点走过边的数量；</li>
-<li>节点「高度 Height」：最远叶节点到该节点走过边的数量；</li>
+<li>「根节点 Root Node」：位于二叉树顶层的节点，没有父节点；</li>
+<li>「叶节点 Leaf Node」：没有子节点的节点，其两个指针均指向 <span class="arithmatex">\(\text{null}\)</span> ；</li>
+<li>节点的「层 Level」：从顶至底递增，根节点所在层为 1 ；</li>
+<li>节点的「度 Degree」：节点的子节点的数量。在二叉树中，度的范围是 0, 1, 2 ；</li>
+<li>「边 Edge」：连接两个节点的线段，即节点指针；</li>
+<li>二叉树的「高度」：从根节点到最远叶节点所经过的边的数量；</li>
+<li>节点的「深度 Depth」 ：从根节点到该节点所经过的边的数量；</li>
+<li>节点的「高度 Height」：从最远叶节点到该节点所经过的边的数量；</li>
 </ul>
 <p><img alt="二叉树的常用术语" src="../binary_tree.assets/binary_tree_terminology.png" /></p>
 <p align="center"> Fig. 二叉树的常用术语 </p>
 
 <div class="admonition tip">
 <p class="admonition-title">高度与深度的定义</p>
-<p>值得注意，我们通常将「高度」和「深度」定义为“走过边的数量”，而有些题目或教材会将其定义为“走过节点的数量”，此时高度或深度都需要 + 1 。</p>
+<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>
+<p><strong>初始化二叉树</strong>。与链表类似，首先初始化节点，然后构建引用指向（即指针）。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:10"><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" /><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">JavaScript</label><label for="__tabbed_2_6">TypeScript</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></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2112,7 +2112,7 @@
 </div>
 </div>
 </div>
-<p><strong>插入与删除节点</strong>。与链表类似，插入与删除节点都可以通过修改指针实现。</p>
+<p><strong>插入与删除节点</strong>。与链表类似，通过修改指针来实现插入与删除节点。</p>
 <p><img alt="在二叉树中插入与删除节点" src="../binary_tree.assets/binary_tree_add_remove.png" /></p>
 <p align="center"> Fig. 在二叉树中插入与删除节点 </p>
 
@@ -2208,21 +2208,20 @@
 </div>
 <div class="admonition note">
 <p class="admonition-title">Note</p>
-<p>插入节点会改变二叉树的原有逻辑结构，删除节点往往意味着删除了该节点的所有子树。因此，二叉树中的插入与删除一般都是由一套操作配合完成的，这样才能实现有意义的操作。</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">完美二叉树<a class="headerlink" href="#_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>
+<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>
-<p>在中文社区中，完美二叉树常被称为「满二叉树」，请注意与完满二叉树区分。</p>
+<p>在中文社区中，完美二叉树常被称为「满二叉树」，请注意区分。</p>
 </div>
 <p><img alt="完美二叉树" src="../binary_tree.assets/perfect_binary_tree.png" /></p>
 <p align="center"> Fig. 完美二叉树 </p>
 
 <h3 id="_2">完全二叉树<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
 <p>「完全二叉树 Complete Binary Tree」只有最底层的节点未被填满，且最底层节点尽量靠左填充。</p>
-<p><strong>完全二叉树非常适合用数组来表示</strong>。如果按照层序遍历序列的顺序来存储，那么空节点 <code>null</code> 一定全部出现在序列的尾部，因此我们就可以不用存储这些 null 了。</p>
 <p><img alt="完全二叉树" src="../binary_tree.assets/complete_binary_tree.png" /></p>
 <p align="center"> Fig. 完全二叉树 </p>
 
@@ -2232,14 +2231,14 @@
 <p align="center"> Fig. 完满二叉树 </p>
 
 <h3 id="_4">平衡二叉树<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
-<p>「平衡二叉树 Balanced Binary Tree」中任意节点的左子树和右子树的高度之差的绝对值 <span class="arithmatex">\(\leq 1\)</span> 。</p>
+<p>「平衡二叉树 Balanced Binary Tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。</p>
 <p><img alt="平衡二叉树" src="../binary_tree.assets/balanced_binary_tree.png" /></p>
 <p align="center"> Fig. 平衡二叉树 </p>
 
 <h2 id="714">7.1.4. &nbsp; 二叉树的退化<a class="headerlink" href="#714" title="Permanent link">&para;</a></h2>
-<p>当二叉树的每层的节点都被填满时，达到「完美二叉树」；而当所有节点都偏向一边时，二叉树退化为「链表」。</p>
+<p>当二叉树的每层节点都被填满时，达到「完美二叉树」；而当所有节点都偏向一侧时，二叉树退化为「链表」。</p>
 <ul>
-<li>完美二叉树是一个二叉树的“最佳状态”，可以完全发挥出二叉树“分治”的优势；</li>
+<li>完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势；</li>
 <li>链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> ；</li>
 </ul>
 <p><img alt="二叉树的最佳与最二叉树的最佳和最差结构差情况" src="../binary_tree.assets/binary_tree_corner_cases.png" /></p>
@@ -2280,17 +2279,17 @@
 </table>
 </div>
 <h2 id="715">7.1.5. &nbsp; 二叉树表示方式 *<a class="headerlink" href="#715" title="Permanent link">&para;</a></h2>
-<p>我们一般使用二叉树的「链表表示」，即存储单位为节点 <code>TreeNode</code> ，节点之间通过指针（引用）相连接。本文前述示例代码展示了二叉树在链表表示下的各项基本操作。</p>
-<p>那能否可以用「数组表示」二叉树呢？答案是肯定的。先来分析一个简单案例，给定一个「完美二叉树」，将节点按照层序遍历的顺序编号（从 0 开始），那么可以推导得出父节点索引与子节点索引之间的「映射公式」：<strong>设节点的索引为 <span class="arithmatex">\(i\)</span> ，则该节点的左子节点索引为 <span class="arithmatex">\(2i + 1\)</span> 、右子节点索引为 <span class="arithmatex">\(2i + 2\)</span></strong> 。</p>
-<p><strong>本质上，映射公式的作用就是链表中的指针</strong>。对于层序遍历序列中的任意节点，我们都可以使用映射公式来访问子节点。因此，可以直接使用层序遍历序列（即数组）来表示完美二叉树。</p>
+<p>我们通常使用二叉树的「链表表示」，即存储单位为节点 <code>TreeNode</code> ，节点之间通过指针相连接。本文前述示例代码展示了二叉树在链表表示下的各项基本操作。</p>
+<p>那么，能否用「数组」来表示二叉树呢？答案是肯定的。先来分析一个简单案例，给定一个「完美二叉树」，将节点按照层序遍历的顺序编号（从 0 开始），那么可以推导得出父节点索引与子节点索引之间的“映射公式”：<strong>若节点的索引为 <span class="arithmatex">\(i\)</span> ，则该节点的左子节点索引为 <span class="arithmatex">\(2i + 1\)</span> ，右子节点索引为 <span class="arithmatex">\(2i + 2\)</span></strong> 。</p>
+<p><strong>本质上，映射公式的作用相当于链表中的指针</strong>。对于层序遍历序列中的任意节点，我们都可以使用映射公式来访问其子节点。因此，我们可以将二叉树的层序遍历序列存储到数组中，利用以上映射公式来表示二叉树。</p>
 <p><img alt="完美二叉树的数组表示" src="../binary_tree.assets/array_representation_mapping.png" /></p>
 <p align="center"> Fig. 完美二叉树的数组表示 </p>
 
-<p>然而，完美二叉树只是个例，二叉树中间层往往存在许多空节点（即 <code>null</code> ），而层序遍历序列并不包含这些空节点，并且我们无法单凭序列来猜测空节点的数量和分布位置，<strong>即理论上存在许多种二叉树都符合该层序遍历序列</strong>。显然，这种情况无法使用数组来存储二叉树。</p>
+<p>然而，完美二叉树只是一个特例。在二叉树的中间层，通常存在许多 <span class="arithmatex">\(\text{null}\)</span> ，而层序遍历序列并不包含这些 <span class="arithmatex">\(\text{null}\)</span> 。我们无法仅凭序列来推测空节点的数量和分布位置，<strong>这意味着理论上存在许多种二叉树都符合该层序遍历序列</strong>。显然，在这种情况下，我们无法使用数组来存储二叉树。</p>
 <p><img alt="给定数组对应多种二叉树可能性" src="../binary_tree.assets/array_representation_without_empty.png" /></p>
 <p align="center"> Fig. 给定数组对应多种二叉树可能性 </p>
 
-<p>为了解决此问题，考虑按照完美二叉树的形式来表示所有二叉树，<strong>即在序列中使用特殊符号来显式地表示“空位”</strong>。如下图所示，这样处理后，序列（数组）就可以唯一表示二叉树了。</p>
+<p>为了解决这个问题，我们可以考虑按照完美二叉树的形式来表示所有二叉树，<strong>并在序列中使用特殊符号来显式地表示 <span class="arithmatex">\(\text{null}\)</span></strong>。如下图所示，这样处理后，层序遍历序列就可以唯一表示二叉树了。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="4:10"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Java</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Python</label><label for="__tabbed_4_4">Go</label><label for="__tabbed_4_5">JavaScript</label><label for="__tabbed_4_6">TypeScript</label><label for="__tabbed_4_7">C</label><label for="__tabbed_4_8">C#</label><label for="__tabbed_4_9">Swift</label><label for="__tabbed_4_10">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2355,11 +2354,11 @@
 <p><img alt="任意类型二叉树的数组表示" src="../binary_tree.assets/array_representation_with_empty.png" /></p>
 <p align="center"> Fig. 任意类型二叉树的数组表示 </p>
 
-<p>回顾「完全二叉树」的定义，其只有最底层有空节点，并且最底层的节点尽量靠左，因而所有空节点都一定出现在层序遍历序列的末尾。<strong>因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”</strong>。因此，完全二叉树非常适合使用数组来表示。</p>
+<p><strong>完全二叉树非常适合使用数组来表示</strong>。回顾「完全二叉树」的定义，<span class="arithmatex">\(\text{null}\)</span> 只出现在最底层，并且最底层的节点尽量靠左。这意味着，<strong>所有空节点一定出现在层序遍历序列的末尾</strong>。由于我们事先知道了所有 <span class="arithmatex">\(\text{null}\)</span> 的位置，因此在使用数组表示完全二叉树时，可以省略存储它们。</p>
 <p><img alt="完全二叉树的数组表示" src="../binary_tree.assets/array_representation_complete_binary_tree.png" /></p>
 <p align="center"> Fig. 完全二叉树的数组表示 </p>
 
-<p>数组表示有两个优点： 一是不需要存储指针，节省空间；二是可以随机访问节点。然而，当二叉树中的“空位”很多时，数组中只包含很少节点的数据，空间利用率很低。</p>
+<p>数组表示具有两个显著优点：首先，它不需要存储指针，从而节省了空间；其次，它允许随机访问节点。然而，当二叉树中存在大量 <span class="arithmatex">\(\text{null}\)</span> 时，数组中包含的节点数据比重较低，导致有效空间利用率降低。</p>