mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-26 02:26:28 +08:00
deploy
This commit is contained in:
krahets
parent
c0f960b443
commit
c359c07fe0
67 changed files with 443 additions and 442 deletions
|
|
@ -3434,9 +3434,9 @@
|
|||
<p>然而在本开源书中，内容更迭的时间被缩短至数日甚至几个小时。</p>
|
||||
</div>
|
||||
<h2 id="1621">16.2.1 内容微调<a class="headerlink" href="#1621" title="Permanent link">¶</a></h2>
|
||||
<p>您可以按照以下步骤修改文本或代码：</p>
|
||||
<p>如下图所示，每个页面的右上角都有“编辑图标”。您可以按照以下步骤修改文本或代码：</p>
|
||||
<ol>
|
||||
<li>点击页面的右上角的“编辑图标”，如果遇到“需要 Fork 此仓库”的提示，请同意该操作。</li>
|
||||
<li>点击“编辑图标”，如果遇到“需要 Fork 此仓库”的提示，请同意该操作。</li>
|
||||
<li>修改 Markdown 源文件内容，检查内容的正确性，并尽量保持排版格式的统一。</li>
|
||||
<li>在页面底部填写修改说明，然后点击“Propose file change”按钮。页面跳转后，点击“Create pull request”按钮即可发起拉取请求。</li>
|
||||
</ol>
|
||||
|
|
|
|||
|
|
@ -3536,7 +3536,7 @@
|
|||
|
||||
|
||||
<h1 id="41">4.1 数组<a class="headerlink" href="#41" title="Permanent link">¶</a></h1>
|
||||
<p>「数组 array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将某个元素在数组中的位置称为该元素的「索引 index」。</p>
|
||||
<p>「数组 array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将元素在数组中的位置称为该元素的「索引 index」。下图展示了数组的主要术语和概念。</p>
|
||||
<p><img alt="数组定义与存储方式" src="../array.assets/array_definition.png" /></p>
|
||||
<p align="center"> 图：数组定义与存储方式 </p>
|
||||
|
||||
|
|
@ -3772,11 +3772,11 @@
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="3">3. 插入元素<a class="headerlink" href="#3" title="Permanent link">¶</a></h3>
|
||||
<p>数组元素在内存中是“紧挨着的”，它们之间没有空间再存放任何数据。这意味着如果想要在数组中间插入一个元素，则需要将该元素之后的所有元素都向后移动一位，之后再把元素赋值给该索引。</p>
|
||||
<p>值得注意的是，由于数组的长度是固定的，因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。</p>
|
||||
<p><img alt="数组插入元素" src="../array.assets/array_insert_element.png" /></p>
|
||||
<p align="center"> 图：数组插入元素 </p>
|
||||
<p>数组元素在内存中是“紧挨着的”，它们之间没有空间再存放任何数据。如下图所示，如果想要在数组中间插入一个元素，则需要将该元素之后的所有元素都向后移动一位，之后再把元素赋值给该索引。</p>
|
||||
<p><img alt="数组插入元素示例" src="../array.assets/array_insert_element.png" /></p>
|
||||
<p align="center"> 图：数组插入元素示例 </p>
|
||||
|
||||
<p>值得注意的是，由于数组的长度是固定的，因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。</p>
|
||||
<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">
|
||||
|
|
@ -3925,11 +3925,11 @@
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="4">4. 删除元素<a class="headerlink" href="#4" title="Permanent link">¶</a></h3>
|
||||
<p>同理，如果我们想要删除索引 <span class="arithmatex">\(i\)</span> 处的元素，则需要把索引 <span class="arithmatex">\(i\)</span> 之后的元素都向前移动一位。</p>
|
||||
<p>请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。</p>
|
||||
<p><img alt="数组删除元素" src="../array.assets/array_remove_element.png" /></p>
|
||||
<p align="center"> 图：数组删除元素 </p>
|
||||
<p>同理，如下图所示，若想要删除索引 <span class="arithmatex">\(i\)</span> 处的元素，则需要把索引 <span class="arithmatex">\(i\)</span> 之后的元素都向前移动一位。</p>
|
||||
<p><img alt="数组删除元素示例" src="../array.assets/array_remove_element.png" /></p>
|
||||
<p align="center"> 图：数组删除元素示例 </p>
|
||||
|
||||
<p>请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:12"><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" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><input id="__tabbed_4_12" 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">JS</label><label for="__tabbed_4_6">TS</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><label for="__tabbed_4_11">Dart</label><label for="__tabbed_4_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3523,7 +3523,8 @@
|
|||
|
||||
<h1 id="42">4.2 链表<a class="headerlink" href="#42" title="Permanent link">¶</a></h1>
|
||||
<p>内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。</p>
|
||||
<p>「链表 linked list」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。</p>
|
||||
<p>「链表 linked list」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，通过它可以从当前节点访问到下一个节点。</p>
|
||||
<p>链表的设计使得各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。</p>
|
||||
<p><img alt="链表定义与存储方式" src="../linked_list.assets/linkedlist_definition.png" /></p>
|
||||
<p align="center"> 图：链表定义与存储方式 </p>
|
||||
|
||||
|
|
@ -3533,7 +3534,7 @@
|
|||
<li>尾节点指向的是“空”，它在 Java, C++, Python 中分别被记为 <span class="arithmatex">\(\text{null}\)</span> , <span class="arithmatex">\(\text{nullptr}\)</span> , <span class="arithmatex">\(\text{None}\)</span> 。</li>
|
||||
<li>在 C, C++, Go, Rust 等支持指针的语言中，上述的“引用”应被替换为“指针”。</li>
|
||||
</ul>
|
||||
<p>链表节点 <code>ListNode</code> 如以下代码所示。每个节点除了包含值，还需额外保存一个引用（指针）。因此在相同数据量下，<strong>链表比数组占用更多的内存空间</strong>。</p>
|
||||
<p>如以下代码所示，链表节点 <code>ListNode</code> 除了包含值，还需额外保存一个引用（指针）。因此在相同数据量下，<strong>链表比数组占用更多的内存空间</strong>。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:12"><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" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" 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">JS</label><label for="__tabbed_1_6">TS</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><label for="__tabbed_1_11">Dart</label><label for="__tabbed_1_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3872,10 +3873,10 @@
|
|||
</div>
|
||||
<p>数组整体是一个变量，比如数组 <code>nums</code> 包含元素 <code>nums[0]</code> , <code>nums[1]</code> 等，而链表是由多个独立的节点对象组成的。<strong>我们通常将头节点当作链表的代称</strong>，比如以上代码中的链表可被记做链表 <code>n0</code> 。</p>
|
||||
<h3 id="2">2. 插入节点<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p><strong>在链表中插入节点非常容易</strong>。假设我们想在相邻的两个节点 <code>n0</code> , <code>n1</code> 之间插入一个新节点 <code>P</code> ，则只需要改变两个节点引用（指针）即可，时间复杂度为 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<p>在链表中插入节点非常容易。如下图所示，假设我们想在相邻的两个节点 <code>n0</code> , <code>n1</code> 之间插入一个新节点 <code>P</code> ，<strong>则只需要改变两个节点引用（指针）即可</strong>，时间复杂度为 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<p>相比之下，在数组中插入元素的时间复杂度为 <span class="arithmatex">\(O(n)\)</span> ，在大数据量下的效率较低。</p>
|
||||
<p><img alt="链表插入节点" src="../linked_list.assets/linkedlist_insert_node.png" /></p>
|
||||
<p align="center"> 图：链表插入节点 </p>
|
||||
<p><img alt="链表插入节点示例" src="../linked_list.assets/linkedlist_insert_node.png" /></p>
|
||||
<p align="center"> 图：链表插入节点示例 </p>
|
||||
|
||||
<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">
|
||||
|
|
@ -3990,7 +3991,7 @@
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="3">3. 删除节点<a class="headerlink" href="#3" title="Permanent link">¶</a></h3>
|
||||
<p>在链表中删除节点也非常简便，只需改变一个节点的引用（指针）即可。</p>
|
||||
<p>如下图所示，在链表中删除节点也非常方便，<strong>只需改变一个节点的引用（指针）即可</strong>。</p>
|
||||
<p>请注意，尽管在删除操作完成后节点 <code>P</code> 仍然指向 <code>n1</code> ，但实际上遍历此链表已经无法访问到 <code>P</code> ，这意味着 <code>P</code> 已经不再属于该链表了。</p>
|
||||
<p><img alt="链表删除节点" src="../linked_list.assets/linkedlist_remove_node.png" /></p>
|
||||
<p align="center"> 图：链表删除节点 </p>
|
||||
|
|
@ -4529,9 +4530,12 @@
|
|||
</table>
|
||||
</div>
|
||||
<h2 id="423">4.2.3 常见链表类型<a class="headerlink" href="#423" title="Permanent link">¶</a></h2>
|
||||
<p><strong>单向链表</strong>。即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 <span class="arithmatex">\(\text{None}\)</span> 。</p>
|
||||
<p><strong>环形链表</strong>。如果我们令单向链表的尾节点指向头节点（即首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。</p>
|
||||
<p><strong>双向链表</strong>。与单向链表相比，双向链表记录了两个方向的引用。双向链表的节点定义同时包含指向后继节点（下一个节点）和前驱节点（上一个节点）的引用（指针）。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。</p>
|
||||
<p>如下图所示，常见的链表类型包括三种。</p>
|
||||
<ul>
|
||||
<li><strong>单向链表</strong>：即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 <span class="arithmatex">\(\text{None}\)</span> 。</li>
|
||||
<li><strong>环形链表</strong>：如果我们令单向链表的尾节点指向头节点（即首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。</li>
|
||||
<li><strong>双向链表</strong>：与单向链表相比，双向链表记录了两个方向的引用。双向链表的节点定义同时包含指向后继节点（下一个节点）和前驱节点（上一个节点）的引用（指针）。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。</li>
|
||||
</ul>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="7:12"><input checked="checked" id="__tabbed_7_1" name="__tabbed_7" type="radio" /><input id="__tabbed_7_2" name="__tabbed_7" type="radio" /><input id="__tabbed_7_3" name="__tabbed_7" type="radio" /><input id="__tabbed_7_4" name="__tabbed_7" type="radio" /><input id="__tabbed_7_5" name="__tabbed_7" type="radio" /><input id="__tabbed_7_6" name="__tabbed_7" type="radio" /><input id="__tabbed_7_7" name="__tabbed_7" type="radio" /><input id="__tabbed_7_8" name="__tabbed_7" type="radio" /><input id="__tabbed_7_9" name="__tabbed_7" type="radio" /><input id="__tabbed_7_10" name="__tabbed_7" type="radio" /><input id="__tabbed_7_11" name="__tabbed_7" type="radio" /><input id="__tabbed_7_12" name="__tabbed_7" type="radio" /><div class="tabbed-labels"><label for="__tabbed_7_1">Java</label><label for="__tabbed_7_2">C++</label><label for="__tabbed_7_3">Python</label><label for="__tabbed_7_4">Go</label><label for="__tabbed_7_5">JS</label><label for="__tabbed_7_6">TS</label><label for="__tabbed_7_7">C</label><label for="__tabbed_7_8">C#</label><label for="__tabbed_7_9">Swift</label><label for="__tabbed_7_10">Zig</label><label for="__tabbed_7_11">Dart</label><label for="__tabbed_7_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3474,7 +3474,7 @@
|
|||
<p class="admonition-title">例题一</p>
|
||||
<p>给定一个二叉树，搜索并记录所有值为 <span class="arithmatex">\(7\)</span> 的节点，请返回节点列表。</p>
|
||||
</div>
|
||||
<p>对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 <span class="arithmatex">\(7\)</span> ，若是则将该节点的值加入到结果列表 <code>res</code> 之中。</p>
|
||||
<p>对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 <span class="arithmatex">\(7\)</span> ，若是则将该节点的值加入到结果列表 <code>res</code> 之中。相关过程实现如下图和以下代码所示。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:12"><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" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" 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">JS</label><label for="__tabbed_1_6">TS</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><label for="__tabbed_1_11">Dart</label><label for="__tabbed_1_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3880,7 +3880,7 @@
|
|||
</div>
|
||||
</div>
|
||||
<p>在每次“尝试”中，我们通过将当前节点添加进 <code>path</code> 来记录路径；而在“回退”前，我们需要将该节点从 <code>path</code> 中弹出，<strong>以恢复本次尝试之前的状态</strong>。</p>
|
||||
<p>观察该过程，<strong>我们可以将尝试和回退理解为“前进”与“撤销”</strong>，两个操作是互为逆向的。</p>
|
||||
<p>观察下图所示的过程，<strong>我们可以将尝试和回退理解为“前进”与“撤销”</strong>，两个操作是互为逆向的。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:11"><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" /><div class="tabbed-labels"><label for="__tabbed_3_1"><1></label><label for="__tabbed_3_2"><2></label><label for="__tabbed_3_3"><3></label><label for="__tabbed_3_4"><4></label><label for="__tabbed_3_5"><5></label><label for="__tabbed_3_6"><6></label><label for="__tabbed_3_7"><7></label><label for="__tabbed_3_8"><8></label><label for="__tabbed_3_9"><9></label><label for="__tabbed_3_10"><10></label><label for="__tabbed_3_11"><11></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4189,7 +4189,7 @@
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>剪枝是一个非常形象的名词。在搜索过程中，<strong>我们“剪掉”了不满足约束条件的搜索分支</strong>，避免许多无意义的尝试，从而实现搜索效率的提高。</p>
|
||||
<p>剪枝是一个非常形象的名词。如下图所示，在搜索过程中，<strong>我们“剪掉”了不满足约束条件的搜索分支</strong>，避免许多无意义的尝试，从而提高了搜索效率。</p>
|
||||
<p><img alt="根据约束条件剪枝" src="../backtracking_algorithm.assets/preorder_find_constrained_paths.png" /></p>
|
||||
<p align="center"> 图：根据约束条件剪枝 </p>
|
||||
|
||||
|
|
@ -5003,7 +5003,7 @@
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>根据题意，当找到值为 7 的节点后应该继续搜索，<strong>因此我们需要将记录解之后的 <code>return</code> 语句删除</strong>。下图对比了保留或删除 <code>return</code> 语句的搜索过程。</p>
|
||||
<p>根据题意，我们在找到值为 7 的节点后应该继续搜索，<strong>因此需要将记录解之后的 <code>return</code> 语句删除</strong>。下图对比了保留或删除 <code>return</code> 语句的搜索过程。</p>
|
||||
<p><img alt="保留与删除 return 的搜索过程对比" src="../backtracking_algorithm.assets/backtrack_remove_return_or_not.png" /></p>
|
||||
<p align="center"> 图：保留与删除 return 的搜索过程对比 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3434,7 +3434,7 @@
|
|||
<p><img alt="4 皇后问题的解" src="../n_queens_problem.assets/solution_4_queens.png" /></p>
|
||||
<p align="center"> 图：4 皇后问题的解 </p>
|
||||
|
||||
<p>本题共包含三个约束条件：<strong>多个皇后不能在同一行、同一列、同一对角线</strong>。值得注意的是，对角线分为主对角线 <code>\</code> 和次对角线 <code>/</code> 两种。</p>
|
||||
<p>下图展示了本题的三个约束条件：<strong>多个皇后不能在同一行、同一列、同一对角线</strong>。值得注意的是，对角线分为主对角线 <code>\</code> 和次对角线 <code>/</code> 两种。</p>
|
||||
<p><img alt="n 皇后问题的约束条件" src="../n_queens_problem.assets/n_queens_constraints.png" /></p>
|
||||
<p align="center"> 图：n 皇后问题的约束条件 </p>
|
||||
|
||||
|
|
@ -3449,8 +3449,8 @@
|
|||
<h3 id="2">2. 列与对角线剪枝<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>为了满足列约束，我们可以利用一个长度为 <span class="arithmatex">\(n\)</span> 的布尔型数组 <code>cols</code> 记录每一列是否有皇后。在每次决定放置前，我们通过 <code>cols</code> 将已有皇后的列进行剪枝，并在回溯中动态更新 <code>cols</code> 的状态。</p>
|
||||
<p>那么，如何处理对角线约束呢？设棋盘中某个格子的行列索引为 <span class="arithmatex">\((row, col)\)</span> ，选定矩阵中的某条主对角线，我们发现该对角线上所有格子的行索引减列索引都相等，<strong>即对角线上所有格子的 <span class="arithmatex">\(row - col\)</span> 为恒定值</strong>。</p>
|
||||
<p>也就是说，如果两个格子满足 <span class="arithmatex">\(row_1 - col_1 = row_2 - col_2\)</span> ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助一个数组 <code>diag1</code> 来记录每条主对角线上是否有皇后。</p>
|
||||
<p>同理，<strong>次对角线上的所有格子的 <span class="arithmatex">\(row + col\)</span> 是恒定值</strong>。我们可以使用相同方法，借助数组 <code>diag2</code> 来处理次对角线约束。</p>
|
||||
<p>也就是说，如果两个格子满足 <span class="arithmatex">\(row_1 - col_1 = row_2 - col_2\)</span> ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助下图所示的数组 <code>diag1</code> ，记录每条主对角线上是否有皇后。</p>
|
||||
<p>同理，<strong>次对角线上的所有格子的 <span class="arithmatex">\(row + col\)</span> 是恒定值</strong>。我们同样也可以借助数组 <code>diag2</code> 来处理次对角线约束。</p>
|
||||
<p><img alt="处理列约束和对角线约束" src="../n_queens_problem.assets/n_queens_cols_diagonals.png" /></p>
|
||||
<p align="center"> 图：处理列约束和对角线约束 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3968,8 +3968,8 @@
|
|||
|
||||
<p>那么如何去除重复的排列呢？最直接地，考虑借助一个哈希表，直接对排列结果进行去重。然而这样做不够优雅，<strong>因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝</strong>，这样可以进一步提升算法效率。</p>
|
||||
<h3 id="1_1">1. 相等元素剪枝<a class="headerlink" href="#1_1" title="Permanent link">¶</a></h3>
|
||||
<p>观察发现，在第一轮中，选择 <span class="arithmatex">\(1\)</span> 或选择 <span class="arithmatex">\(\hat{1}\)</span> 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 <span class="arithmatex">\(\hat{1}\)</span> 剪枝掉。</p>
|
||||
<p>同理，在第一轮选择 <span class="arithmatex">\(2\)</span> 后，第二轮选择中的 <span class="arithmatex">\(1\)</span> 和 <span class="arithmatex">\(\hat{1}\)</span> 也会产生重复分支，因此也应将第二轮的 <span class="arithmatex">\(\hat{1}\)</span> 剪枝。</p>
|
||||
<p>观察下图，在第一轮中，选择 <span class="arithmatex">\(1\)</span> 或选择 <span class="arithmatex">\(\hat{1}\)</span> 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 <span class="arithmatex">\(\hat{1}\)</span> 剪枝掉。</p>
|
||||
<p>同理，在第一轮选择 <span class="arithmatex">\(2\)</span> 之后，第二轮选择中的 <span class="arithmatex">\(1\)</span> 和 <span class="arithmatex">\(\hat{1}\)</span> 也会产生重复分支，因此也应将第二轮的 <span class="arithmatex">\(\hat{1}\)</span> 剪枝。</p>
|
||||
<p>本质上看，<strong>我们的目标是在某一轮选择中，保证多个相等的元素仅被选择一次</strong>。</p>
|
||||
<p><img alt="重复排列剪枝" src="../permutations_problem.assets/permutations_ii_pruning.png" /></p>
|
||||
<p align="center"> 图：重复排列剪枝 </p>
|
||||
|
|
|
|||
|
|
@ -3926,11 +3926,11 @@
|
|||
<li>第一轮和第二轮分别选择 <span class="arithmatex">\(3\)</span> , <span class="arithmatex">\(4\)</span> ，会生成包含这两个元素的所有子集，记为 <span class="arithmatex">\([3, 4, \dots]\)</span> 。</li>
|
||||
<li>若第一轮选择 <span class="arithmatex">\(4\)</span> ，<strong>则第二轮应该跳过 <span class="arithmatex">\(3\)</span></strong> ，因为该选择产生的子集 <span class="arithmatex">\([4, 3, \dots]\)</span> 和 <code>1.</code> 中生成的子集完全重复。</li>
|
||||
</ol>
|
||||
<p>分支越靠右，需要排除的分支也越多，例如：</p>
|
||||
<p>如下图所示，每一层的选择都是从左到右被逐个尝试的，因此越靠右剪枝越多。</p>
|
||||
<ol>
|
||||
<li>前两轮选择 <span class="arithmatex">\(3\)</span> , <span class="arithmatex">\(5\)</span> ，生成子集 <span class="arithmatex">\([3, 5, \dots]\)</span> 。</li>
|
||||
<li>前两轮选择 <span class="arithmatex">\(4\)</span> , <span class="arithmatex">\(5\)</span> ，生成子集 <span class="arithmatex">\([4, 5, \dots]\)</span> 。</li>
|
||||
<li>若第一轮选择 <span class="arithmatex">\(5\)</span> ，<strong>则第二轮应该跳过 <span class="arithmatex">\(3\)</span> 和 <span class="arithmatex">\(4\)</span></strong> ，因为子集 <span class="arithmatex">\([5, 3, \dots]\)</span> 和子集 <span class="arithmatex">\([5, 4, \dots]\)</span> 和 <code>1.</code> , <code>2.</code> 中生成的子集完全重复。</li>
|
||||
<li>若第一轮选择 <span class="arithmatex">\(5\)</span> ，<strong>则第二轮应该跳过 <span class="arithmatex">\(3\)</span> 和 <span class="arithmatex">\(4\)</span></strong> ，因为子集 <span class="arithmatex">\([5, 3, \dots]\)</span> 和子集 <span class="arithmatex">\([5, 4, \dots]\)</span> 和 <code>1.</code> , <code>2.</code> 中描述的子集完全重复。</li>
|
||||
</ol>
|
||||
<p><img alt="不同选择顺序导致的重复子集" src="../subset_sum_problem.assets/subset_sum_i_pruning.png" /></p>
|
||||
<p align="center"> 图：不同选择顺序导致的重复子集 </p>
|
||||
|
|
@ -4372,7 +4372,7 @@
|
|||
<p>给定一个正整数数组 <code>nums</code> 和一个目标正整数 <code>target</code> ，请找出所有可能的组合，使得组合中的元素和等于 <code>target</code> 。<strong>给定数组可能包含重复元素，每个元素只可被选择一次</strong>。请以列表形式返回这些组合，列表中不应包含重复组合。</p>
|
||||
</div>
|
||||
<p>相比于上题，<strong>本题的输入数组可能包含重复元素</strong>，这引入了新的问题。例如，给定数组 <span class="arithmatex">\([4, \hat{4}, 5]\)</span> 和目标元素 <span class="arithmatex">\(9\)</span> ，则现有代码的输出结果为 <span class="arithmatex">\([4, 5], [\hat{4}, 5]\)</span> ，出现了重复子集。</p>
|
||||
<p><strong>造成这种重复的原因是相等元素在某轮中被多次选择</strong>。如下图所示，第一轮共有三个选择，其中两个都为 <span class="arithmatex">\(4\)</span> ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 <span class="arithmatex">\(4\)</span> 也会产生重复子集。</p>
|
||||
<p><strong>造成这种重复的原因是相等元素在某轮中被多次选择</strong>。在下图中，第一轮共有三个选择，其中两个都为 <span class="arithmatex">\(4\)</span> ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 <span class="arithmatex">\(4\)</span> 也会产生重复子集。</p>
|
||||
<p><img alt="相等元素导致的重复子集" src="../subset_sum_problem.assets/subset_sum_ii_repeat.png" /></p>
|
||||
<p align="center"> 图：相等元素导致的重复子集 </p>
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
Before Width: | Height: | Size: 73 KiB After Width: | Height: | Size: 72 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 78 KiB After Width: | Height: | Size: 82 KiB |
|
|
@ -4123,7 +4123,7 @@ O(1) < O(\log n) < O(n) < O(n^2) < O(2^n) \newline
|
|||
</div>
|
||||
<h3 id="1-o1">1. 常数阶 <span class="arithmatex">\(O(1)\)</span><a class="headerlink" href="#1-o1" title="Permanent link">¶</a></h3>
|
||||
<p>常数阶常见于数量与输入数据大小 <span class="arithmatex">\(n\)</span> 无关的常量、变量、对象。</p>
|
||||
<p>需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 <span class="arithmatex">\(O(1)\)</span> ：</p>
|
||||
<p>需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，因此不会累积占用空间，空间复杂度仍为 <span class="arithmatex">\(O(1)\)</span> ：</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:12"><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" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><input id="__tabbed_4_12" 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">JS</label><label for="__tabbed_4_6">TS</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><label for="__tabbed_4_11">Dart</label><label for="__tabbed_4_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4675,7 +4675,7 @@ O(1) < O(\log n) < O(n) < O(n^2) < O(2^n) \newline
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>以下函数的递归深度为 <span class="arithmatex">\(n\)</span> ，即同时存在 <span class="arithmatex">\(n\)</span> 个未返回的 <code>linear_recur()</code> 函数，使用 <span class="arithmatex">\(O(n)\)</span> 大小的栈帧空间：</p>
|
||||
<p>如下图所示，此函数的递归深度为 <span class="arithmatex">\(n\)</span> ，即同时存在 <span class="arithmatex">\(n\)</span> 个未返回的 <code>linear_recur()</code> 函数，使用 <span class="arithmatex">\(O(n)\)</span> 大小的栈帧空间：</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="6:12"><input checked="checked" id="__tabbed_6_1" name="__tabbed_6" type="radio" /><input id="__tabbed_6_2" name="__tabbed_6" type="radio" /><input id="__tabbed_6_3" name="__tabbed_6" type="radio" /><input id="__tabbed_6_4" name="__tabbed_6" type="radio" /><input id="__tabbed_6_5" name="__tabbed_6" type="radio" /><input id="__tabbed_6_6" name="__tabbed_6" type="radio" /><input id="__tabbed_6_7" name="__tabbed_6" type="radio" /><input id="__tabbed_6_8" name="__tabbed_6" type="radio" /><input id="__tabbed_6_9" name="__tabbed_6" type="radio" /><input id="__tabbed_6_10" name="__tabbed_6" type="radio" /><input id="__tabbed_6_11" name="__tabbed_6" type="radio" /><input id="__tabbed_6_12" name="__tabbed_6" type="radio" /><div class="tabbed-labels"><label for="__tabbed_6_1">Java</label><label for="__tabbed_6_2">C++</label><label for="__tabbed_6_3">Python</label><label for="__tabbed_6_4">Go</label><label for="__tabbed_6_5">JS</label><label for="__tabbed_6_6">TS</label><label for="__tabbed_6_7">C</label><label for="__tabbed_6_8">C#</label><label for="__tabbed_6_9">Swift</label><label for="__tabbed_6_10">Zig</label><label for="__tabbed_6_11">Dart</label><label for="__tabbed_6_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4992,7 +4992,7 @@ O(1) < O(\log n) < O(n) < O(n^2) < O(2^n) \newline
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>以下函数的递归深度为 <span class="arithmatex">\(n\)</span> ，在每个递归函数中都初始化了一个数组，长度分别为 <span class="arithmatex">\(n, n-1, n-2, ..., 2, 1\)</span> ，平均长度为 <span class="arithmatex">\(n / 2\)</span> ，因此总体占用 <span class="arithmatex">\(O(n^2)\)</span> 空间。</p>
|
||||
<p>如下图所示，该函数的递归深度为 <span class="arithmatex">\(n\)</span> ，在每个递归函数中都初始化了一个数组，长度分别为 <span class="arithmatex">\(n, n-1, n-2, ..., 2, 1\)</span> ，平均长度为 <span class="arithmatex">\(n / 2\)</span> ，因此总体占用 <span class="arithmatex">\(O(n^2)\)</span> 空间：</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="8:12"><input checked="checked" id="__tabbed_8_1" name="__tabbed_8" type="radio" /><input id="__tabbed_8_2" name="__tabbed_8" type="radio" /><input id="__tabbed_8_3" name="__tabbed_8" type="radio" /><input id="__tabbed_8_4" name="__tabbed_8" type="radio" /><input id="__tabbed_8_5" name="__tabbed_8" type="radio" /><input id="__tabbed_8_6" name="__tabbed_8" type="radio" /><input id="__tabbed_8_7" name="__tabbed_8" type="radio" /><input id="__tabbed_8_8" name="__tabbed_8" type="radio" /><input id="__tabbed_8_9" name="__tabbed_8" type="radio" /><input id="__tabbed_8_10" name="__tabbed_8" type="radio" /><input id="__tabbed_8_11" name="__tabbed_8" type="radio" /><input id="__tabbed_8_12" name="__tabbed_8" type="radio" /><div class="tabbed-labels"><label for="__tabbed_8_1">Java</label><label for="__tabbed_8_2">C++</label><label for="__tabbed_8_3">Python</label><label for="__tabbed_8_4">Go</label><label for="__tabbed_8_5">JS</label><label for="__tabbed_8_6">TS</label><label for="__tabbed_8_7">C</label><label for="__tabbed_8_8">C#</label><label for="__tabbed_8_9">Swift</label><label for="__tabbed_8_10">Zig</label><label for="__tabbed_8_11">Dart</label><label for="__tabbed_8_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -5134,7 +5134,7 @@ O(1) < O(\log n) < O(n) < O(n^2) < O(2^n) \newline
|
|||
<p align="center"> 图：递归函数产生的平方阶空间复杂度 </p>
|
||||
|
||||
<h3 id="4-o2n">4. 指数阶 <span class="arithmatex">\(O(2^n)\)</span><a class="headerlink" href="#4-o2n" title="Permanent link">¶</a></h3>
|
||||
<p>指数阶常见于二叉树。高度为 <span class="arithmatex">\(n\)</span> 的“满二叉树”的节点数量为 <span class="arithmatex">\(2^n - 1\)</span> ，占用 <span class="arithmatex">\(O(2^n)\)</span> 空间：</p>
|
||||
<p>指数阶常见于二叉树。观察下图，高度为 <span class="arithmatex">\(n\)</span> 的“满二叉树”的节点数量为 <span class="arithmatex">\(2^n - 1\)</span> ，占用 <span class="arithmatex">\(O(2^n)\)</span> 空间：</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="9:12"><input checked="checked" id="__tabbed_9_1" name="__tabbed_9" type="radio" /><input id="__tabbed_9_2" name="__tabbed_9" type="radio" /><input id="__tabbed_9_3" name="__tabbed_9" type="radio" /><input id="__tabbed_9_4" name="__tabbed_9" type="radio" /><input id="__tabbed_9_5" name="__tabbed_9" type="radio" /><input id="__tabbed_9_6" name="__tabbed_9" type="radio" /><input id="__tabbed_9_7" name="__tabbed_9" type="radio" /><input id="__tabbed_9_8" name="__tabbed_9" type="radio" /><input id="__tabbed_9_9" name="__tabbed_9" type="radio" /><input id="__tabbed_9_10" name="__tabbed_9" type="radio" /><input id="__tabbed_9_11" name="__tabbed_9" type="radio" /><input id="__tabbed_9_12" name="__tabbed_9" type="radio" /><div class="tabbed-labels"><label for="__tabbed_9_1">Java</label><label for="__tabbed_9_2">C++</label><label for="__tabbed_9_3">Python</label><label for="__tabbed_9_4">Go</label><label for="__tabbed_9_5">JS</label><label for="__tabbed_9_6">TS</label><label for="__tabbed_9_7">C</label><label for="__tabbed_9_8">C#</label><label for="__tabbed_9_9">Swift</label><label for="__tabbed_9_10">Zig</label><label for="__tabbed_9_11">Dart</label><label for="__tabbed_9_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3982,9 +3982,12 @@
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>算法 <code>A</code> 只有 <span class="arithmatex">\(1\)</span> 个打印操作，算法运行时间不随着 <span class="arithmatex">\(n\)</span> 增大而增长。我们称此算法的时间复杂度为“常数阶”。</p>
|
||||
<p>算法 <code>B</code> 中的打印操作需要循环 <span class="arithmatex">\(n\)</span> 次，算法运行时间随着 <span class="arithmatex">\(n\)</span> 增大呈线性增长。此算法的时间复杂度被称为“线性阶”。</p>
|
||||
<p>算法 <code>C</code> 中的打印操作需要循环 <span class="arithmatex">\(1000000\)</span> 次，虽然运行时间很长，但它与输入数据大小 <span class="arithmatex">\(n\)</span> 无关。因此 <code>C</code> 的时间复杂度和 <code>A</code> 相同，仍为“常数阶”。</p>
|
||||
<p>下图展示了以上三个算法函数的时间复杂度。</p>
|
||||
<ul>
|
||||
<li>算法 <code>A</code> 只有 <span class="arithmatex">\(1\)</span> 个打印操作，算法运行时间不随着 <span class="arithmatex">\(n\)</span> 增大而增长。我们称此算法的时间复杂度为“常数阶”。</li>
|
||||
<li>算法 <code>B</code> 中的打印操作需要循环 <span class="arithmatex">\(n\)</span> 次，算法运行时间随着 <span class="arithmatex">\(n\)</span> 增大呈线性增长。此算法的时间复杂度被称为“线性阶”。</li>
|
||||
<li>算法 <code>C</code> 中的打印操作需要循环 <span class="arithmatex">\(1000000\)</span> 次，虽然运行时间很长，但它与输入数据大小 <span class="arithmatex">\(n\)</span> 无关。因此 <code>C</code> 的时间复杂度和 <code>A</code> 相同，仍为“常数阶”。</li>
|
||||
</ul>
|
||||
<p><img alt="算法 A 、B 和 C 的时间增长趋势" src="../time_complexity.assets/time_complexity_simple_example.png" /></p>
|
||||
<p align="center"> 图：算法 A 、B 和 C 的时间增长趋势 </p>
|
||||
|
||||
|
|
@ -4370,7 +4373,7 @@ T(n) & = n^2 + n & \text{偷懒统计 (o.O)}
|
|||
</div>
|
||||
<h3 id="2">2. 第二步：判断渐近上界<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p><strong>时间复杂度由多项式 <span class="arithmatex">\(T(n)\)</span> 中最高阶的项来决定</strong>。这是因为在 <span class="arithmatex">\(n\)</span> 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。</p>
|
||||
<p>以下表格展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 <span class="arithmatex">\(n\)</span> 趋于无穷大时，这些常数变得无足轻重。</p>
|
||||
<p>下表展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 <span class="arithmatex">\(n\)</span> 趋于无穷大时，这些常数变得无足轻重。</p>
|
||||
<p align="center"> 表：不同操作数量对应的时间复杂度 </p>
|
||||
|
||||
<div class="center-table">
|
||||
|
|
@ -4406,7 +4409,7 @@ T(n) & = n^2 + n & \text{偷懒统计 (o.O)}
|
|||
</table>
|
||||
</div>
|
||||
<h2 id="224">2.2.4 常见类型<a class="headerlink" href="#224" title="Permanent link">¶</a></h2>
|
||||
<p>设输入数据大小为 <span class="arithmatex">\(n\)</span> ，常见的时间复杂度类型包括（按照从低到高的顺序排列）：</p>
|
||||
<p>设输入数据大小为 <span class="arithmatex">\(n\)</span> ，常见的时间复杂度类型如下图所示（按照从低到高的顺序排列）。</p>
|
||||
<div class="arithmatex">\[
|
||||
\begin{aligned}
|
||||
O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!) \newline
|
||||
|
|
@ -5275,7 +5278,8 @@ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="4-o2n">4. 指数阶 <span class="arithmatex">\(O(2^n)\)</span><a class="headerlink" href="#4-o2n" title="Permanent link">¶</a></h3>
|
||||
<p>生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 <span class="arithmatex">\(1\)</span> 个细胞，分裂一轮后变为 <span class="arithmatex">\(2\)</span> 个，分裂两轮后变为 <span class="arithmatex">\(4\)</span> 个，以此类推，分裂 <span class="arithmatex">\(n\)</span> 轮后有 <span class="arithmatex">\(2^n\)</span> 个细胞。相关代码如下：</p>
|
||||
<p>生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 <span class="arithmatex">\(1\)</span> 个细胞，分裂一轮后变为 <span class="arithmatex">\(2\)</span> 个，分裂两轮后变为 <span class="arithmatex">\(4\)</span> 个，以此类推，分裂 <span class="arithmatex">\(n\)</span> 轮后有 <span class="arithmatex">\(2^n\)</span> 个细胞。</p>
|
||||
<p>以下代码和图模拟了细胞分裂的过程，时间复杂度为 <span class="arithmatex">\(O(2^n)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="10:12"><input checked="checked" id="__tabbed_10_1" name="__tabbed_10" type="radio" /><input id="__tabbed_10_2" name="__tabbed_10" type="radio" /><input id="__tabbed_10_3" name="__tabbed_10" type="radio" /><input id="__tabbed_10_4" name="__tabbed_10" type="radio" /><input id="__tabbed_10_5" name="__tabbed_10" type="radio" /><input id="__tabbed_10_6" name="__tabbed_10" type="radio" /><input id="__tabbed_10_7" name="__tabbed_10" type="radio" /><input id="__tabbed_10_8" name="__tabbed_10" type="radio" /><input id="__tabbed_10_9" name="__tabbed_10" type="radio" /><input id="__tabbed_10_10" name="__tabbed_10" type="radio" /><input id="__tabbed_10_11" name="__tabbed_10" type="radio" /><input id="__tabbed_10_12" name="__tabbed_10" type="radio" /><div class="tabbed-labels"><label for="__tabbed_10_1">Java</label><label for="__tabbed_10_2">C++</label><label for="__tabbed_10_3">Python</label><label for="__tabbed_10_4">Go</label><label for="__tabbed_10_5">JS</label><label for="__tabbed_10_6">TS</label><label for="__tabbed_10_7">C</label><label for="__tabbed_10_8">C#</label><label for="__tabbed_10_9">Swift</label><label for="__tabbed_10_10">Zig</label><label for="__tabbed_10_11">Dart</label><label for="__tabbed_10_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -5478,11 +5482,10 @@ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>下图展示了细胞分裂的过程。</p>
|
||||
<p><img alt="指数阶的时间复杂度" src="../time_complexity.assets/time_complexity_exponential.png" /></p>
|
||||
<p align="center"> 图：指数阶的时间复杂度 </p>
|
||||
|
||||
<p>在实际算法中，指数阶常出现于递归函数中。例如以下代码，其递归地一分为二，经过 <span class="arithmatex">\(n\)</span> 次分裂后停止：</p>
|
||||
<p>在实际算法中，指数阶常出现于递归函数中。例如在以下代码中，其递归地一分为二，经过 <span class="arithmatex">\(n\)</span> 次分裂后停止：</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="11:12"><input checked="checked" id="__tabbed_11_1" name="__tabbed_11" type="radio" /><input id="__tabbed_11_2" name="__tabbed_11" type="radio" /><input id="__tabbed_11_3" name="__tabbed_11" type="radio" /><input id="__tabbed_11_4" name="__tabbed_11" type="radio" /><input id="__tabbed_11_5" name="__tabbed_11" type="radio" /><input id="__tabbed_11_6" name="__tabbed_11" type="radio" /><input id="__tabbed_11_7" name="__tabbed_11" type="radio" /><input id="__tabbed_11_8" name="__tabbed_11" type="radio" /><input id="__tabbed_11_9" name="__tabbed_11" type="radio" /><input id="__tabbed_11_10" name="__tabbed_11" type="radio" /><input id="__tabbed_11_11" name="__tabbed_11" type="radio" /><input id="__tabbed_11_12" name="__tabbed_11" type="radio" /><div class="tabbed-labels"><label for="__tabbed_11_1">Java</label><label for="__tabbed_11_2">C++</label><label for="__tabbed_11_3">Python</label><label for="__tabbed_11_4">Go</label><label for="__tabbed_11_5">JS</label><label for="__tabbed_11_6">TS</label><label for="__tabbed_11_7">C</label><label for="__tabbed_11_8">C#</label><label for="__tabbed_11_9">Swift</label><label for="__tabbed_11_10">Zig</label><label for="__tabbed_11_11">Dart</label><label for="__tabbed_11_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -5594,7 +5597,8 @@ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!
|
|||
</div>
|
||||
<p>指数阶增长非常迅速，在穷举法（暴力搜索、回溯等）中比较常见。对于数据规模较大的问题，指数阶是不可接受的，通常需要使用动态规划或贪心等算法来解决。</p>
|
||||
<h3 id="5-olog-n">5. 对数阶 <span class="arithmatex">\(O(\log n)\)</span><a class="headerlink" href="#5-olog-n" title="Permanent link">¶</a></h3>
|
||||
<p>与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 <span class="arithmatex">\(n\)</span> ，由于每轮缩减到一半，因此循环次数是 <span class="arithmatex">\(\log_2 n\)</span> ，即 <span class="arithmatex">\(2^n\)</span> 的反函数。相关代码如下：</p>
|
||||
<p>与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 <span class="arithmatex">\(n\)</span> ，由于每轮缩减到一半，因此循环次数是 <span class="arithmatex">\(\log_2 n\)</span> ，即 <span class="arithmatex">\(2^n\)</span> 的反函数。</p>
|
||||
<p>以下代码和图模拟了“每轮缩减到一半”的过程，时间复杂度为 <span class="arithmatex">\(O(\log_2 n)\)</span> ，简记为 <span class="arithmatex">\(O(\log n)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="12:12"><input checked="checked" id="__tabbed_12_1" name="__tabbed_12" type="radio" /><input id="__tabbed_12_2" name="__tabbed_12" type="radio" /><input id="__tabbed_12_3" name="__tabbed_12" type="radio" /><input id="__tabbed_12_4" name="__tabbed_12" type="radio" /><input id="__tabbed_12_5" name="__tabbed_12" type="radio" /><input id="__tabbed_12_6" name="__tabbed_12" type="radio" /><input id="__tabbed_12_7" name="__tabbed_12" type="radio" /><input id="__tabbed_12_8" name="__tabbed_12" type="radio" /><input id="__tabbed_12_9" name="__tabbed_12" type="radio" /><input id="__tabbed_12_10" name="__tabbed_12" type="radio" /><input id="__tabbed_12_11" name="__tabbed_12" type="radio" /><input id="__tabbed_12_12" name="__tabbed_12" type="radio" /><div class="tabbed-labels"><label for="__tabbed_12_1">Java</label><label for="__tabbed_12_2">C++</label><label for="__tabbed_12_3">Python</label><label for="__tabbed_12_4">Go</label><label for="__tabbed_12_5">JS</label><label for="__tabbed_12_6">TS</label><label for="__tabbed_12_7">C</label><label for="__tabbed_12_8">C#</label><label for="__tabbed_12_9">Swift</label><label for="__tabbed_12_10">Zig</label><label for="__tabbed_12_11">Dart</label><label for="__tabbed_12_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -5864,7 +5868,7 @@ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!
|
|||
<div class="arithmatex">\[
|
||||
O(\log_m n) = O(\log_k n / \log_k m) = O(\log_k n)
|
||||
\]</div>
|
||||
<p>因此我们通常会省略底数 <span class="arithmatex">\(m\)</span> ，将对数阶直接记为 <span class="arithmatex">\(O(\log n)\)</span> 。</p>
|
||||
<p>也就是说，底数 <span class="arithmatex">\(m\)</span> 可以在不影响复杂度的前提下转换。因此我们通常会省略底数 <span class="arithmatex">\(m\)</span> ，将对数阶直接记为 <span class="arithmatex">\(O(\log n)\)</span> 。</p>
|
||||
</div>
|
||||
<h3 id="6-on-log-n">6. 线性对数阶 <span class="arithmatex">\(O(n \log n)\)</span><a class="headerlink" href="#6-on-log-n" title="Permanent link">¶</a></h3>
|
||||
<p>线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 <span class="arithmatex">\(O(\log n)\)</span> 和 <span class="arithmatex">\(O(n)\)</span> 。相关代码如下：</p>
|
||||
|
|
@ -6030,6 +6034,7 @@ O(\log_m n) = O(\log_k n / \log_k m) = O(\log_k n)
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>下图展示了线性对数阶的生成方式。二叉树的每一层的操作总数都为 <span class="arithmatex">\(n\)</span> ，树共有 <span class="arithmatex">\(\log_2 n + 1\)</span> 层，因此时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> 。</p>
|
||||
<p><img alt="线性对数阶的时间复杂度" src="../time_complexity.assets/time_complexity_logarithmic_linear.png" /></p>
|
||||
<p align="center"> 图：线性对数阶的时间复杂度 </p>
|
||||
|
||||
|
|
@ -6039,7 +6044,7 @@ O(\log_m n) = O(\log_k n / \log_k m) = O(\log_k n)
|
|||
<div class="arithmatex">\[
|
||||
n! = n \times (n - 1) \times (n - 2) \times \dots \times 2 \times 1
|
||||
\]</div>
|
||||
<p>阶乘通常使用递归实现。例如在以下代码中，第一层分裂出 <span class="arithmatex">\(n\)</span> 个，第二层分裂出 <span class="arithmatex">\(n - 1\)</span> 个，以此类推，直至第 <span class="arithmatex">\(n\)</span> 层时停止分裂：</p>
|
||||
<p>阶乘通常使用递归实现。如下图和以下代码所示，第一层分裂出 <span class="arithmatex">\(n\)</span> 个，第二层分裂出 <span class="arithmatex">\(n - 1\)</span> 个，以此类推，直至第 <span class="arithmatex">\(n\)</span> 层时停止分裂：</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="15:12"><input checked="checked" id="__tabbed_15_1" name="__tabbed_15" type="radio" /><input id="__tabbed_15_2" name="__tabbed_15" type="radio" /><input id="__tabbed_15_3" name="__tabbed_15" type="radio" /><input id="__tabbed_15_4" name="__tabbed_15" type="radio" /><input id="__tabbed_15_5" name="__tabbed_15" type="radio" /><input id="__tabbed_15_6" name="__tabbed_15" type="radio" /><input id="__tabbed_15_7" name="__tabbed_15" type="radio" /><input id="__tabbed_15_8" name="__tabbed_15" type="radio" /><input id="__tabbed_15_9" name="__tabbed_15" type="radio" /><input id="__tabbed_15_10" name="__tabbed_15" type="radio" /><input id="__tabbed_15_11" name="__tabbed_15" type="radio" /><input id="__tabbed_15_12" name="__tabbed_15" type="radio" /><div class="tabbed-labels"><label for="__tabbed_15_1">Java</label><label for="__tabbed_15_2">C++</label><label for="__tabbed_15_3">Python</label><label for="__tabbed_15_4">Go</label><label for="__tabbed_15_5">JS</label><label for="__tabbed_15_6">TS</label><label for="__tabbed_15_7">C</label><label for="__tabbed_15_8">C#</label><label for="__tabbed_15_9">Swift</label><label for="__tabbed_15_10">Zig</label><label for="__tabbed_15_11">Dart</label><label for="__tabbed_15_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3456,7 +3456,7 @@
|
|||
<h1 id="34">3.4 字符编码 *<a class="headerlink" href="#34" title="Permanent link">¶</a></h1>
|
||||
<p>在计算机中，所有数据都是以二进制数的形式存储的，字符 <code>char</code> 也不例外。为了表示字符，我们需要建立一套“字符集”，规定每个字符和二进制数之间的一一对应关系。有了字符集之后，计算机就可以通过查表完成二进制数到字符的转换。</p>
|
||||
<h2 id="341-ascii">3.4.1 ASCII 字符集<a class="headerlink" href="#341-ascii" title="Permanent link">¶</a></h2>
|
||||
<p>「ASCII 码」是最早出现的字符集，全称为“美国标准信息交换代码”。它使用 7 位二进制数（即一个字节的低 7 位）表示一个字符，最多能够表示 128 个不同的字符。这包括英文字母的大小写、数字 0-9 、一些标点符号，以及一些控制字符（如换行符和制表符）。</p>
|
||||
<p>「ASCII 码」是最早出现的字符集，全称为“美国标准信息交换代码”。它使用 7 位二进制数（即一个字节的低 7 位）表示一个字符，最多能够表示 128 个不同的字符。如下图所示，ASCII 码包括英文字母的大小写、数字 0-9 、一些标点符号，以及一些控制字符（如换行符和制表符）。</p>
|
||||
<p><img alt="ASCII 码" src="../character_encoding.assets/ascii_table.png" /></p>
|
||||
<p align="center"> 图：ASCII 码 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3415,7 +3415,7 @@
|
|||
<p>常见的数据结构包括数组、链表、栈、队列、哈希表、树、堆、图，它们可以从“逻辑结构”和“物理结构”两个维度进行分类。</p>
|
||||
<h2 id="311">3.1.1 逻辑结构：线性与非线性<a class="headerlink" href="#311" title="Permanent link">¶</a></h2>
|
||||
<p><strong>逻辑结构揭示了数据元素之间的逻辑关系</strong>。在数组和链表中，数据按照顺序依次排列，体现了数据之间的线性关系；而在树中，数据从顶部向下按层次排列，表现出祖先与后代之间的派生关系；图则由节点和边构成，反映了复杂的网络关系。</p>
|
||||
<p>逻辑结构可被分为“线性”和“非线性”两大类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列。</p>
|
||||
<p>如下图所示，逻辑结构可被分为“线性”和“非线性”两大类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列。</p>
|
||||
<ul>
|
||||
<li><strong>线性数据结构</strong>：数组、链表、栈、队列、哈希表。</li>
|
||||
<li><strong>非线性数据结构</strong>：树、堆、图、哈希表。</li>
|
||||
|
|
@ -3432,12 +3432,12 @@
|
|||
<h2 id="312">3.1.2 物理结构：连续与离散<a class="headerlink" href="#312" title="Permanent link">¶</a></h2>
|
||||
<p>在计算机中，内存和硬盘是两种主要的存储硬件设备。硬盘主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。内存用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。</p>
|
||||
<p><strong>在算法运行过程中，相关数据都存储在内存中</strong>。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储一定大小的数据，在算法运行时，所有数据都被存储在这些单元格中。</p>
|
||||
<p><strong>系统通过内存地址来访问目标位置的数据</strong>。计算机根据特定规则为表格中的每个单元格分配编号，确保每个内存空间都有唯一的内存地址。有了这些地址，程序便可以访问内存中的数据。</p>
|
||||
<p><strong>系统通过内存地址来访问目标位置的数据</strong>。如下图所示，计算机根据特定规则为表格中的每个单元格分配编号，确保每个内存空间都有唯一的内存地址。有了这些地址，程序便可以访问内存中的数据。</p>
|
||||
<p><img alt="内存条、内存空间、内存地址" src="../classification_of_data_structure.assets/computer_memory_location.png" /></p>
|
||||
<p align="center"> 图：内存条、内存空间、内存地址 </p>
|
||||
|
||||
<p>内存是所有程序的共享资源，当某块内存被某个程序占用时，则无法被其他程序同时使用了。<strong>因此在数据结构与算法的设计中，内存资源是一个重要的考虑因素</strong>。比如，算法所占用的内存峰值不应超过系统剩余空闲内存；如果缺少连续大块的内存空间，那么所选用的数据结构必须能够存储在离散的内存空间内。</p>
|
||||
<p><strong>物理结构反映了数据在计算机内存中的存储方式</strong>，可分为连续空间存储（数组）和离散空间存储（链表）。物理结构从底层决定了数据的访问、更新、增删等操作方法，同时在时间效率和空间效率方面呈现出互补的特点。</p>
|
||||
<p>如下图所示，<strong>物理结构反映了数据在计算机内存中的存储方式</strong>，可分为连续空间存储（数组）和离散空间存储（链表）。物理结构从底层决定了数据的访问、更新、增删等操作方法，同时在时间效率和空间效率方面呈现出互补的特点。</p>
|
||||
<p><img alt="连续空间存储与离散空间存储" src="../classification_of_data_structure.assets/classification_phisical_structure.png" /></p>
|
||||
<p align="center"> 图：连续空间存储与离散空间存储 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3418,12 +3418,13 @@
|
|||
</div>
|
||||
<h2 id="331">3.3.1 原码、反码和补码<a class="headerlink" href="#331" title="Permanent link">¶</a></h2>
|
||||
<p>在上一节的表格中我们发现，所有整数类型能够表示的负数都比正数多一个，例如 <code>byte</code> 的取值范围是 <span class="arithmatex">\([-128, 127]\)</span> 。这个现象比较反直觉，它的内在原因涉及到原码、反码、补码的相关知识。</p>
|
||||
<p>实际上，<strong>数字是以“补码”的形式存储在计算机中的</strong>。在分析这样做的原因之前，我们首先给出三者的定义：</p>
|
||||
<p>首先需要指出，<strong>数字是以“补码”的形式存储在计算机中的</strong>。在分析这样做的原因之前，我们首先给出三者的定义：</p>
|
||||
<ul>
|
||||
<li><strong>原码</strong>：我们将数字的二进制表示的最高位视为符号位，其中 <span class="arithmatex">\(0\)</span> 表示正数，<span class="arithmatex">\(1\)</span> 表示负数，其余位表示数字的值。</li>
|
||||
<li><strong>反码</strong>：正数的反码与其原码相同，负数的反码是对其原码除符号位外的所有位取反。</li>
|
||||
<li><strong>补码</strong>：正数的补码与其原码相同，负数的补码是在其反码的基础上加 <span class="arithmatex">\(1\)</span> 。</li>
|
||||
</ul>
|
||||
<p>下图展示了原吗、反码和补码之间的转换方法。</p>
|
||||
<p><img alt="原码、反码与补码之间的相互转换" src="../number_encoding.assets/1s_2s_complement.png" /></p>
|
||||
<p align="center"> 图：原码、反码与补码之间的相互转换 </p>
|
||||
|
||||
|
|
@ -3431,9 +3432,9 @@
|
|||
<div class="arithmatex">\[
|
||||
\begin{aligned}
|
||||
& 1 + (-2) \newline
|
||||
& = 0000 \space 0001 + 1000 \space 0010 \newline
|
||||
& \rightarrow 0000 \space 0001 + 1000 \space 0010 \newline
|
||||
& = 1000 \space 0011 \newline
|
||||
& = -3
|
||||
& \rightarrow -3
|
||||
\end{aligned}
|
||||
\]</div>
|
||||
<p>为了解决此问题，计算机引入了「反码 1's complement code」。如果我们先将原码转换为反码，并在反码下计算 <span class="arithmatex">\(1 + (-2)\)</span> ，最后将结果从反码转化回原码，则可得到正确结果 <span class="arithmatex">\(-1\)</span> 。</p>
|
||||
|
|
@ -3450,14 +3451,14 @@
|
|||
<p>另一方面，<strong>数字零的原码有 <span class="arithmatex">\(+0\)</span> 和 <span class="arithmatex">\(-0\)</span> 两种表示方式</strong>。这意味着数字零对应着两个不同的二进制编码，其可能会带来歧义。比如在条件判断中，如果没有区分正零和负零，则可能会导致判断结果出错。而如果我们想要处理正零和负零歧义，则需要引入额外的判断操作，其可能会降低计算机的运算效率。</p>
|
||||
<div class="arithmatex">\[
|
||||
\begin{aligned}
|
||||
+0 & = 0000 \space 0000 \newline
|
||||
-0 & = 1000 \space 0000
|
||||
+0 & \rightarrow 0000 \space 0000 \newline
|
||||
-0 & \rightarrow 1000 \space 0000
|
||||
\end{aligned}
|
||||
\]</div>
|
||||
<p>与原码一样，反码也存在正负零歧义问题，因此计算机进一步引入了「补码 2's complement code」。我们先来观察一下负零的原码、反码、补码的转换过程：</p>
|
||||
<div class="arithmatex">\[
|
||||
\begin{aligned}
|
||||
-0 = \space & 1000 \space 0000 \space \text{(原码)} \newline
|
||||
-0 \rightarrow \space & 1000 \space 0000 \space \text{(原码)} \newline
|
||||
= \space & 1111 \space 1111 \space \text{(反码)} \newline
|
||||
= 1 \space & 0000 \space 0000 \space \text{(补码)} \newline
|
||||
\end{aligned}
|
||||
|
|
@ -3506,16 +3507,16 @@ b_{31} b_{30} b_{29} \ldots b_2 b_1 b_0
|
|||
(1 + \mathrm{N}) = & (1 + \sum_{i=1}^{23} b_{23-i} 2^{-i}) \subset [1, 2 - 2^{-23}]
|
||||
\end{aligned}
|
||||
\]</div>
|
||||
<p><img alt="IEEE 754 标准下的 float 表示方式" src="../number_encoding.assets/ieee_754_float.png" /></p>
|
||||
<p align="center"> 图：IEEE 754 标准下的 float 表示方式 </p>
|
||||
<p><img alt="IEEE 754 标准下的 float 的计算示例" src="../number_encoding.assets/ieee_754_float.png" /></p>
|
||||
<p align="center"> 图：IEEE 754 标准下的 float 的计算示例 </p>
|
||||
|
||||
<p>给定一个示例数据 <span class="arithmatex">\(\mathrm{S} = 0\)</span> ， <span class="arithmatex">\(\mathrm{E} = 124\)</span> ，<span class="arithmatex">\(\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\)</span> ，则有：</p>
|
||||
<p>观察上图，给定一个示例数据 <span class="arithmatex">\(\mathrm{S} = 0\)</span> ， <span class="arithmatex">\(\mathrm{E} = 124\)</span> ，<span class="arithmatex">\(\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\)</span> ，则有：</p>
|
||||
<div class="arithmatex">\[
|
||||
\text { val } = (-1)^0 \times 2^{124 - 127} \times (1 + 0.375) = 0.171875
|
||||
\]</div>
|
||||
<p>现在我们可以回答最初的问题：<strong><code>float</code> 的表示方式包含指数位，导致其取值范围远大于 <code>int</code></strong> 。根据以上计算，<code>float</code> 可表示的最大正数为 <span class="arithmatex">\(2^{254 - 127} \times (2 - 2^{-23}) \approx 3.4 \times 10^{38}\)</span> ，切换符号位便可得到最小负数。</p>
|
||||
<p><strong>尽管浮点数 <code>float</code> 扩展了取值范围，但其副作用是牺牲了精度</strong>。整数类型 <code>int</code> 将全部 32 位用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 <code>float</code> 的数值越大，相邻两个数字之间的差值就会趋向越大。</p>
|
||||
<p>进一步地，指数位 <span class="arithmatex">\(E = 0\)</span> 和 <span class="arithmatex">\(E = 255\)</span> 具有特殊含义，<strong>用于表示零、无穷大、<span class="arithmatex">\(\mathrm{NaN}\)</span> 等</strong>。</p>
|
||||
<p>如下表所示，指数位 <span class="arithmatex">\(E = 0\)</span> 和 <span class="arithmatex">\(E = 255\)</span> 具有特殊含义，<strong>用于表示零、无穷大、<span class="arithmatex">\(\mathrm{NaN}\)</span> 等</strong>。</p>
|
||||
<p align="center"> 表：指数位含义 </p>
|
||||
|
||||
<div class="center-table">
|
||||
|
|
|
|||
|
|
@ -3469,7 +3469,7 @@
|
|||
<li>前序遍历：<code>[ 根节点 | 左子树 | 右子树 ]</code> ，例如上图 <code>[ 3 | 9 | 2 1 7 ]</code> 。</li>
|
||||
<li>中序遍历：<code>[ 左子树 | 根节点 ｜ 右子树 ]</code> ，例如上图 <code>[ 9 | 3 | 1 2 7 ]</code> 。</li>
|
||||
</ul>
|
||||
<p>以上图数据为例，我们可以通过以下步骤得到上述的划分结果：</p>
|
||||
<p>以上图数据为例，我们可以通过下图所示的步骤得到划分结果：</p>
|
||||
<ol>
|
||||
<li>前序遍历的首元素 3 是根节点的值。</li>
|
||||
<li>查找根节点 3 在 <code>inorder</code> 中的索引，利用该索引可将 <code>inorder</code> 划分为 <code>[ 9 | 3 ｜ 1 2 7 ]</code> 。</li>
|
||||
|
|
|
|||
|
|
@ -3479,7 +3479,7 @@
|
|||
<li><strong>分（划分阶段）</strong>：递归地将原问题分解为两个或多个子问题，直至到达最小子问题时终止。</li>
|
||||
<li><strong>治（合并阶段）</strong>：从已知解的最小子问题开始，从底至顶地将子问题的解进行合并，从而构建出原问题的解。</li>
|
||||
</ol>
|
||||
<p>我们已学过的“归并排序”是分治策略的典型应用之一，其算法原理为：</p>
|
||||
<p>如下图所示，“归并排序”是分治策略的典型应用之一，其算法原理为：</p>
|
||||
<ol>
|
||||
<li><strong>分</strong>：递归地将原数组（原问题）划分为两个子数组（子问题），直到子数组只剩一个元素（最小子问题）。</li>
|
||||
<li><strong>治</strong>：从底至顶地将有序的子数组（子问题的解）进行合并，从而得到有序的原数组（原问题的解）。</li>
|
||||
|
|
@ -3504,7 +3504,7 @@
|
|||
<p>分治不仅可以有效地解决算法问题，<strong>往往还可以带来算法效率的提升</strong>。在排序算法中，快速排序、归并排序、堆排序相较于选择、冒泡、插入排序更快，就是因为它们应用了分治策略。</p>
|
||||
<p>那么，我们不禁发问：<strong>为什么分治可以提升算法效率，其底层逻辑是什么</strong>？换句话说，将大问题分解为多个子问题、解决子问题、将子问题的解合并为原问题的解，这几步的效率为什么比直接解决原问题的效率更高？这个问题可以从操作数量和并行计算两方面来讨论。</p>
|
||||
<h3 id="1">1. 操作数量优化<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>以“冒泡排序”为例，其处理一个长度为 <span class="arithmatex">\(n\)</span> 的数组需要 <span class="arithmatex">\(O(n^2)\)</span> 时间。假设我们把数组从中点分为两个子数组，则划分需要 <span class="arithmatex">\(O(n)\)</span> 时间，排序每个子数组需要 <span class="arithmatex">\(O((n / 2)^2)\)</span> 时间，合并两个子数组需要 <span class="arithmatex">\(O(n)\)</span> 时间，总体时间复杂度为：</p>
|
||||
<p>以“冒泡排序”为例，其处理一个长度为 <span class="arithmatex">\(n\)</span> 的数组需要 <span class="arithmatex">\(O(n^2)\)</span> 时间。假设我们按照下图所示的方式，将数组从中点分为两个子数组，则划分需要 <span class="arithmatex">\(O(n)\)</span> 时间，排序每个子数组需要 <span class="arithmatex">\(O((n / 2)^2)\)</span> 时间，合并两个子数组需要 <span class="arithmatex">\(O(n)\)</span> 时间，总体时间复杂度为：</p>
|
||||
<div class="arithmatex">\[
|
||||
O(n + (\frac{n}{2})^2 \times 2 + n) = O(\frac{n^2}{2} + 2n)
|
||||
\]</div>
|
||||
|
|
@ -3525,7 +3525,7 @@ n(n - 4) & > 0
|
|||
<h3 id="2">2. 并行计算优化<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>我们知道，分治生成的子问题是相互独立的，<strong>因此通常可以并行解决</strong>。也就是说，分治不仅可以降低算法的时间复杂度，<strong>还有利于操作系统的并行优化</strong>。</p>
|
||||
<p>并行优化在多核或多处理器的环境中尤其有效，因为系统可以同时处理多个子问题，更加充分地利用计算资源，从而显著减少总体的运行时间。</p>
|
||||
<p>比如在桶排序中，我们将海量的数据平均分配到各个桶中，则可所有桶的排序任务分散到各个计算单元，完成后再进行结果合并。</p>
|
||||
<p>比如在下图所示的“桶排序”中，我们将海量的数据平均分配到各个桶中，则可所有桶的排序任务分散到各个计算单元，完成后再进行结果合并。</p>
|
||||
<p><img alt="桶排序的并行计算" src="../divide_and_conquer.assets/divide_and_conquer_parallel_computing.png" /></p>
|
||||
<p align="center"> 图：桶排序的并行计算 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3449,7 +3449,7 @@
|
|||
|
||||
<p><strong>我们将规模为 <span class="arithmatex">\(i\)</span> 的汉诺塔问题记做 <span class="arithmatex">\(f(i)\)</span></strong> 。例如 <span class="arithmatex">\(f(3)\)</span> 代表将 <span class="arithmatex">\(3\)</span> 个圆盘从 <code>A</code> 移动至 <code>C</code> 的汉诺塔问题。</p>
|
||||
<h3 id="1">1. 考虑基本情况<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>对于问题 <span class="arithmatex">\(f(1)\)</span> ，即当只有一个圆盘时，则将它直接从 <code>A</code> 移动至 <code>C</code> 即可。</p>
|
||||
<p>如下图所示，对于问题 <span class="arithmatex">\(f(1)\)</span> ，即当只有一个圆盘时，我们将它直接从 <code>A</code> 移动至 <code>C</code> 即可。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:2"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3462,13 +3462,12 @@
|
|||
</div>
|
||||
<p align="center"> 图：规模为 1 问题的解 </p>
|
||||
|
||||
<p>对于问题 <span class="arithmatex">\(f(2)\)</span> ，即当有两个圆盘时，<strong>由于要时刻满足小圆盘在大圆盘之上，因此需要借助 <code>B</code> 来完成移动</strong>，包括三步：</p>
|
||||
<p>如下图所示，对于问题 <span class="arithmatex">\(f(2)\)</span> ，即当有两个圆盘时，<strong>由于要时刻满足小圆盘在大圆盘之上，因此需要借助 <code>B</code> 来完成移动</strong>。</p>
|
||||
<ol>
|
||||
<li>先将上面的小圆盘从 <code>A</code> 移至 <code>B</code> 。</li>
|
||||
<li>再将大圆盘从 <code>A</code> 移至 <code>C</code> 。</li>
|
||||
<li>最后将小圆盘从 <code>B</code> 移至 <code>C</code> 。</li>
|
||||
</ol>
|
||||
<p>解决问题 <span class="arithmatex">\(f(2)\)</span> 的过程可总结为：<strong>将两个圆盘借助 <code>B</code> 从 <code>A</code> 移至 <code>C</code></strong> 。其中，<code>C</code> 称为目标柱、<code>B</code> 称为缓冲柱。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:4"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3487,14 +3486,15 @@
|
|||
</div>
|
||||
<p align="center"> 图：规模为 2 问题的解 </p>
|
||||
|
||||
<p>解决问题 <span class="arithmatex">\(f(2)\)</span> 的过程可总结为：<strong>将两个圆盘借助 <code>B</code> 从 <code>A</code> 移至 <code>C</code></strong> 。其中，<code>C</code> 称为目标柱、<code>B</code> 称为缓冲柱。</p>
|
||||
<h3 id="2">2. 子问题分解<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>对于问题 <span class="arithmatex">\(f(3)\)</span> ，即当有三个圆盘时，情况变得稍微复杂了一些。由于已知 <span class="arithmatex">\(f(1)\)</span> 和 <span class="arithmatex">\(f(2)\)</span> 的解，因此可从分治角度思考，<strong>将 <code>A</code> 顶部的两个圆盘看做一个整体</strong>，执行以下步骤：</p>
|
||||
<p>对于问题 <span class="arithmatex">\(f(3)\)</span> ，即当有三个圆盘时，情况变得稍微复杂了一些。</p>
|
||||
<p>因为已知 <span class="arithmatex">\(f(1)\)</span> 和 <span class="arithmatex">\(f(2)\)</span> 的解，所以我们可从分治角度思考，<strong>将 <code>A</code> 顶部的两个圆盘看做一个整体</strong>，执行下图所示的步骤。这样三个圆盘就被顺利地从 <code>A</code> 移动至 <code>C</code> 了。</p>
|
||||
<ol>
|
||||
<li>令 <code>B</code> 为目标柱、<code>C</code> 为缓冲柱，将两个圆盘从 <code>A</code> 移动至 <code>B</code> 。</li>
|
||||
<li>将 <code>A</code> 中剩余的一个圆盘从 <code>A</code> 直接移动至 <code>C</code> 。</li>
|
||||
<li>令 <code>C</code> 为目标柱、<code>A</code> 为缓冲柱，将两个圆盘从 <code>B</code> 移动至 <code>C</code> 。</li>
|
||||
</ol>
|
||||
<p>这样三个圆盘就被顺利地从 <code>A</code> 移动至 <code>C</code> 了。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:4"><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" /><div class="tabbed-labels"><label for="__tabbed_3_1"><1></label><label for="__tabbed_3_2"><2></label><label for="__tabbed_3_3"><3></label><label for="__tabbed_3_4"><4></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3514,7 +3514,7 @@
|
|||
<p align="center"> 图：规模为 3 问题的解 </p>
|
||||
|
||||
<p>本质上看，<strong>我们将问题 <span class="arithmatex">\(f(3)\)</span> 划分为两个子问题 <span class="arithmatex">\(f(2)\)</span> 和子问题 <span class="arithmatex">\(f(1)\)</span></strong> 。按顺序解决这三个子问题之后，原问题随之得到解决。这说明子问题是独立的，而且解是可以合并的。</p>
|
||||
<p>至此，我们可总结出汉诺塔问题的分治策略：将原问题 <span class="arithmatex">\(f(n)\)</span> 划分为两个子问题 <span class="arithmatex">\(f(n-1)\)</span> 和一个子问题 <span class="arithmatex">\(f(1)\)</span> 。子问题的解决顺序为：</p>
|
||||
<p>至此，我们可总结出下图所示的汉诺塔问题的分治策略：将原问题 <span class="arithmatex">\(f(n)\)</span> 划分为两个子问题 <span class="arithmatex">\(f(n-1)\)</span> 和一个子问题 <span class="arithmatex">\(f(1)\)</span> 。子问题的解决顺序为：</p>
|
||||
<ol>
|
||||
<li>将 <span class="arithmatex">\(n-1\)</span> 个圆盘借助 <code>C</code> 从 <code>A</code> 移至 <code>B</code> 。</li>
|
||||
<li>将剩余 <span class="arithmatex">\(1\)</span> 个圆盘从 <code>A</code> 直接移至 <code>C</code> 。</li>
|
||||
|
|
|
|||
|
|
@ -3353,7 +3353,7 @@
|
|||
<li>引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了操作数量；另一方面，分治后有利于系统的并行优化。</li>
|
||||
<li>分治既可以解决许多算法问题，也广泛应用于数据结构与算法设计中，处处可见其身影。</li>
|
||||
<li>相较于暴力搜索，自适应搜索效率更高。时间复杂度为 <span class="arithmatex">\(O(\log n)\)</span> 的搜索算法通常都是基于分治策略实现的。</li>
|
||||
<li>二分查找是分治思想的另一个典型应用，它不包含将子问题的解进行合并的步骤。我们可以通过递归分治实现二分查找。</li>
|
||||
<li>二分查找是分治策略的另一个典型应用，它不包含将子问题的解进行合并的步骤。我们可以通过递归分治实现二分查找。</li>
|
||||
<li>在构建二叉树问题中，构建树（原问题）可以被划分为构建左子树和右子树（子问题），其可以通过划分前序遍历和中序遍历的索引区间来实现。</li>
|
||||
<li>在汉诺塔问题中，一个规模为 <span class="arithmatex">\(n\)</span> 的问题可以被划分为两个规模为 <span class="arithmatex">\(n-1\)</span> 的子问题和一个规模为 <span class="arithmatex">\(1\)</span> 的子问题。按顺序解决这三个子问题后，原问题随之得到解决。</li>
|
||||
</ul>
|
||||
|
|
|
|||
|
|
@ -3444,7 +3444,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
|||
<p>这便可以引出最优子结构的含义：<strong>原问题的最优解是从子问题的最优解构建得来的</strong>。</p>
|
||||
<p>本题显然具有最优子结构：我们从两个子问题最优解 <span class="arithmatex">\(dp[i-1]\)</span> , <span class="arithmatex">\(dp[i-2]\)</span> 中挑选出较优的那一个，并用它构建出原问题 <span class="arithmatex">\(dp[i]\)</span> 的最优解。</p>
|
||||
<p>那么，上节的爬楼梯题目有没有最优子结构呢？它的目标是求解方案数量，看似是一个计数问题，但如果换一种问法：“求解最大方案数量”。我们意外地发现，<strong>虽然题目修改前后是等价的，但最优子结构浮现出来了</strong>：第 <span class="arithmatex">\(n\)</span> 阶最大方案数量等于第 <span class="arithmatex">\(n-1\)</span> 阶和第 <span class="arithmatex">\(n-2\)</span> 阶最大方案数量之和。所以说，最优子结构的解释方式比较灵活，在不同问题中会有不同的含义。</p>
|
||||
<p>根据状态转移方程，以及初始状态 <span class="arithmatex">\(dp[1] = cost[1]\)</span> , <span class="arithmatex">\(dp[2] = cost[2]\)</span> ，可以得出动态规划代码。</p>
|
||||
<p>根据状态转移方程，以及初始状态 <span class="arithmatex">\(dp[1] = cost[1]\)</span> , <span class="arithmatex">\(dp[2] = cost[2]\)</span> ，我们就可以得到动态规划代码。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:12"><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" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" 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">JS</label><label for="__tabbed_1_6">TS</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><label for="__tabbed_1_11">Dart</label><label for="__tabbed_1_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3630,6 +3630,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>下图展示了以上代码的动态规划过程。</p>
|
||||
<p><img alt="爬楼梯最小代价的动态规划过程" src="../dp_problem_features.assets/min_cost_cs_dp.png" /></p>
|
||||
<p align="center"> 图：爬楼梯最小代价的动态规划过程 </p>
|
||||
|
||||
|
|
@ -3801,7 +3802,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
|||
<p class="admonition-title">带约束爬楼梯</p>
|
||||
<p>给定一个共有 <span class="arithmatex">\(n\)</span> 阶的楼梯，你每步可以上 <span class="arithmatex">\(1\)</span> 阶或者 <span class="arithmatex">\(2\)</span> 阶，<strong>但不能连续两轮跳 <span class="arithmatex">\(1\)</span> 阶</strong>，请问有多少种方案可以爬到楼顶。</p>
|
||||
</div>
|
||||
<p>例如，爬上第 <span class="arithmatex">\(3\)</span> 阶仅剩 <span class="arithmatex">\(2\)</span> 种可行方案，其中连续三次跳 <span class="arithmatex">\(1\)</span> 阶的方案不满足约束条件，因此被舍弃。</p>
|
||||
<p>例如下图，爬上第 <span class="arithmatex">\(3\)</span> 阶仅剩 <span class="arithmatex">\(2\)</span> 种可行方案，其中连续三次跳 <span class="arithmatex">\(1\)</span> 阶的方案不满足约束条件，因此被舍弃。</p>
|
||||
<p><img alt="带约束爬到第 3 阶的方案数量" src="../dp_problem_features.assets/climbing_stairs_constraint_example.png" /></p>
|
||||
<p align="center"> 图：带约束爬到第 3 阶的方案数量 </p>
|
||||
|
||||
|
|
@ -3812,7 +3813,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
|||
<li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(1\)</span> ，即上一轮跳了 <span class="arithmatex">\(1\)</span> 阶时，这一轮只能选择跳 <span class="arithmatex">\(2\)</span> 阶。</li>
|
||||
<li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(2\)</span> ，即上一轮跳了 <span class="arithmatex">\(2\)</span> 阶时，这一轮可选择跳 <span class="arithmatex">\(1\)</span> 阶或跳 <span class="arithmatex">\(2\)</span> 阶。</li>
|
||||
</ul>
|
||||
<p>在该定义下，<span class="arithmatex">\(dp[i, j]\)</span> 表示状态 <span class="arithmatex">\([i, j]\)</span> 对应的方案数。在该定义下的状态转移方程为：</p>
|
||||
<p>如下图所示，在该定义下，<span class="arithmatex">\(dp[i, j]\)</span> 表示状态 <span class="arithmatex">\([i, j]\)</span> 对应的方案数。此时状态转移方程为：</p>
|
||||
<div class="arithmatex">\[
|
||||
\begin{cases}
|
||||
dp[i, 1] = dp[i-1, 2] \\
|
||||
|
|
|
|||
|
|
@ -3515,14 +3515,14 @@
|
|||
<p class="admonition-title">Question</p>
|
||||
<p>给定一个 <span class="arithmatex">\(n \times m\)</span> 的二维网格 <code>grid</code> ，网格中的每个单元格包含一个非负整数，表示该单元格的代价。机器人以左上角单元格为起始点，每次只能向下或者向右移动一步，直至到达右下角单元格。请返回从左上角到右下角的最小路径和。</p>
|
||||
</div>
|
||||
<p>例如以下示例数据，给定网格的最小路径和为 <span class="arithmatex">\(13\)</span> 。</p>
|
||||
<p>下图展示了一个例子，给定网格的最小路径和为 <span class="arithmatex">\(13\)</span> 。</p>
|
||||
<p><img alt="最小路径和示例数据" src="../dp_solution_pipeline.assets/min_path_sum_example.png" /></p>
|
||||
<p align="center"> 图：最小路径和示例数据 </p>
|
||||
|
||||
<p><strong>第一步：思考每轮的决策，定义状态，从而得到 <span class="arithmatex">\(dp\)</span> 表</strong></p>
|
||||
<p>本题的每一轮的决策就是从当前格子向下或向右一步。设当前格子的行列索引为 <span class="arithmatex">\([i, j]\)</span> ，则向下或向右走一步后，索引变为 <span class="arithmatex">\([i+1, j]\)</span> 或 <span class="arithmatex">\([i, j+1]\)</span> 。因此，状态应包含行索引和列索引两个变量，记为 <span class="arithmatex">\([i, j]\)</span> 。</p>
|
||||
<p>状态 <span class="arithmatex">\([i, j]\)</span> 对应的子问题为：从起始点 <span class="arithmatex">\([0, 0]\)</span> 走到 <span class="arithmatex">\([i, j]\)</span> 的最小路径和，解记为 <span class="arithmatex">\(dp[i, j]\)</span> 。</p>
|
||||
<p>至此，我们就得到了一个二维 <span class="arithmatex">\(dp\)</span> 矩阵，其尺寸与输入网格 <span class="arithmatex">\(grid\)</span> 相同。</p>
|
||||
<p>至此，我们就得到了下图所示的二维 <span class="arithmatex">\(dp\)</span> 矩阵，其尺寸与输入网格 <span class="arithmatex">\(grid\)</span> 相同。</p>
|
||||
<p><img alt="状态定义与 dp 表" src="../dp_solution_pipeline.assets/min_path_sum_solution_step1.png" /></p>
|
||||
<p align="center"> 图：状态定义与 dp 表 </p>
|
||||
|
||||
|
|
@ -3533,7 +3533,7 @@
|
|||
</div>
|
||||
<p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
|
||||
<p>对于状态 <span class="arithmatex">\([i, j]\)</span> ，它只能从上边格子 <span class="arithmatex">\([i-1, j]\)</span> 和左边格子 <span class="arithmatex">\([i, j-1]\)</span> 转移而来。因此最优子结构为：到达 <span class="arithmatex">\([i, j]\)</span> 的最小路径和由 <span class="arithmatex">\([i, j-1]\)</span> 的最小路径和与 <span class="arithmatex">\([i-1, j]\)</span> 的最小路径和，这两者较小的那一个决定。</p>
|
||||
<p>根据以上分析，可推出以下状态转移方程：</p>
|
||||
<p>根据以上分析，可推出下图所示的状态转移方程：</p>
|
||||
<div class="arithmatex">\[
|
||||
dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
||||
\]</div>
|
||||
|
|
@ -3547,7 +3547,7 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
|||
</div>
|
||||
<p><strong>第三步：确定边界条件和状态转移顺序</strong></p>
|
||||
<p>在本题中，处在首行的状态只能向右转移，首列状态只能向下转移，因此首行 <span class="arithmatex">\(i = 0\)</span> 和首列 <span class="arithmatex">\(j = 0\)</span> 是边界条件。</p>
|
||||
<p>每个格子是由其左方格子和上方格子转移而来，因此我们使用采用循环来遍历矩阵，外循环遍历各行、内循环遍历各列。</p>
|
||||
<p>如下图所示，由于每个格子是由其左方格子和上方格子转移而来，因此我们使用采用循环来遍历矩阵，外循环遍历各行、内循环遍历各列。</p>
|
||||
<p><img alt="边界条件与状态转移顺序" src="../dp_solution_pipeline.assets/min_path_sum_solution_step3.png" /></p>
|
||||
<p align="center"> 图：边界条件与状态转移顺序 </p>
|
||||
|
||||
|
|
@ -3990,7 +3990,7 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>引入记忆化后，所有子问题的解只需计算一次，因此时间复杂度取决于状态总数，即网格尺寸 <span class="arithmatex">\(O(nm)\)</span> 。</p>
|
||||
<p>如下图所示，在引入记忆化后，所有子问题的解只需计算一次，因此时间复杂度取决于状态总数，即网格尺寸 <span class="arithmatex">\(O(nm)\)</span> 。</p>
|
||||
<p><img alt="记忆化搜索递归树" src="../dp_solution_pipeline.assets/min_path_sum_dfs_mem.png" /></p>
|
||||
<p align="center"> 图：记忆化搜索递归树 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3462,7 +3462,7 @@
|
|||
<p>状态 <span class="arithmatex">\([i, j]\)</span> 对应的子问题：<strong>将 <span class="arithmatex">\(s\)</span> 的前 <span class="arithmatex">\(i\)</span> 个字符更改为 <span class="arithmatex">\(t\)</span> 的前 <span class="arithmatex">\(j\)</span> 个字符所需的最少编辑步数</strong>。</p>
|
||||
<p>至此，得到一个尺寸为 <span class="arithmatex">\((i+1) \times (j+1)\)</span> 的二维 <span class="arithmatex">\(dp\)</span> 表。</p>
|
||||
<p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
|
||||
<p>考虑子问题 <span class="arithmatex">\(dp[i, j]\)</span> ，其对应的两个字符串的尾部字符为 <span class="arithmatex">\(s[i-1]\)</span> 和 <span class="arithmatex">\(t[j-1]\)</span> ，可根据不同编辑操作分为三种情况：</p>
|
||||
<p>考虑子问题 <span class="arithmatex">\(dp[i, j]\)</span> ，其对应的两个字符串的尾部字符为 <span class="arithmatex">\(s[i-1]\)</span> 和 <span class="arithmatex">\(t[j-1]\)</span> ，可根据不同编辑操作分为下图所示的三种情况：</p>
|
||||
<ol>
|
||||
<li>在 <span class="arithmatex">\(s[i-1]\)</span> 之后添加 <span class="arithmatex">\(t[j-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i, j-1]\)</span> 。</li>
|
||||
<li>删除 <span class="arithmatex">\(s[i-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i-1, j]\)</span> 。</li>
|
||||
|
|
|
|||
|
|
@ -3789,7 +3789,7 @@ dp[i-1] , dp[i-2] , \dots , dp[2] , dp[1]
|
|||
<div class="arithmatex">\[
|
||||
dp[i] = dp[i-1] + dp[i-2]
|
||||
\]</div>
|
||||
<p>这意味着在爬楼梯问题中，各个子问题之间存在递推关系，<strong>原问题的解可以由子问题的解构建得来</strong>。</p>
|
||||
<p>这意味着在爬楼梯问题中，各个子问题之间存在递推关系，<strong>原问题的解可以由子问题的解构建得来</strong>。下图展示了该递推关系。</p>
|
||||
<p><img alt="方案数量递推关系" src="../intro_to_dynamic_programming.assets/climbing_stairs_state_transfer.png" /></p>
|
||||
<p align="center"> 图：方案数量递推关系 </p>
|
||||
|
||||
|
|
@ -4492,6 +4492,10 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>下图模拟了以上代码的执行过程。</p>
|
||||
<p><img alt="爬楼梯的动态规划过程" src="../intro_to_dynamic_programming.assets/climbing_stairs_dp.png" /></p>
|
||||
<p align="center"> 图：爬楼梯的动态规划过程 </p>
|
||||
|
||||
<p>与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如，爬楼梯问题的状态定义为当前所在楼梯阶数 <span class="arithmatex">\(i\)</span> 。</p>
|
||||
<p>总结以上，动态规划的常用术语包括：</p>
|
||||
<ul>
|
||||
|
|
@ -4499,9 +4503,6 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
<li>将最小子问题对应的状态（即第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 阶楼梯）称为「初始状态」。</li>
|
||||
<li>将递推公式 <span class="arithmatex">\(dp[i] = dp[i-1] + dp[i-2]\)</span> 称为「状态转移方程」。</li>
|
||||
</ul>
|
||||
<p><img alt="爬楼梯的动态规划过程" src="../intro_to_dynamic_programming.assets/climbing_stairs_dp.png" /></p>
|
||||
<p align="center"> 图：爬楼梯的动态规划过程 </p>
|
||||
|
||||
<h2 id="1414">14.1.4 状态压缩<a class="headerlink" href="#1414" title="Permanent link">¶</a></h2>
|
||||
<p>细心的你可能发现，<strong>由于 <span class="arithmatex">\(dp[i]\)</span> 只与 <span class="arithmatex">\(dp[i-1]\)</span> 和 <span class="arithmatex">\(dp[i-2]\)</span> 有关，因此我们无须使用一个数组 <code>dp</code> 来存储所有子问题的解</strong>，而只需两个变量滚动前进即可。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="5:12"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><input id="__tabbed_5_11" name="__tabbed_5" type="radio" /><input id="__tabbed_5_12" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Java</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Python</label><label for="__tabbed_5_4">Go</label><label for="__tabbed_5_5">JS</label><label for="__tabbed_5_6">TS</label><label for="__tabbed_5_7">C</label><label for="__tabbed_5_8">C#</label><label for="__tabbed_5_9">Swift</label><label for="__tabbed_5_10">Zig</label><label for="__tabbed_5_11">Dart</label><label for="__tabbed_5_12">Rust</label></div>
|
||||
|
|
|
|||
|
|
@ -3454,7 +3454,7 @@
|
|||
<p class="admonition-title">Question</p>
|
||||
<p>给定 <span class="arithmatex">\(n\)</span> 个物品，第 <span class="arithmatex">\(i\)</span> 个物品的重量为 <span class="arithmatex">\(wgt[i-1]\)</span> 、价值为 <span class="arithmatex">\(val[i-1]\)</span> ，和一个容量为 <span class="arithmatex">\(cap\)</span> 的背包。每个物品只能选择一次，问在不超过背包容量下能放入物品的最大价值。</p>
|
||||
</div>
|
||||
<p>请注意，物品编号 <span class="arithmatex">\(i\)</span> 从 <span class="arithmatex">\(1\)</span> 开始计数，数组索引从 <span class="arithmatex">\(0\)</span> 开始计数，因此物品 <span class="arithmatex">\(i\)</span> 对应重量 <span class="arithmatex">\(wgt[i-1]\)</span> 和价值 <span class="arithmatex">\(val[i-1]\)</span> 。</p>
|
||||
<p>观察下图，由于物品编号 <span class="arithmatex">\(i\)</span> 从 <span class="arithmatex">\(1\)</span> 开始计数，数组索引从 <span class="arithmatex">\(0\)</span> 开始计数，因此物品 <span class="arithmatex">\(i\)</span> 对应重量 <span class="arithmatex">\(wgt[i-1]\)</span> 和价值 <span class="arithmatex">\(val[i-1]\)</span> 。</p>
|
||||
<p><img alt="0-1 背包的示例数据" src="../knapsack_problem.assets/knapsack_example.png" /></p>
|
||||
<p align="center"> 图：0-1 背包的示例数据 </p>
|
||||
|
||||
|
|
@ -3915,6 +3915,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>下图展示了在记忆化递归中被剪掉的搜索分支。</p>
|
||||
<p><img alt="0-1 背包的记忆化搜索递归树" src="../knapsack_problem.assets/knapsack_dfs_mem.png" /></p>
|
||||
<p align="center"> 图：0-1 背包的记忆化搜索递归树 </p>
|
||||
|
||||
|
|
@ -4189,7 +4190,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
<li>如果采取正序遍历，那么遍历到 <span class="arithmatex">\(dp[i, j]\)</span> 时，左上方 <span class="arithmatex">\(dp[i-1, 1]\)</span> ~ <span class="arithmatex">\(dp[i-1, j-1]\)</span> 值可能已经被覆盖，此时就无法得到正确的状态转移结果。</li>
|
||||
<li>如果采取倒序遍历，则不会发生覆盖问题，状态转移可以正确进行。</li>
|
||||
</ul>
|
||||
<p>以下动画展示了在单个数组下从第 <span class="arithmatex">\(i = 1\)</span> 行转换至第 <span class="arithmatex">\(i = 2\)</span> 行的过程。请思考正序遍历和倒序遍历的区别。</p>
|
||||
<p>下图展示了在单个数组下从第 <span class="arithmatex">\(i = 1\)</span> 行转换至第 <span class="arithmatex">\(i = 2\)</span> 行的过程。请思考正序遍历和倒序遍历的区别。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="5:6"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1"><1></label><label for="__tabbed_5_2"><2></label><label for="__tabbed_5_3"><3></label><label for="__tabbed_5_4"><4></label><label for="__tabbed_5_5"><5></label><label for="__tabbed_5_6"><6></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3837,7 +3837,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
|
|||
</div>
|
||||
<h3 id="3">3. 状态压缩<a class="headerlink" href="#3" title="Permanent link">¶</a></h3>
|
||||
<p>由于当前状态是从左边和上边的状态转移而来，<strong>因此状态压缩后应该对 <span class="arithmatex">\(dp\)</span> 表中的每一行采取正序遍历</strong>。</p>
|
||||
<p>这个遍历顺序与 0-1 背包正好相反。请通过以下动画来理解两者的区别。</p>
|
||||
<p>这个遍历顺序与 0-1 背包正好相反。请借助下图来理解两者的区别。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:6"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label><label for="__tabbed_2_5"><5></label><label for="__tabbed_2_6"><6></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -1716,24 +1716,17 @@
|
|||
|
||||
<li class="md-nav__item">
|
||||
<a href="#911" class="md-nav__link">
|
||||
9.1.1 图常见类型
|
||||
9.1.1 图常见类型与术语
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#912" class="md-nav__link">
|
||||
9.1.2 图常用术语
|
||||
9.1.2 图的表示
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#913" class="md-nav__link">
|
||||
9.1.3 图的表示
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="9.1.3 图的表示">
|
||||
<nav class="md-nav" aria-label="9.1.2 图的表示">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
|
|
@ -1756,8 +1749,8 @@
|
|||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#914" class="md-nav__link">
|
||||
9.1.4 图常见应用
|
||||
<a href="#913" class="md-nav__link">
|
||||
9.1.3 图常见应用
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
|
@ -3410,24 +3403,17 @@
|
|||
|
||||
<li class="md-nav__item">
|
||||
<a href="#911" class="md-nav__link">
|
||||
9.1.1 图常见类型
|
||||
9.1.1 图常见类型与术语
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#912" class="md-nav__link">
|
||||
9.1.2 图常用术语
|
||||
9.1.2 图的表示
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#913" class="md-nav__link">
|
||||
9.1.3 图的表示
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="9.1.3 图的表示">
|
||||
<nav class="md-nav" aria-label="9.1.2 图的表示">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
|
|
@ -3450,8 +3436,8 @@
|
|||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#914" class="md-nav__link">
|
||||
9.1.4 图常见应用
|
||||
<a href="#913" class="md-nav__link">
|
||||
9.1.3 图常见应用
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
|
@ -3488,12 +3474,12 @@ E & = \{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \} \newline
|
|||
G & = \{ V, E \} \newline
|
||||
\end{aligned}
|
||||
\]</div>
|
||||
<p>如果将顶点看作节点，将边看作连接各个节点的引用（指针），我们就可以将图看作是一种从链表拓展而来的数据结构。如下图所示，<strong>相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高</strong>，从而更为复杂。</p>
|
||||
<p><img alt="链表、树、图之间的关系" src="../graph.assets/linkedlist_tree_graph.png" /></p>
|
||||
<p align="center"> 图：链表、树、图之间的关系 </p>
|
||||
|
||||
<p>那么，图与其他数据结构的关系是什么？如果我们把顶点看作节点，把边看作连接各个节点的指针，则可将图看作是一种从链表拓展而来的数据结构。<strong>相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高，从而更为复杂</strong>。</p>
|
||||
<h2 id="911">9.1.1 图常见类型<a class="headerlink" href="#911" title="Permanent link">¶</a></h2>
|
||||
<p>根据边是否具有方向，可分为「无向图 undirected graph」和「有向图 directed graph」。</p>
|
||||
<h2 id="911">9.1.1 图常见类型与术语<a class="headerlink" href="#911" title="Permanent link">¶</a></h2>
|
||||
<p>根据边是否具有方向，可分为下图所示的「无向图 undirected graph」和「有向图 directed graph」。</p>
|
||||
<ul>
|
||||
<li>在无向图中，边表示两顶点之间的“双向”连接关系，例如微信或 QQ 中的“好友关系”。</li>
|
||||
<li>在有向图中，边具有方向性，即 <span class="arithmatex">\(A \rightarrow B\)</span> 和 <span class="arithmatex">\(A \leftarrow B\)</span> 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系。</li>
|
||||
|
|
@ -3501,7 +3487,7 @@ G & = \{ V, E \} \newline
|
|||
<p><img alt="有向图与无向图" src="../graph.assets/directed_graph.png" /></p>
|
||||
<p align="center"> 图：有向图与无向图 </p>
|
||||
|
||||
<p>根据所有顶点是否连通，可分为「连通图 connected graph」和「非连通图 disconnected graph」。</p>
|
||||
<p>根据所有顶点是否连通，可分为下图所示的「连通图 connected graph」和「非连通图 disconnected graph」。</p>
|
||||
<ul>
|
||||
<li>对于连通图，从某个顶点出发，可以到达其余任意顶点。</li>
|
||||
<li>对于非连通图，从某个顶点出发，至少有一个顶点无法到达。</li>
|
||||
|
|
@ -3509,18 +3495,18 @@ G & = \{ V, E \} \newline
|
|||
<p><img alt="连通图与非连通图" src="../graph.assets/connected_graph.png" /></p>
|
||||
<p align="center"> 图：连通图与非连通图 </p>
|
||||
|
||||
<p>我们还可以为边添加“权重”变量，从而得到「有权图 weighted graph」。例如，在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。</p>
|
||||
<p>我们还可以为边添加“权重”变量，从而得到下图所示的「有权图 weighted graph」。例如在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。</p>
|
||||
<p><img alt="有权图与无权图" src="../graph.assets/weighted_graph.png" /></p>
|
||||
<p align="center"> 图：有权图与无权图 </p>
|
||||
|
||||
<h2 id="912">9.1.2 图常用术语<a class="headerlink" href="#912" title="Permanent link">¶</a></h2>
|
||||
<p>图的常用术语包括：</p>
|
||||
<ul>
|
||||
<li>「邻接 adjacency」：当两顶点之间存在边相连时，称这两顶点“邻接”。在上图中，顶点 1 的邻接顶点为顶点 2、3、5。</li>
|
||||
<li>「路径 path」：从顶点 A 到顶点 B 经过的边构成的序列被称为从 A 到 B 的“路径”。在上图中，边序列 1-5-2-4 是顶点 1 到顶点 4 的一条路径。</li>
|
||||
<li>「度 degree」：一个顶点拥有的边数。对于有向图，「入度 In-Degree」表示有多少条边指向该顶点，「出度 Out-Degree」表示有多少条边从该顶点指出。</li>
|
||||
</ul>
|
||||
<h2 id="913">9.1.3 图的表示<a class="headerlink" href="#913" title="Permanent link">¶</a></h2>
|
||||
<p>图的常用表示方法包括“邻接矩阵”和“邻接表”。以下使用无向图进行举例。</p>
|
||||
<h2 id="912">9.1.2 图的表示<a class="headerlink" href="#912" title="Permanent link">¶</a></h2>
|
||||
<p>图的常用表示方式包括“邻接矩阵”和“邻接表”。以下使用无向图进行举例。</p>
|
||||
<h3 id="1">1. 邻接矩阵<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>设图的顶点数量为 <span class="arithmatex">\(n\)</span> ，「邻接矩阵 adjacency matrix」使用一个 <span class="arithmatex">\(n \times n\)</span> 大小的矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，用 <span class="arithmatex">\(1\)</span> 或 <span class="arithmatex">\(0\)</span> 表示两个顶点之间是否存在边。</p>
|
||||
<p>如下图所示，设邻接矩阵为 <span class="arithmatex">\(M\)</span> 、顶点列表为 <span class="arithmatex">\(V\)</span> ，那么矩阵元素 <span class="arithmatex">\(M[i, j] = 1\)</span> 表示顶点 <span class="arithmatex">\(V[i]\)</span> 到顶点 <span class="arithmatex">\(V[j]\)</span> 之间存在边，反之 <span class="arithmatex">\(M[i, j] = 0\)</span> 表示两顶点之间无边。</p>
|
||||
|
|
@ -3535,14 +3521,14 @@ G & = \{ V, E \} \newline
|
|||
</ul>
|
||||
<p>使用邻接矩阵表示图时，我们可以直接访问矩阵元素以获取边，因此增删查操作的效率很高，时间复杂度均为 <span class="arithmatex">\(O(1)\)</span> 。然而，矩阵的空间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> ，内存占用较多。</p>
|
||||
<h3 id="2">2. 邻接表<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>「邻接表 adjacency list」使用 <span class="arithmatex">\(n\)</span> 个链表来表示图，链表节点表示顶点。第 <span class="arithmatex">\(i\)</span> 条链表对应顶点 <span class="arithmatex">\(i\)</span> ，其中存储了该顶点的所有邻接顶点（即与该顶点相连的顶点）。</p>
|
||||
<p>「邻接表 adjacency list」使用 <span class="arithmatex">\(n\)</span> 个链表来表示图，链表节点表示顶点。第 <span class="arithmatex">\(i\)</span> 条链表对应顶点 <span class="arithmatex">\(i\)</span> ，其中存储了该顶点的所有邻接顶点（即与该顶点相连的顶点）。下图展示了一个使用邻接表存储的图的示例。</p>
|
||||
<p><img alt="图的邻接表表示" src="../graph.assets/adjacency_list.png" /></p>
|
||||
<p align="center"> 图：图的邻接表表示 </p>
|
||||
|
||||
<p>邻接表仅存储实际存在的边，而边的总数通常远小于 <span class="arithmatex">\(n^2\)</span> ，因此它更加节省空间。然而，在邻接表中需要通过遍历链表来查找边，因此其时间效率不如邻接矩阵。</p>
|
||||
<p>观察上图，<strong>邻接表结构与哈希表中的“链式地址”非常相似，因此我们也可以采用类似方法来优化效率</strong>。比如当链表较长时，可以将链表转化为 AVL 树或红黑树，从而将时间效率从 <span class="arithmatex">\(O(n)\)</span> 优化至 <span class="arithmatex">\(O(\log n)\)</span> ；还可以把链表转换为哈希表，从而将时间复杂度降低至 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<h2 id="914">9.1.4 图常见应用<a class="headerlink" href="#914" title="Permanent link">¶</a></h2>
|
||||
<p>实际应用中，许多系统都可以用图来建模，相应的待求解问题也可以约化为图计算问题。</p>
|
||||
<h2 id="913">9.1.3 图常见应用<a class="headerlink" href="#913" title="Permanent link">¶</a></h2>
|
||||
<p>如下图所示，许多现实系统都可以用图来建模，相应的问题也可以约化为图计算问题。</p>
|
||||
<p align="center"> 表：现实生活中常见的图 </p>
|
||||
|
||||
<div class="center-table">
|
||||
|
|
|
|||
|
|
@ -3428,7 +3428,7 @@
|
|||
<h1 id="92">9.2 图基础操作<a class="headerlink" href="#92" title="Permanent link">¶</a></h1>
|
||||
<p>图的基础操作可分为对“边”的操作和对“顶点”的操作。在“邻接矩阵”和“邻接表”两种表示方法下，实现方式有所不同。</p>
|
||||
<h2 id="921">9.2.1 基于邻接矩阵的实现<a class="headerlink" href="#921" title="Permanent link">¶</a></h2>
|
||||
<p>给定一个顶点数量为 <span class="arithmatex">\(n\)</span> 的无向图，则有：</p>
|
||||
<p>给定一个顶点数量为 <span class="arithmatex">\(n\)</span> 的无向图，则各种操作的实现方式如下图所示。</p>
|
||||
<ul>
|
||||
<li><strong>添加或删除边</strong>：直接在邻接矩阵中修改指定的边即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间。而由于是无向图，因此需要同时更新两个方向的边。</li>
|
||||
<li><strong>添加顶点</strong>：在邻接矩阵的尾部添加一行一列，并全部填 <span class="arithmatex">\(0\)</span> 即可，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
|
||||
|
|
@ -4528,7 +4528,7 @@
|
|||
</div>
|
||||
</div>
|
||||
<h2 id="922">9.2.2 基于邻接表的实现<a class="headerlink" href="#922" title="Permanent link">¶</a></h2>
|
||||
<p>设无向图的顶点总数为 <span class="arithmatex">\(n\)</span> 、边总数为 <span class="arithmatex">\(m\)</span> ，则有：</p>
|
||||
<p>设无向图的顶点总数为 <span class="arithmatex">\(n\)</span> 、边总数为 <span class="arithmatex">\(m\)</span> ，则可根据下图所示的方法实现各种操作。</p>
|
||||
<ul>
|
||||
<li><strong>添加边</strong>：在顶点对应链表的末尾添加边即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间。因为是无向图，所以需要同时添加两个方向的边。</li>
|
||||
<li><strong>删除边</strong>：在顶点对应链表中查找并删除指定边，使用 <span class="arithmatex">\(O(m)\)</span> 时间。在无向图中，需要同时删除两个方向的边。</li>
|
||||
|
|
@ -5499,7 +5499,7 @@
|
|||
</div>
|
||||
</div>
|
||||
<h2 id="923">9.2.3 效率对比<a class="headerlink" href="#923" title="Permanent link">¶</a></h2>
|
||||
<p>设图中共有 <span class="arithmatex">\(n\)</span> 个顶点和 <span class="arithmatex">\(m\)</span> 条边，下表为邻接矩阵和邻接表的时间和空间效率对比。</p>
|
||||
<p>设图中共有 <span class="arithmatex">\(n\)</span> 个顶点和 <span class="arithmatex">\(m\)</span> 条边，下表对比了邻接矩阵和邻接表的时间和空间效率。</p>
|
||||
<p align="center"> 表：邻接矩阵与邻接表对比 </p>
|
||||
|
||||
<div class="center-table">
|
||||
|
|
|
|||
|
|
@ -3499,7 +3499,7 @@
|
|||
<p>图和树都是非线性数据结构，都需要使用搜索算法来实现遍历操作。</p>
|
||||
<p>与树类似，图的遍历方式也可分为两种，即「广度优先遍历 breadth-first traversal」和「深度优先遍历 depth-first traversal」。它们也被称为「广度优先搜索 breadth-first search」和「深度优先搜索 depth-first search」，简称 BFS 和 DFS 。</p>
|
||||
<h2 id="931">9.3.1 广度优先遍历<a class="headerlink" href="#931" title="Permanent link">¶</a></h2>
|
||||
<p><strong>广度优先遍历是一种由近及远的遍历方式，从距离最近的顶点开始访问，并一层层向外扩张</strong>。具体来说，从某个顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接顶点，以此类推，直至所有顶点访问完毕。</p>
|
||||
<p><strong>广度优先遍历是一种由近及远的遍历方式，从某个节点出发，始终优先访问距离最近的顶点，并一层层向外扩张</strong>。如下图所示，从左上角顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接顶点，以此类推，直至所有顶点访问完毕。</p>
|
||||
<p><img alt="图的广度优先遍历" src="../graph_traversal.assets/graph_bfs.png" /></p>
|
||||
<p align="center"> 图：图的广度优先遍历 </p>
|
||||
|
||||
|
|
@ -3853,7 +3853,7 @@
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>代码相对抽象，建议对照以下动画图示来加深理解。</p>
|
||||
<p>代码相对抽象，建议对照下图来加深理解。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:11"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label><label for="__tabbed_2_5"><5></label><label for="__tabbed_2_6"><6></label><label for="__tabbed_2_7"><7></label><label for="__tabbed_2_8"><8></label><label for="__tabbed_2_9"><9></label><label for="__tabbed_2_10"><10></label><label for="__tabbed_2_11"><11></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3901,12 +3901,12 @@
|
|||
<p><strong>时间复杂度：</strong> 所有顶点都会入队并出队一次，使用 <span class="arithmatex">\(O(|V|)\)</span> 时间；在遍历邻接顶点的过程中，由于是无向图，因此所有边都会被访问 <span class="arithmatex">\(2\)</span> 次，使用 <span class="arithmatex">\(O(2|E|)\)</span> 时间；总体使用 <span class="arithmatex">\(O(|V| + |E|)\)</span> 时间。</p>
|
||||
<p><strong>空间复杂度：</strong> 列表 <code>res</code> ，哈希表 <code>visited</code> ，队列 <code>que</code> 中的顶点数量最多为 <span class="arithmatex">\(|V|\)</span> ，使用 <span class="arithmatex">\(O(|V|)\)</span> 空间。</p>
|
||||
<h2 id="932">9.3.2 深度优先遍历<a class="headerlink" href="#932" title="Permanent link">¶</a></h2>
|
||||
<p><strong>深度优先遍历是一种优先走到底、无路可走再回头的遍历方式</strong>。具体地，从某个顶点出发，访问当前顶点的某个邻接顶点，直到走到尽头时返回，再继续走到尽头并返回，以此类推，直至所有顶点遍历完成。</p>
|
||||
<p><strong>深度优先遍历是一种优先走到底、无路可走再回头的遍历方式</strong>。如下图所示，从左上角顶点出发，访问当前顶点的某个邻接顶点，直到走到尽头时返回，再继续走到尽头并返回，以此类推，直至所有顶点遍历完成。</p>
|
||||
<p><img alt="图的深度优先遍历" src="../graph_traversal.assets/graph_dfs.png" /></p>
|
||||
<p align="center"> 图：图的深度优先遍历 </p>
|
||||
|
||||
<h3 id="1_1">1. 算法实现<a class="headerlink" href="#1_1" title="Permanent link">¶</a></h3>
|
||||
<p>这种“走到尽头 + 回溯”的算法形式通常基于递归来实现。与 BFS 类似，在 DFS 中我们也需要借助一个哈希表 <code>visited</code> 来记录已被访问的顶点，以避免重复访问顶点。</p>
|
||||
<p>这种“走到尽头再返回”的算法范式通常基于递归来实现。与广度优先遍历类似，在深度优先遍历中我们也需要借助一个哈希表 <code>visited</code> 来记录已被访问的顶点，以避免重复访问顶点。</p>
|
||||
<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">
|
||||
|
|
|
|||
|
|
@ -3434,7 +3434,6 @@
|
|||
|
||||
|
||||
<h1 id="152">15.2 分数背包问题<a class="headerlink" href="#152" title="Permanent link">¶</a></h1>
|
||||
<p>分数背包是 0-1 背包的一个变种问题。</p>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>给定 <span class="arithmatex">\(n\)</span> 个物品，第 <span class="arithmatex">\(i\)</span> 个物品的重量为 <span class="arithmatex">\(wgt[i-1]\)</span> 、价值为 <span class="arithmatex">\(val[i-1]\)</span> ，和一个容量为 <span class="arithmatex">\(cap\)</span> 的背包。每个物品只能选择一次，<strong>但可以选择物品的一部分，价值根据选择的重量比例计算</strong>，问在不超过背包容量下背包中物品的最大价值。</p>
|
||||
|
|
@ -3442,8 +3441,8 @@
|
|||
<p><img alt="分数背包问题的示例数据" src="../fractional_knapsack_problem.assets/fractional_knapsack_example.png" /></p>
|
||||
<p align="center"> 图：分数背包问题的示例数据 </p>
|
||||
|
||||
<p>本题和 0-1 背包整体上非常相似，状态包含当前物品 <span class="arithmatex">\(i\)</span> 和容量 <span class="arithmatex">\(c\)</span> ，目标是求不超过背包容量下的最大价值。</p>
|
||||
<p>不同点在于，本题允许只选择物品的一部分，<strong>这意味着可以对物品任意地进行切分，并按照重量比例来计算物品价值</strong>，因此有：</p>
|
||||
<p>分数背包和 0-1 背包整体上非常相似，状态包含当前物品 <span class="arithmatex">\(i\)</span> 和容量 <span class="arithmatex">\(c\)</span> ，目标是求不超过背包容量下的最大价值。</p>
|
||||
<p>不同点在于，本题允许只选择物品的一部分。如下图所示，<strong>我们可以对物品任意地进行切分，并按照重量比例来计算物品价值</strong>。</p>
|
||||
<ol>
|
||||
<li>对于物品 <span class="arithmatex">\(i\)</span> ，它在单位重量下的价值为 <span class="arithmatex">\(val[i-1] / wgt[i-1]\)</span> ，简称为单位价值。</li>
|
||||
<li>假设放入一部分物品 <span class="arithmatex">\(i\)</span> ，重量为 <span class="arithmatex">\(w\)</span> ，则背包增加的价值为 <span class="arithmatex">\(w \times val[i-1] / wgt[i-1]\)</span> 。</li>
|
||||
|
|
@ -3452,7 +3451,7 @@
|
|||
<p align="center"> 图：物品在单位重量下的价值 </p>
|
||||
|
||||
<h3 id="1">1. 贪心策略确定<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>最大化背包内物品总价值，<strong>本质上是要最大化单位重量下的物品价值</strong>。由此便可推出本题的贪心策略：</p>
|
||||
<p>最大化背包内物品总价值，<strong>本质上是要最大化单位重量下的物品价值</strong>。由此便可推出下图所示的贪心策略：</p>
|
||||
<ol>
|
||||
<li>将物品按照单位价值从高到低进行排序。</li>
|
||||
<li>遍历所有物品，<strong>每轮贪心地选择单位价值最高的物品</strong>。</li>
|
||||
|
|
@ -3762,8 +3761,7 @@
|
|||
<p>采用反证法。假设物品 <span class="arithmatex">\(x\)</span> 是单位价值最高的物品，使用某算法求得最大价值为 <code>res</code> ，但该解中不包含物品 <span class="arithmatex">\(x\)</span> 。</p>
|
||||
<p>现在从背包中拿出单位重量的任意物品，并替换为单位重量的物品 <span class="arithmatex">\(x\)</span> 。由于物品 <span class="arithmatex">\(x\)</span> 的单位价值最高，因此替换后的总价值一定大于 <code>res</code> 。<strong>这与 <code>res</code> 是最优解矛盾，说明最优解中必须包含物品 <span class="arithmatex">\(x\)</span></strong> 。</p>
|
||||
<p>对于该解中的其他物品，我们也可以构建出上述矛盾。总而言之，<strong>单位价值更大的物品总是更优选择</strong>，这说明贪心策略是有效的。</p>
|
||||
<p>如下图所示，如果将物品重量和物品单位价值分别看作一个 2D 图表的横轴和纵轴，则分数背包问题可被转化为“求在有限横轴区间下的最大围成面积”。</p>
|
||||
<p>通过这个类比，我们可以从几何角度理解贪心策略的有效性。</p>
|
||||
<p>如下图所示，如果将物品重量和物品单位价值分别看作一个 2D 图表的横轴和纵轴，则分数背包问题可被转化为“求在有限横轴区间下的最大围成面积”。这个类比可以帮助我们从几何角度理解贪心策略的有效性。</p>
|
||||
<p><img alt="分数背包问题的几何表示" src="../fractional_knapsack_problem.assets/fractional_knapsack_area_chart.png" /></p>
|
||||
<p align="center"> 图：分数背包问题的几何表示 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3459,7 +3459,7 @@
|
|||
<p class="admonition-title">Question</p>
|
||||
<p>给定 <span class="arithmatex">\(n\)</span> 种硬币，第 <span class="arithmatex">\(i\)</span> 种硬币的面值为 <span class="arithmatex">\(coins[i - 1]\)</span> ，目标金额为 <span class="arithmatex">\(amt\)</span> ，每种硬币可以重复选取，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 <span class="arithmatex">\(-1\)</span> 。</p>
|
||||
</div>
|
||||
<p>这道题的贪心策略在生活中很常见：给定目标金额，<strong>我们贪心地选择不大于且最接近它的硬币</strong>，不断循环该步骤，直至凑出目标金额为止。</p>
|
||||
<p>本题的贪心策略如下图所示。给定目标金额，<strong>我们贪心地选择不大于且最接近它的硬币</strong>，不断循环该步骤，直至凑出目标金额为止。</p>
|
||||
<p><img alt="零钱兑换的贪心策略" src="../greedy_algorithm.assets/coin_change_greedy_strategy.png" /></p>
|
||||
<p align="center"> 图：零钱兑换的贪心策略 </p>
|
||||
|
||||
|
|
@ -3641,7 +3641,7 @@
|
|||
</div>
|
||||
<h2 id="1511">15.1.1 贪心优点与局限性<a class="headerlink" href="#1511" title="Permanent link">¶</a></h2>
|
||||
<p><strong>贪心算法不仅操作直接、实现简单，而且通常效率也很高</strong>。在以上代码中，记硬币最小面值为 <span class="arithmatex">\(\min(coins)\)</span> ，则贪心选择最多循环 <span class="arithmatex">\(amt / \min(coins)\)</span> 次，时间复杂度为 <span class="arithmatex">\(O(amt / \min(coins))\)</span> 。这比动态规划解法的时间复杂度 <span class="arithmatex">\(O(n \times amt)\)</span> 提升了一个数量级。</p>
|
||||
<p>然而，<strong>对于某些硬币面值组合，贪心算法并不能找到最优解</strong>。我们来看几个例子：</p>
|
||||
<p>然而，<strong>对于某些硬币面值组合，贪心算法并不能找到最优解</strong>。下图给出了两个示例。</p>
|
||||
<ul>
|
||||
<li><strong>正例 <span class="arithmatex">\(coins = [1, 5, 10, 20, 50, 100]\)</span></strong>：在该硬币组合下，给定任意 <span class="arithmatex">\(amt\)</span> ，贪心算法都可以找出最优解。</li>
|
||||
<li><strong>反例 <span class="arithmatex">\(coins = [1, 20, 50]\)</span></strong>：假设 <span class="arithmatex">\(amt = 60\)</span> ，贪心算法只能找到 <span class="arithmatex">\(50 + 1 \times 10\)</span> 的兑换组合，共计 <span class="arithmatex">\(11\)</span> 枚硬币，但动态规划可以找到最优解 <span class="arithmatex">\(20 + 20 + 20\)</span> ，仅需 <span class="arithmatex">\(3\)</span> 枚硬币。</li>
|
||||
|
|
|
|||
|
|
@ -3454,7 +3454,7 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
|
|||
<p><img alt="初始状态" src="../max_capacity_problem.assets/max_capacity_initial_state.png" /></p>
|
||||
<p align="center"> 图：初始状态 </p>
|
||||
|
||||
<p>我们发现，<strong>如果此时将长板 <span class="arithmatex">\(j\)</span> 向短板 <span class="arithmatex">\(i\)</span> 靠近，则容量一定变小</strong>。这是因为在移动长板 <span class="arithmatex">\(j\)</span> 后：</p>
|
||||
<p>如下图所示，<strong>若此时将长板 <span class="arithmatex">\(j\)</span> 向短板 <span class="arithmatex">\(i\)</span> 靠近，则容量一定变小</strong>。这是因为在移动长板 <span class="arithmatex">\(j\)</span> 后：</p>
|
||||
<ul>
|
||||
<li>宽度 <span class="arithmatex">\(j-i\)</span> 肯定变小。</li>
|
||||
<li>高度由短板决定，因此高度只可能不变（ <span class="arithmatex">\(i\)</span> 仍为短板）或变小（移动后的 <span class="arithmatex">\(j\)</span> 成为短板）。</li>
|
||||
|
|
@ -3462,11 +3462,12 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
|
|||
<p><img alt="向内移动长板后的状态" src="../max_capacity_problem.assets/max_capacity_moving_long_board.png" /></p>
|
||||
<p align="center"> 图：向内移动长板后的状态 </p>
|
||||
|
||||
<p>反向思考，<strong>我们只有向内收缩短板 <span class="arithmatex">\(i\)</span> ，才有可能使容量变大</strong>。因为虽然宽度一定变小，<strong>但高度可能会变大</strong>（移动后的短板 <span class="arithmatex">\(i\)</span> 可能会变长）。</p>
|
||||
<p><img alt="向内移动长板后的状态" src="../max_capacity_problem.assets/max_capacity_moving_short_board.png" /></p>
|
||||
<p align="center"> 图：向内移动长板后的状态 </p>
|
||||
<p>反向思考，<strong>我们只有向内收缩短板 <span class="arithmatex">\(i\)</span> ，才有可能使容量变大</strong>。因为虽然宽度一定变小，<strong>但高度可能会变大</strong>（移动后的短板 <span class="arithmatex">\(i\)</span> 可能会变长）。例如在下图中，移动短板后面积变大。</p>
|
||||
<p><img alt="向内移动短板后的状态" src="../max_capacity_problem.assets/max_capacity_moving_short_board.png" /></p>
|
||||
<p align="center"> 图：向内移动短板后的状态 </p>
|
||||
|
||||
<p>由此便可推出本题的贪心策略：</p>
|
||||
<p>由此便可推出本题的贪心策略：初始化两指针分裂容器两端，每轮向内收缩短板对应的指针，直至两指针相遇。</p>
|
||||
<p>下图展示了贪心策略的执行过程。</p>
|
||||
<ol>
|
||||
<li>初始状态下，指针 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 分列与数组两端。</li>
|
||||
<li>计算当前状态的容量 <span class="arithmatex">\(cap[i, j]\)</span> ，并更新最大容量。</li>
|
||||
|
|
@ -3694,7 +3695,7 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
|
|||
</div>
|
||||
<h3 id="3">3. 正确性证明<a class="headerlink" href="#3" title="Permanent link">¶</a></h3>
|
||||
<p>之所以贪心比穷举更快，是因为每轮的贪心选择都会“跳过”一些状态。</p>
|
||||
<p>比如在状态 <span class="arithmatex">\(cap[i, j]\)</span> 下，<span class="arithmatex">\(i\)</span> 为短板、<span class="arithmatex">\(j\)</span> 为长板。若贪心地将短板 <span class="arithmatex">\(i\)</span> 向内移动一格，会导致以下状态被“跳过”。<strong>这意味着之后无法验证这些状态的容量大小</strong>。</p>
|
||||
<p>比如在状态 <span class="arithmatex">\(cap[i, j]\)</span> 下，<span class="arithmatex">\(i\)</span> 为短板、<span class="arithmatex">\(j\)</span> 为长板。若贪心地将短板 <span class="arithmatex">\(i\)</span> 向内移动一格，会导致下图所示的状态被“跳过”。<strong>这意味着之后无法验证这些状态的容量大小</strong>。</p>
|
||||
<div class="arithmatex">\[
|
||||
cap[i, i+1], cap[i, i+2], \dots, cap[i, j-2], cap[i, j-1]
|
||||
\]</div>
|
||||
|
|
|
|||
|
|
@ -3459,13 +3459,13 @@ n = \sum_{i=1}^{m}n_i
|
|||
n & \geq 4
|
||||
\end{aligned}
|
||||
\]</div>
|
||||
<p>我们发现当 <span class="arithmatex">\(n \geq 4\)</span> 时，切分出一个 <span class="arithmatex">\(2\)</span> 后乘积会变大，<strong>这说明大于等于 <span class="arithmatex">\(4\)</span> 的整数都应该被切分</strong>。</p>
|
||||
<p>如下图所示，当 <span class="arithmatex">\(n \geq 4\)</span> 时，切分出一个 <span class="arithmatex">\(2\)</span> 后乘积会变大，<strong>这说明大于等于 <span class="arithmatex">\(4\)</span> 的整数都应该被切分</strong>。</p>
|
||||
<p><strong>贪心策略一</strong>：如果切分方案中包含 <span class="arithmatex">\(\geq 4\)</span> 的因子，那么它就应该被继续切分。最终的切分方案只应出现 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(3\)</span> 这三种因子。</p>
|
||||
<p><img alt="切分导致乘积变大" src="../max_product_cutting_problem.assets/max_product_cutting_greedy_infer1.png" /></p>
|
||||
<p align="center"> 图：切分导致乘积变大 </p>
|
||||
|
||||
<p>接下来思考哪个因子是最优的。在 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(3\)</span> 这三个因子中，显然 <span class="arithmatex">\(1\)</span> 是最差的，因为 <span class="arithmatex">\(1 \times (n-1) < n\)</span> 恒成立，即切分出 <span class="arithmatex">\(1\)</span> 反而会导致乘积减小。</p>
|
||||
<p>我们发现，当 <span class="arithmatex">\(n = 6\)</span> 时，有 <span class="arithmatex">\(3 \times 3 > 2 \times 2 \times 2\)</span> 。<strong>这意味着切分出 <span class="arithmatex">\(3\)</span> 比切分出 <span class="arithmatex">\(2\)</span> 更优</strong>。</p>
|
||||
<p>如下图所示，当 <span class="arithmatex">\(n = 6\)</span> 时，有 <span class="arithmatex">\(3 \times 3 > 2 \times 2 \times 2\)</span> 。<strong>这意味着切分出 <span class="arithmatex">\(3\)</span> 比切分出 <span class="arithmatex">\(2\)</span> 更优</strong>。</p>
|
||||
<p><strong>贪心策略二</strong>：在切分方案中，最多只应存在两个 <span class="arithmatex">\(2\)</span> 。因为三个 <span class="arithmatex">\(2\)</span> 总是可以被替换为两个 <span class="arithmatex">\(3\)</span> ，从而获得更大乘积。</p>
|
||||
<p><img alt="最优切分因子" src="../max_product_cutting_problem.assets/max_product_cutting_greedy_infer3.png" /></p>
|
||||
<p align="center"> 图：最优切分因子 </p>
|
||||
|
|
@ -3478,7 +3478,7 @@ n & \geq 4
|
|||
<li>当余数为 <span class="arithmatex">\(1\)</span> 时，由于 <span class="arithmatex">\(2 \times 2 > 1 \times 3\)</span> ，因此应将最后一个 <span class="arithmatex">\(3\)</span> 替换为 <span class="arithmatex">\(2\)</span> 。</li>
|
||||
</ol>
|
||||
<h3 id="2">2. 代码实现<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>在代码中，我们无须通过循环来切分整数，而可以利用向下整除运算得到 <span class="arithmatex">\(3\)</span> 的个数 <span class="arithmatex">\(a\)</span> ，用取模运算得到余数 <span class="arithmatex">\(b\)</span> ，此时有：</p>
|
||||
<p>如下图所示，我们无须通过循环来切分整数，而可以利用向下整除运算得到 <span class="arithmatex">\(3\)</span> 的个数 <span class="arithmatex">\(a\)</span> ，用取模运算得到余数 <span class="arithmatex">\(b\)</span> ，此时有：</p>
|
||||
<div class="arithmatex">\[
|
||||
n = 3 a + b
|
||||
\]</div>
|
||||
|
|
@ -3666,7 +3666,7 @@ n = 3 a + b
|
|||
<p><img alt="最大切分乘积的计算方法" src="../max_product_cutting_problem.assets/max_product_cutting_greedy_calculation.png" /></p>
|
||||
<p align="center"> 图：最大切分乘积的计算方法 </p>
|
||||
|
||||
<p><strong>时间复杂度取决于编程语言的幂运算的实现方法</strong>。以 Python 为例，常用的幂计算函数有三种：</p>
|
||||
<p><strong>时间复杂度取决于编程语言的幂运算的实现方法</strong>。以 Python 为例，常用的幂计算函数有：</p>
|
||||
<ul>
|
||||
<li>运算符 <code>**</code> 和函数 <code>pow()</code> 的时间复杂度均为 <span class="arithmatex">\(O(\log a)\)</span> 。</li>
|
||||
<li>函数 <code>math.pow()</code> 内部调用 C 语言库的 <code>pow()</code> 函数，其执行浮点取幂，时间复杂度为 <span class="arithmatex">\(O(1)\)</span> 。</li>
|
||||
|
|
|
|||
|
|
@ -3441,7 +3441,7 @@
|
|||
|
||||
<h1 id="63">6.3 哈希算法<a class="headerlink" href="#63" title="Permanent link">¶</a></h1>
|
||||
<p>在上两节中，我们了解了哈希表的工作原理和哈希冲突的处理方法。然而无论是开放寻址还是链地址法，<strong>它们只能保证哈希表可以在发生冲突时正常工作，但无法减少哈希冲突的发生</strong>。</p>
|
||||
<p>如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。对于链地址哈希表，理想情况下键值对平均分布在各个桶中，达到最佳查询效率；最差情况下所有键值对都被存储到同一个桶中，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> 。</p>
|
||||
<p>如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。如下图所示，对于链地址哈希表，理想情况下键值对平均分布在各个桶中，达到最佳查询效率；最差情况下所有键值对都被存储到同一个桶中，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> 。</p>
|
||||
<p><img alt="哈希冲突的最佳与最差情况" src="../hash_algorithm.assets/hash_collision_best_worst_condition.png" /></p>
|
||||
<p align="center"> 图：哈希冲突的最佳与最差情况 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3474,7 +3474,7 @@
|
|||
</ol>
|
||||
<p>哈希表的结构改良方法主要包括链式地址和开放寻址。</p>
|
||||
<h2 id="621">6.2.1 链式地址<a class="headerlink" href="#621" title="Permanent link">¶</a></h2>
|
||||
<p>在原始哈希表中，每个桶仅能存储一个键值对。「链式地址 separate chaining」将单个元素转换为链表，将键值对作为链表节点，将所有发生冲突的键值对都存储在同一链表中。</p>
|
||||
<p>在原始哈希表中，每个桶仅能存储一个键值对。「链式地址 separate chaining」将单个元素转换为链表，将键值对作为链表节点，将所有发生冲突的键值对都存储在同一链表中。下图展示了一个链式地址哈希表的例子。</p>
|
||||
<p><img alt="链式地址哈希表" src="../hash_collision.assets/hash_table_chaining.png" /></p>
|
||||
<p align="center"> 图：链式地址哈希表 </p>
|
||||
|
||||
|
|
@ -4597,8 +4597,9 @@
|
|||
<li><strong>插入元素</strong>：通过哈希函数计算数组索引，若发现桶内已有元素，则从冲突位置向后线性遍历（步长通常为 <span class="arithmatex">\(1\)</span> ），直至找到空位，将元素插入其中。</li>
|
||||
<li><strong>查找元素</strong>：若发现哈希冲突，则使用相同步长向后线性遍历，直到找到对应元素，返回 <code>value</code> 即可；如果遇到空位，说明目标键值对不在哈希表中，返回 <span class="arithmatex">\(\text{None}\)</span> 。</li>
|
||||
</ul>
|
||||
<p><img alt="线性探测" src="../hash_collision.assets/hash_table_linear_probing.png" /></p>
|
||||
<p align="center"> 图：线性探测 </p>
|
||||
<p>下图展示了一个在开放寻址（线性探测）下工作的哈希表。</p>
|
||||
<p><img alt="开放寻址和线性探测" src="../hash_collision.assets/hash_table_linear_probing.png" /></p>
|
||||
<p align="center"> 图：开放寻址和线性探测 </p>
|
||||
|
||||
<p>然而，线性探测存在以下缺陷：</p>
|
||||
<ul>
|
||||
|
|
|
|||
|
|
@ -3427,15 +3427,15 @@
|
|||
|
||||
<h1 id="61">6.1 哈希表<a class="headerlink" href="#61" title="Permanent link">¶</a></h1>
|
||||
<p>「哈希表 hash table」，又称「散列表」，其通过建立键 <code>key</code> 与值 <code>value</code> 之间的映射，实现高效的元素查询。具体而言，我们向哈希表输入一个键 <code>key</code> ，则可以在 <span class="arithmatex">\(O(1)\)</span> 时间内获取对应的值 <code>value</code> 。</p>
|
||||
<p>以一个包含 <span class="arithmatex">\(n\)</span> 个学生的数据库为例，每个学生都有“姓名”和“学号”两项数据。假如我们希望实现“输入一个学号，返回对应的姓名”的查询功能，则可以采用哈希表来实现。</p>
|
||||
<p>如下图所示，给定 <span class="arithmatex">\(n\)</span> 个学生，每个学生都有“姓名”和“学号”两项数据。假如我们希望实现“输入一个学号，返回对应的姓名”的查询功能，则可以采用哈希表来实现。</p>
|
||||
<p><img alt="哈希表的抽象表示" src="../hash_map.assets/hash_table_lookup.png" /></p>
|
||||
<p align="center"> 图：哈希表的抽象表示 </p>
|
||||
|
||||
<p>除哈希表外，我们还可以使用数组或链表实现查询功能。若将学生数据看作数组（链表）元素，则有：</p>
|
||||
<p>除哈希表外，数组和链表也可以实现查询功能，它们的效率对比如下表所示。</p>
|
||||
<ul>
|
||||
<li><strong>添加元素</strong>：仅需将元素添加至数组（链表）的尾部即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间。</li>
|
||||
<li><strong>查询元素</strong>：由于数组（链表）是乱序的，因此需要遍历其中的所有元素，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
|
||||
<li><strong>删除元素</strong>：需要先查询到元素，再从数组中删除，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
|
||||
<li><strong>删除元素</strong>：需要先查询到元素，再从数组（链表）中删除，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
|
||||
</ul>
|
||||
<p align="center"> 表：元素查询效率对比 </p>
|
||||
|
||||
|
|
@ -4866,7 +4866,8 @@
|
|||
<p><img alt="哈希冲突示例" src="../hash_map.assets/hash_collision.png" /></p>
|
||||
<p align="center"> 图：哈希冲突示例 </p>
|
||||
|
||||
<p>容易想到，哈希表容量 <span class="arithmatex">\(n\)</span> 越大，多个 <code>key</code> 被分配到同一个桶中的概率就越低，冲突就越少。因此，<strong>我们可以通过扩容哈希表来减少哈希冲突</strong>。如下图所示，扩容前键值对 <code>(136, A)</code> 和 <code>(236, D)</code> 发生冲突，扩容后冲突消失。</p>
|
||||
<p>容易想到，哈希表容量 <span class="arithmatex">\(n\)</span> 越大，多个 <code>key</code> 被分配到同一个桶中的概率就越低，冲突就越少。因此，<strong>我们可以通过扩容哈希表来减少哈希冲突</strong>。</p>
|
||||
<p>如下图所示，扩容前键值对 <code>(136, A)</code> 和 <code>(236, D)</code> 发生冲突，扩容后冲突消失。</p>
|
||||
<p><img alt="哈希表扩容" src="../hash_map.assets/hash_table_reshash.png" /></p>
|
||||
<p align="center"> 图：哈希表扩容 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3595,11 +3595,11 @@
|
|||
<li>在从顶至底堆化的过程中，每个节点最多堆化到叶节点，因此最大迭代次数为二叉树高度 <span class="arithmatex">\(O(\log n)\)</span> 。</li>
|
||||
</ul>
|
||||
<p>将上述两者相乘，可得到建堆过程的时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> 。<strong>然而，这个估算结果并不准确，因为我们没有考虑到二叉树底层节点数量远多于顶层节点的特性</strong>。</p>
|
||||
<p>接下来我们来进行更为详细的计算。为了减小计算难度，我们假设树是一个“完美二叉树”，该假设不会影响计算结果的正确性。设二叉树（即堆）节点数量为 <span class="arithmatex">\(n\)</span> ，树高度为 <span class="arithmatex">\(h\)</span> 。上文提到，<strong>节点堆化最大迭代次数等于该节点到叶节点的距离，而该距离正是“节点高度”</strong>。</p>
|
||||
<p>接下来我们来进行更为详细的计算。为了减小计算难度，我们假设树是一个“完美二叉树”，该假设不会影响计算结果的正确性。设二叉树（即堆）节点数量为 <span class="arithmatex">\(n\)</span> ，树高度为 <span class="arithmatex">\(h\)</span> 。</p>
|
||||
<p><img alt="完美二叉树的各层节点数量" src="../build_heap.assets/heapify_operations_count.png" /></p>
|
||||
<p align="center"> 图：完美二叉树的各层节点数量 </p>
|
||||
|
||||
<p>因此，我们可以将各层的“节点数量 <span class="arithmatex">\(\times\)</span> 节点高度”求和，<strong>从而得到所有节点的堆化迭代次数的总和</strong>。</p>
|
||||
<p>如上图所示，<strong>节点“从顶至底堆化”的最大迭代次数等于该节点到叶节点的距离，而该距离正是“节点高度”</strong>。因此，我们可以将各层的“节点数量 <span class="arithmatex">\(\times\)</span> 节点高度”求和，<strong>从而得到所有节点的堆化迭代次数的总和</strong>。</p>
|
||||
<div class="arithmatex">\[
|
||||
T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1
|
||||
\]</div>
|
||||
|
|
|
|||
|
|
@ -3494,7 +3494,7 @@
|
|||
|
||||
|
||||
<h1 id="81">8.1 堆<a class="headerlink" href="#81" title="Permanent link">¶</a></h1>
|
||||
<p>「堆 heap」是一种满足特定条件的完全二叉树，可分为两种类型：</p>
|
||||
<p>「堆 heap」是一种满足特定条件的完全二叉树，主要可分为下图所示的两种类型：</p>
|
||||
<ul>
|
||||
<li>「大顶堆 max heap」：任意节点的值 <span class="arithmatex">\(\geq\)</span> 其子节点的值。</li>
|
||||
<li>「小顶堆 min heap」：任意节点的值 <span class="arithmatex">\(\leq\)</span> 其子节点的值。</li>
|
||||
|
|
@ -3816,7 +3816,7 @@
|
|||
<h3 id="1">1. 堆的存储与表示<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>我们在二叉树章节中学习到，完全二叉树非常适合用数组来表示。由于堆正是一种完全二叉树，<strong>我们将采用数组来存储堆</strong>。</p>
|
||||
<p>当使用数组表示二叉树时，元素代表节点值，索引代表节点在二叉树中的位置。<strong>节点指针通过索引映射公式来实现</strong>。</p>
|
||||
<p>具体而言，给定索引 <span class="arithmatex">\(i\)</span> ，其左子节点索引为 <span class="arithmatex">\(2i + 1\)</span> ，右子节点索引为 <span class="arithmatex">\(2i + 2\)</span> ，父节点索引为 <span class="arithmatex">\((i - 1) / 2\)</span>（向下取整）。当索引越界时，表示空节点或节点不存在。</p>
|
||||
<p>如下图所示，给定索引 <span class="arithmatex">\(i\)</span> ，其左子节点索引为 <span class="arithmatex">\(2i + 1\)</span> ，右子节点索引为 <span class="arithmatex">\(2i + 2\)</span> ，父节点索引为 <span class="arithmatex">\((i - 1) / 2\)</span>（向下取整）。当索引越界时，表示空节点或节点不存在。</p>
|
||||
<p><img alt="堆的表示与存储" src="../heap.assets/representation_of_heap.png" /></p>
|
||||
<p align="center"> 图：堆的表示与存储 </p>
|
||||
|
||||
|
|
@ -4119,7 +4119,7 @@
|
|||
</div>
|
||||
<h3 id="3">3. 元素入堆<a class="headerlink" href="#3" title="Permanent link">¶</a></h3>
|
||||
<p>给定元素 <code>val</code> ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏。因此，<strong>需要修复从插入节点到根节点的路径上的各个节点</strong>，这个操作被称为「堆化 heapify」。</p>
|
||||
<p>考虑从入堆节点开始，<strong>从底至顶执行堆化</strong>。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。</p>
|
||||
<p>考虑从入堆节点开始，<strong>从底至顶执行堆化</strong>。如下图所示，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:9"><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" /><div class="tabbed-labels"><label for="__tabbed_4_1"><1></label><label for="__tabbed_4_2"><2></label><label for="__tabbed_4_3"><3></label><label for="__tabbed_4_4"><4></label><label for="__tabbed_4_5"><5></label><label for="__tabbed_4_6"><6></label><label for="__tabbed_4_7"><7></label><label for="__tabbed_4_8"><8></label><label for="__tabbed_4_9"><9></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4477,7 +4477,7 @@
|
|||
<li>交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）。</li>
|
||||
<li>从根节点开始，<strong>从顶至底执行堆化</strong>。</li>
|
||||
</ol>
|
||||
<p>顾名思义，<strong>从顶至底堆化的操作方向与从底至顶堆化相反</strong>，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。</p>
|
||||
<p>如下图所示，<strong>“从顶至底堆化”的操作方向与“从底至顶堆化”相反</strong>，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换。然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="6:10"><input checked="checked" id="__tabbed_6_1" name="__tabbed_6" type="radio" /><input id="__tabbed_6_2" name="__tabbed_6" type="radio" /><input id="__tabbed_6_3" name="__tabbed_6" type="radio" /><input id="__tabbed_6_4" name="__tabbed_6" type="radio" /><input id="__tabbed_6_5" name="__tabbed_6" type="radio" /><input id="__tabbed_6_6" name="__tabbed_6" type="radio" /><input id="__tabbed_6_7" name="__tabbed_6" type="radio" /><input id="__tabbed_6_8" name="__tabbed_6" type="radio" /><input id="__tabbed_6_9" name="__tabbed_6" type="radio" /><input id="__tabbed_6_10" name="__tabbed_6" type="radio" /><div class="tabbed-labels"><label for="__tabbed_6_1"><1></label><label for="__tabbed_6_2"><2></label><label for="__tabbed_6_3"><3></label><label for="__tabbed_6_4"><4></label><label for="__tabbed_6_5"><5></label><label for="__tabbed_6_6"><6></label><label for="__tabbed_6_7"><7></label><label for="__tabbed_6_8"><8></label><label for="__tabbed_6_9"><9></label><label for="__tabbed_6_10"><10></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3432,8 +3432,8 @@
|
|||
</div>
|
||||
<p>对于该问题，我们先介绍两种思路比较直接的解法，再介绍效率更高的堆解法。</p>
|
||||
<h2 id="831">8.3.1 方法一：遍历选择<a class="headerlink" href="#831" title="Permanent link">¶</a></h2>
|
||||
<p>我们可以进行 <span class="arithmatex">\(k\)</span> 轮遍历，分别在每轮中提取第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(\dots\)</span> , <span class="arithmatex">\(k\)</span> 大的元素，时间复杂度为 <span class="arithmatex">\(O(nk)\)</span> 。</p>
|
||||
<p>该方法只适用于 <span class="arithmatex">\(k \ll n\)</span> 的情况，因为当 <span class="arithmatex">\(k\)</span> 与 <span class="arithmatex">\(n\)</span> 比较接近时，其时间复杂度趋向于 <span class="arithmatex">\(O(n^2)\)</span> ，非常耗时。</p>
|
||||
<p>我们可以进行下图所示的 <span class="arithmatex">\(k\)</span> 轮遍历，分别在每轮中提取第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(\dots\)</span> , <span class="arithmatex">\(k\)</span> 大的元素，时间复杂度为 <span class="arithmatex">\(O(nk)\)</span> 。</p>
|
||||
<p>此方法只适用于 <span class="arithmatex">\(k \ll n\)</span> 的情况，因为当 <span class="arithmatex">\(k\)</span> 与 <span class="arithmatex">\(n\)</span> 比较接近时，其时间复杂度趋向于 <span class="arithmatex">\(O(n^2)\)</span> ，非常耗时。</p>
|
||||
<p><img alt="遍历寻找最大的 k 个元素" src="../top_k.assets/top_k_traversal.png" /></p>
|
||||
<p align="center"> 图：遍历寻找最大的 k 个元素 </p>
|
||||
|
||||
|
|
@ -3442,13 +3442,13 @@
|
|||
<p>当 <span class="arithmatex">\(k = n\)</span> 时，我们可以得到从大到小的序列，等价于“选择排序”算法。</p>
|
||||
</div>
|
||||
<h2 id="832">8.3.2 方法二：排序<a class="headerlink" href="#832" title="Permanent link">¶</a></h2>
|
||||
<p>我们可以对数组 <code>nums</code> 进行排序，并返回最右边的 <span class="arithmatex">\(k\)</span> 个元素，时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> 。</p>
|
||||
<p>如下图所示，我们可以先对数组 <code>nums</code> 进行排序，再返回最右边的 <span class="arithmatex">\(k\)</span> 个元素，时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> 。</p>
|
||||
<p>显然，该方法“超额”完成任务了，因为我们只需要找出最大的 <span class="arithmatex">\(k\)</span> 个元素即可，而不需要排序其他元素。</p>
|
||||
<p><img alt="排序寻找最大的 k 个元素" src="../top_k.assets/top_k_sorting.png" /></p>
|
||||
<p align="center"> 图：排序寻找最大的 k 个元素 </p>
|
||||
|
||||
<h2 id="833">8.3.3 方法三：堆<a class="headerlink" href="#833" title="Permanent link">¶</a></h2>
|
||||
<p>我们可以基于堆更加高效地解决 Top-K 问题，流程如下：</p>
|
||||
<p>我们可以基于堆更加高效地解决 Top-K 问题，流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>初始化一个小顶堆，其堆顶元素最小。</li>
|
||||
<li>先将数组的前 <span class="arithmatex">\(k\)</span> 个元素依次入堆。</li>
|
||||
|
|
|
|||
|
|
@ -3386,7 +3386,7 @@
|
|||
<p align="center"> 图：扑克排序步骤 </p>
|
||||
|
||||
<p>上述整理扑克牌的方法本质上是“插入排序”算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。</p>
|
||||
<p><strong>例三：货币找零</strong>。假设我们在超市购买了 <span class="arithmatex">\(69\)</span> 元的商品，给收银员付了 <span class="arithmatex">\(100\)</span> 元，则收银员需要找我们 <span class="arithmatex">\(31\)</span> 元。他会很自然地完成如下图所示的思考。</p>
|
||||
<p><strong>例三：货币找零</strong>。假设我们在超市购买了 <span class="arithmatex">\(69\)</span> 元的商品，给收银员付了 <span class="arithmatex">\(100\)</span> 元，则收银员需要找我们 <span class="arithmatex">\(31\)</span> 元。他会很自然地完成下图所示的思考。</p>
|
||||
<ol>
|
||||
<li>可选项是比 <span class="arithmatex">\(31\)</span> 元面值更小的货币，包括 <span class="arithmatex">\(1\)</span> 元、<span class="arithmatex">\(5\)</span> 元、<span class="arithmatex">\(10\)</span> 元、<span class="arithmatex">\(20\)</span> 元。</li>
|
||||
<li>从可选项中拿出最大的 <span class="arithmatex">\(20\)</span> 元，剩余 <span class="arithmatex">\(31 - 20 = 11\)</span> 元。</li>
|
||||
|
|
@ -3401,7 +3401,7 @@
|
|||
<p>小到烹饪一道菜，大到星际航行，几乎所有问题的解决都离不开算法。计算机的出现使我们能够通过编程将数据结构存储在内存中，同时编写代码调用 CPU 和 GPU 执行算法。这样一来，我们就能把生活中的问题转移到计算机上，以更高效的方式解决各种复杂问题。</p>
|
||||
<div class="admonition tip">
|
||||
<p class="admonition-title">Tip</p>
|
||||
<p>阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请继续往下阅读，因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。</p>
|
||||
<p>如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请不要担心，继续往下阅读，这本书将引导你迈入数据结构与算法的知识殿堂。</p>
|
||||
</div>
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -3446,16 +3446,16 @@
|
|||
<li>图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。</li>
|
||||
</ul>
|
||||
<h2 id="123">1.2.3 数据结构与算法的关系<a class="headerlink" href="#123" title="Permanent link">¶</a></h2>
|
||||
<p>数据结构与算法高度相关、紧密结合，具体表现在以下几个方面。</p>
|
||||
<p>数据结构与算法高度相关、紧密结合，具体表现在下图所示的几个方面。</p>
|
||||
<ul>
|
||||
<li>数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。</li>
|
||||
<li>算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，结合算法才能解决特定问题。</li>
|
||||
<li>特定算法通常会有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。</li>
|
||||
<li>算法通常可以基于不同的数据结构进行实现，并往往有对应最优的数据结构，但最终执行效率可能相差很大。</li>
|
||||
</ul>
|
||||
<p><img alt="数据结构与算法的关系" src="../what_is_dsa.assets/relationship_between_data_structure_and_algorithm.png" /></p>
|
||||
<p align="center"> 图：数据结构与算法的关系 </p>
|
||||
|
||||
<p>数据结构与算法犹如上图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。</p>
|
||||
<p>数据结构与算法犹如下图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。</p>
|
||||
<p><img alt="拼装积木" src="../what_is_dsa.assets/assembling_blocks.jpg" /></p>
|
||||
<p align="center"> 图：拼装积木 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3441,7 +3441,7 @@
|
|||
<p>您需要至少具备任一语言的编程基础，能够阅读和编写简单代码。</p>
|
||||
</div>
|
||||
<h2 id="012">0.1.2 内容结构<a class="headerlink" href="#012" title="Permanent link">¶</a></h2>
|
||||
<p>本书主要内容包括：</p>
|
||||
<p>本书主要内容如下图所示。</p>
|
||||
<ul>
|
||||
<li><strong>复杂度分析</strong>：数据结构和算法的评价维度与方法。时间复杂度、空间复杂度的推算方法、常见类型、示例等。</li>
|
||||
<li><strong>数据结构</strong>：基本数据类型，数据结构的分类方法。数组、链表、栈、队列、哈希表、树、堆、图等数据结构的定义、优缺点、常用操作、常见类型、典型应用、实现方法等。</li>
|
||||
|
|
|
|||
|
|
@ -3596,17 +3596,18 @@
|
|||
</div>
|
||||
<h2 id="022">0.2.2 在动画图解中高效学习<a class="headerlink" href="#022" title="Permanent link">¶</a></h2>
|
||||
<p>相较于文字，视频和图片具有更高的信息密度和结构化程度，更易于理解。在本书中，<strong>重点和难点知识将主要通过动画和图解形式展示</strong>，而文字则作为动画和图片的解释与补充。</p>
|
||||
<p>在阅读本书时，如果发现某段内容提供了动画或图解，<strong>建议以图为主线</strong>，以文字（通常位于图像上方）为辅，综合两者来理解内容。</p>
|
||||
<p>如果你在阅读本书时，发现某段内容提供了下图所示的动画或图解，<strong>请以图为主、以文字为辅</strong>，综合两者来理解内容。</p>
|
||||
<p><img alt="动画图解示例" src="../../index.assets/animation.gif" /></p>
|
||||
<p align="center"> 图：动画图解示例 </p>
|
||||
|
||||
<h2 id="023">0.2.3 在代码实践中加深理解<a class="headerlink" href="#023" title="Permanent link">¶</a></h2>
|
||||
<p>本书的配套代码被托管在 <a href="https://github.com/krahets/hello-algo">GitHub 仓库</a>。<strong>源代码附有测试样例，可一键运行</strong>。</p>
|
||||
<p>本书的配套代码被托管在 <a href="https://github.com/krahets/hello-algo">GitHub 仓库</a>。如下图所示，<strong>源代码附有测试样例，可一键运行</strong>。</p>
|
||||
<p>如果时间允许，<strong>建议你参照代码自行敲一遍</strong>。如果学习时间有限，请至少通读并运行所有代码。</p>
|
||||
<p>与阅读代码相比，编写代码的过程往往能带来更多收获。<strong>动手学，才是真的学</strong>。</p>
|
||||
<p><img alt="运行代码示例" src="../../index.assets/running_code.gif" /></p>
|
||||
<p align="center"> 图：运行代码示例 </p>
|
||||
|
||||
<p>运行代码的前置工作主要分为三步。</p>
|
||||
<p><strong>第一步：安装本地编程环境</strong>。请参照<a href="https://www.hello-algo.com/chapter_appendix/installation/">附录教程</a>进行安装，如果已安装则可跳过此步骤。</p>
|
||||
<p><strong>第二步：下载代码仓</strong>。如果已经安装 <a href="https://git-scm.com/downloads">Git</a> ，可以通过以下命令克隆本仓库。</p>
|
||||
<div class="highlight"><pre><span></span><code><a id="__codelineno-12-1" name="__codelineno-12-1" href="#__codelineno-12-1"></a>git<span class="w"> </span>clone<span class="w"> </span>https://github.com/krahets/hello-algo.git
|
||||
|
|
@ -3620,8 +3621,8 @@
|
|||
<p align="center"> 图：代码块与对应的源代码文件 </p>
|
||||
|
||||
<h2 id="024">0.2.4 在提问讨论中共同成长<a class="headerlink" href="#024" title="Permanent link">¶</a></h2>
|
||||
<p>阅读本书时，请不要“惯着”那些没学明白的知识点。<strong>欢迎在评论区提出你的问题</strong>，我和其他小伙伴们将竭诚为你解答，一般情况下可在两天内得到回复。</p>
|
||||
<p>同时，也希望您能在评论区多花些时间。一方面，您可以了解大家遇到的问题，从而查漏补缺，这将有助于激发更深入的思考。另一方面，希望您能慷慨地回答其他小伙伴的问题、分享您的见解，让大家共同学习和进步。</p>
|
||||
<p>在阅读本书时，请不要轻易跳过那些没学明白的知识点。<strong>欢迎在评论区提出你的问题</strong>，我和小伙伴们将竭诚为你解答，一般情况下可在两天内回复。</p>
|
||||
<p>同时，也希望你能在评论区多花些时间。一方面，你可以了解大家遇到的问题，从而查漏补缺，激发更深入的思考。另一方面，期待你能慷慨地回答其他小伙伴的问题，分享您的见解，帮助他人进步。</p>
|
||||
<p><img alt="评论区示例" src="../../index.assets/comment.gif" /></p>
|
||||
<p align="center"> 图：评论区示例 </p>
|
||||
|
||||
|
|
@ -3632,7 +3633,7 @@
|
|||
<li><strong>刷算法题</strong>。建议从热门题目开刷，如<a href="https://leetcode.cn/problem-list/xb9nqhhg/">剑指 Offer</a>和<a href="https://leetcode.cn/problem-list/2cktkvj/">LeetCode Hot 100</a>，先积累至少 100 道题目，熟悉主流的算法问题。初次刷题时，“知识遗忘”可能是一个挑战，但请放心，这是很正常的。我们可以按照“艾宾浩斯遗忘曲线”来复习题目，通常在进行 3-5 轮的重复后，就能将其牢记在心。</li>
|
||||
<li><strong>搭建知识体系</strong>。在学习方面，我们可以阅读算法专栏文章、解题框架和算法教材，以不断丰富知识体系。在刷题方面，可以尝试采用进阶刷题策略，如按专题分类、一题多解、一解多题等，相关的刷题心得可以在各个社区找到。</li>
|
||||
</ol>
|
||||
<p>作为一本入门教程，本书内容主要涵盖“第一阶段”，旨在帮助你更高效地展开第二和第三阶段的学习。</p>
|
||||
<p>如下图所示，本书内容主要涵盖“第一阶段”，旨在帮助你更高效地展开第二和第三阶段的学习。</p>
|
||||
<p><img alt="算法学习路线" src="../suggestions.assets/learning_route.png" /></p>
|
||||
<p align="center"> 图：算法学习路线 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3412,7 +3412,7 @@
|
|||
|
||||
|
||||
<h1 id="101">10.1 二分查找<a class="headerlink" href="#101" title="Permanent link">¶</a></h1>
|
||||
<p>「二分查找 binary search」是一种基于分治思想的高效搜索算法。它利用数据的有序性，每轮减少一半搜索范围，直至找到目标元素或搜索区间为空为止。</p>
|
||||
<p>「二分查找 binary search」是一种基于分治策略的高效搜索算法。它利用数据的有序性，每轮减少一半搜索范围，直至找到目标元素或搜索区间为空为止。</p>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>给定一个长度为 <span class="arithmatex">\(n\)</span> 的数组 <code>nums</code> ，元素按从小到大的顺序排列，数组不包含重复元素。请查找并返回元素 <code>target</code> 在该数组中的索引。若数组不包含该元素，则返回 <span class="arithmatex">\(-1\)</span> 。</p>
|
||||
|
|
@ -3420,7 +3420,7 @@
|
|||
<p><img alt="二分查找示例数据" src="../binary_search.assets/binary_search_example.png" /></p>
|
||||
<p align="center"> 图：二分查找示例数据 </p>
|
||||
|
||||
<p>对于上述问题，我们先初始化指针 <span class="arithmatex">\(i = 0\)</span> 和 <span class="arithmatex">\(j = n - 1\)</span> ，分别指向数组首元素和尾元素，代表搜索区间 <span class="arithmatex">\([0, n - 1]\)</span> 。请注意，中括号表示闭区间，其包含边界值本身。</p>
|
||||
<p>如下图所示，我们先初始化指针 <span class="arithmatex">\(i = 0\)</span> 和 <span class="arithmatex">\(j = n - 1\)</span> ，分别指向数组首元素和尾元素，代表搜索区间 <span class="arithmatex">\([0, n - 1]\)</span> 。请注意，中括号表示闭区间，其包含边界值本身。</p>
|
||||
<p>接下来，循环执行以下两个步骤：</p>
|
||||
<ol>
|
||||
<li>计算中点索引 <span class="arithmatex">\(m = \lfloor {(i + j) / 2} \rfloor\)</span> ，其中 <span class="arithmatex">\(\lfloor \space \rfloor\)</span> 表示向下取整操作。</li>
|
||||
|
|
@ -3988,7 +3988,7 @@
|
|||
</div>
|
||||
</div>
|
||||
<p>如下图所示，在两种区间表示下，二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。</p>
|
||||
<p>在“双闭区间”表示法中，由于左右边界都被定义为闭区间，因此指针 <span class="arithmatex">\(i\)</span> 和 <span class="arithmatex">\(j\)</span> 缩小区间操作也是对称的。这样更不容易出错。因此，<strong>我们通常采用“双闭区间”的写法</strong>。</p>
|
||||
<p>由于“双闭区间”表示中的左右边界都被定义为闭区间，因此指针 <span class="arithmatex">\(i\)</span> 和 <span class="arithmatex">\(j\)</span> 缩小区间操作也是对称的。这样更不容易出错，<strong>因此一般建议采用“双闭区间”的写法</strong>。</p>
|
||||
<p><img alt="两种区间定义" src="../binary_search.assets/binary_search_ranges.png" /></p>
|
||||
<p align="center"> 图：两种区间定义 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3587,7 +3587,7 @@
|
|||
<p>下面我们介绍两种更加取巧的方法。</p>
|
||||
<h3 id="1">1. 复用查找左边界<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>实际上，我们可以利用查找最左元素的函数来查找最右元素，具体方法为：<strong>将查找最右一个 <code>target</code> 转化为查找最左一个 <code>target + 1</code></strong>。</p>
|
||||
<p>查找完成后，指针 <span class="arithmatex">\(i\)</span> 指向最左一个 <code>target + 1</code>（如果存在），而 <span class="arithmatex">\(j\)</span> 指向最右一个 <code>target</code> ，<strong>因此返回 <span class="arithmatex">\(j\)</span> 即可</strong>。</p>
|
||||
<p>如下图所示，查找完成后，指针 <span class="arithmatex">\(i\)</span> 指向最左一个 <code>target + 1</code>（如果存在），而 <span class="arithmatex">\(j\)</span> 指向最右一个 <code>target</code> ，<strong>因此返回 <span class="arithmatex">\(j\)</span> 即可</strong>。</p>
|
||||
<p><img alt="将查找右边界转化为查找左边界" src="../binary_search_edge.assets/binary_search_right_edge_by_left_edge.png" /></p>
|
||||
<p align="center"> 图：将查找右边界转化为查找左边界 </p>
|
||||
|
||||
|
|
@ -3716,7 +3716,7 @@
|
|||
</div>
|
||||
<h3 id="2">2. 转化为查找元素<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>我们知道，当数组不包含 <code>target</code> 时，最后 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 会分别指向首个大于、小于 <code>target</code> 的元素。</p>
|
||||
<p>根据上述结论，我们可以构造一个数组中不存在的元素，用于查找左右边界：</p>
|
||||
<p>根据上述结论，我们可以构造一个数组中不存在的元素，用于查找左右边界，如下图所示。</p>
|
||||
<ul>
|
||||
<li>查找最左一个 <code>target</code> ：可以转化为查找 <code>target - 0.5</code> ，并返回指针 <span class="arithmatex">\(i\)</span> 。</li>
|
||||
<li>查找最右一个 <code>target</code> ：可以转化为查找 <code>target + 0.5</code> ，并返回指针 <span class="arithmatex">\(j\)</span> 。</li>
|
||||
|
|
|
|||
|
|
@ -3580,7 +3580,7 @@
|
|||
<p>在上一题的基础上，规定数组可能包含重复元素，其余不变。</p>
|
||||
</div>
|
||||
<p>假设数组中存在多个 <code>target</code> ，则普通二分查找只能返回其中一个 <code>target</code> 的索引，<strong>而无法确定该元素的左边和右边还有多少 <code>target</code></strong>。</p>
|
||||
<p>题目要求将目标元素插入到最左边，<strong>所以我们需要查找数组中最左一个 <code>target</code> 的索引</strong>。初步考虑通过以下两步实现：</p>
|
||||
<p>题目要求将目标元素插入到最左边，<strong>所以我们需要查找数组中最左一个 <code>target</code> 的索引</strong>。初步考虑通过下图所示的步骤实现。</p>
|
||||
<ol>
|
||||
<li>执行二分查找，得到任意一个 <code>target</code> 的索引，记为 <span class="arithmatex">\(k\)</span> 。</li>
|
||||
<li>从索引 <span class="arithmatex">\(k\)</span> 开始，向左进行线性遍历，当找到最左边的 <code>target</code> 时返回。</li>
|
||||
|
|
@ -3589,7 +3589,7 @@
|
|||
<p align="center"> 图：线性查找重复元素的插入点 </p>
|
||||
|
||||
<p>此方法虽然可用，但其包含线性查找，因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span> 。当数组中存在很多重复的 <code>target</code> 时，该方法效率很低。</p>
|
||||
<p>现考虑修改二分查找代码。整体流程不变，每轮先计算中点索引 <span class="arithmatex">\(m\)</span> ，再判断 <code>target</code> 和 <code>nums[m]</code> 大小关系：</p>
|
||||
<p>现考虑拓展二分查找代码。如下图所示，整体流程保持不变，每轮先计算中点索引 <span class="arithmatex">\(m\)</span> ，再判断 <code>target</code> 和 <code>nums[m]</code> 大小关系：</p>
|
||||
<ol>
|
||||
<li>当 <code>nums[m] < target</code> 或 <code>nums[m] > target</code> 时，说明还没有找到 <code>target</code> ，因此采用普通二分查找的缩小区间操作，<strong>从而使指针 <span class="arithmatex">\(i\)</span> 和 <span class="arithmatex">\(j\)</span> 向 <code>target</code> 靠近</strong>。</li>
|
||||
<li>当 <code>nums[m] == target</code> 时，说明小于 <code>target</code> 的元素在区间 <span class="arithmatex">\([i, m - 1]\)</span> 中，因此采用 <span class="arithmatex">\(j = m - 1\)</span> 来缩小区间，<strong>从而使指针 <span class="arithmatex">\(j\)</span> 向小于 <code>target</code> 的元素靠近</strong>。</li>
|
||||
|
|
|
|||
|
|
@ -3418,7 +3418,7 @@
|
|||
<p>给定一个整数数组 <code>nums</code> 和一个目标元素 <code>target</code> ，请在数组中搜索“和”为 <code>target</code> 的两个元素，并返回它们的数组索引。返回任意一个解即可。</p>
|
||||
</div>
|
||||
<h2 id="1041">10.4.1 线性查找：以时间换空间<a class="headerlink" href="#1041" title="Permanent link">¶</a></h2>
|
||||
<p>考虑直接遍历所有可能的组合。开启一个两层循环，在每轮中判断两个整数的和是否为 <code>target</code> ，若是，则返回它们的索引。</p>
|
||||
<p>考虑直接遍历所有可能的组合。如下图所示，我们开启一个两层循环，在每轮中判断两个整数的和是否为 <code>target</code> ，若是则返回它们的索引。</p>
|
||||
<p><img alt="线性查找求解两数之和" src="../replace_linear_by_hashing.assets/two_sum_brute_force.png" /></p>
|
||||
<p align="center"> 图：线性查找求解两数之和 </p>
|
||||
|
||||
|
|
@ -3613,7 +3613,7 @@
|
|||
</div>
|
||||
<p>此方法的时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> ，空间复杂度为 <span class="arithmatex">\(O(1)\)</span> ，在大数据量下非常耗时。</p>
|
||||
<h2 id="1042">10.4.2 哈希查找：以空间换时间<a class="headerlink" href="#1042" title="Permanent link">¶</a></h2>
|
||||
<p>考虑借助一个哈希表，键值对分别为数组元素和元素索引。循环遍历数组，每轮执行：</p>
|
||||
<p>考虑借助一个哈希表，键值对分别为数组元素和元素索引。循环遍历数组，每轮执行下图所示的步骤。</p>
|
||||
<ol>
|
||||
<li>判断数字 <code>target - nums[i]</code> 是否在哈希表中，若是则直接返回这两个元素的索引。</li>
|
||||
<li>将键值对 <code>nums[i]</code> 和索引 <code>i</code> 添加进哈希表。</li>
|
||||
|
|
|
|||
|
|
@ -3427,7 +3427,7 @@
|
|||
|
||||
<h1 id="113">11.3 冒泡排序<a class="headerlink" href="#113" title="Permanent link">¶</a></h1>
|
||||
<p>「冒泡排序 bubble sort」通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样，因此得名冒泡排序。</p>
|
||||
<p>我们可以利用元素交换操作模拟上述过程：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。</p>
|
||||
<p>如下图所示，冒泡过程可以利用元素交换操作来模拟：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:7"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3456,7 +3456,7 @@
|
|||
<p align="center"> 图：利用元素交换操作模拟冒泡 </p>
|
||||
|
||||
<h2 id="1131">11.3.1 算法流程<a class="headerlink" href="#1131" title="Permanent link">¶</a></h2>
|
||||
<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，冒泡排序的步骤为：</p>
|
||||
<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，冒泡排序的步骤如下图所示。</p>
|
||||
<ol>
|
||||
<li>首先，对 <span class="arithmatex">\(n\)</span> 个元素执行“冒泡”，<strong>将数组的最大元素交换至正确位置</strong>，</li>
|
||||
<li>接下来，对剩余 <span class="arithmatex">\(n - 1\)</span> 个元素执行“冒泡”，<strong>将第二大元素交换至正确位置</strong>。</li>
|
||||
|
|
|
|||
|
|
@ -3427,9 +3427,9 @@
|
|||
|
||||
<h1 id="118">11.8 桶排序<a class="headerlink" href="#118" title="Permanent link">¶</a></h1>
|
||||
<p>前述的几种排序算法都属于“基于比较的排序算法”，它们通过比较元素间的大小来实现排序。此类排序算法的时间复杂度无法超越 <span class="arithmatex">\(O(n \log n)\)</span> 。接下来，我们将探讨几种“非比较排序算法”，它们的时间复杂度可以达到线性阶。</p>
|
||||
<p>「桶排序 bucket sort」是分治思想的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。</p>
|
||||
<p>「桶排序 bucket sort」是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。</p>
|
||||
<h2 id="1181">11.8.1 算法流程<a class="headerlink" href="#1181" title="Permanent link">¶</a></h2>
|
||||
<p>考虑一个长度为 <span class="arithmatex">\(n\)</span> 的数组，元素是范围 <span class="arithmatex">\([0, 1)\)</span> 的浮点数。桶排序的流程如下：</p>
|
||||
<p>考虑一个长度为 <span class="arithmatex">\(n\)</span> 的数组，元素是范围 <span class="arithmatex">\([0, 1)\)</span> 的浮点数。桶排序的流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>初始化 <span class="arithmatex">\(k\)</span> 个桶，将 <span class="arithmatex">\(n\)</span> 个元素分配到 <span class="arithmatex">\(k\)</span> 个桶中。</li>
|
||||
<li>对每个桶分别执行排序（本文采用编程语言的内置排序函数）。</li>
|
||||
|
|
@ -3803,11 +3803,13 @@
|
|||
</ul>
|
||||
<h2 id="1183">11.8.3 如何实现平均分配<a class="headerlink" href="#1183" title="Permanent link">¶</a></h2>
|
||||
<p>桶排序的时间复杂度理论上可以达到 <span class="arithmatex">\(O(n)\)</span> ，<strong>关键在于将元素均匀分配到各个桶中</strong>，因为实际数据往往不是均匀分布的。例如，我们想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。</p>
|
||||
<p>为实现平均分配，我们可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。<strong>分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等</strong>。这种方法本质上是创建一个递归树，使叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。</p>
|
||||
<p>为实现平均分配，我们可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。<strong>分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等</strong>。</p>
|
||||
<p>如下图所示，这种方法本质上是创建一个递归树，目标是让叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。</p>
|
||||
<p><img alt="递归划分桶" src="../bucket_sort.assets/scatter_in_buckets_recursively.png" /></p>
|
||||
<p align="center"> 图：递归划分桶 </p>
|
||||
|
||||
<p>如果我们提前知道商品价格的概率分布，<strong>则可以根据数据概率分布设置每个桶的价格分界线</strong>。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。如下图所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。</p>
|
||||
<p>如果我们提前知道商品价格的概率分布，<strong>则可以根据数据概率分布设置每个桶的价格分界线</strong>。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。</p>
|
||||
<p>如下图所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。</p>
|
||||
<p><img alt="根据概率分布划分桶" src="../bucket_sort.assets/scatter_in_buckets_distribution.png" /></p>
|
||||
<p align="center"> 图：根据概率分布划分桶 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3442,7 +3442,7 @@
|
|||
<h1 id="119">11.9 计数排序<a class="headerlink" href="#119" title="Permanent link">¶</a></h1>
|
||||
<p>「计数排序 counting sort」通过统计元素数量来实现排序，通常应用于整数数组。</p>
|
||||
<h2 id="1191">11.9.1 简单实现<a class="headerlink" href="#1191" title="Permanent link">¶</a></h2>
|
||||
<p>先来看一个简单的例子。给定一个长度为 <span class="arithmatex">\(n\)</span> 的数组 <code>nums</code> ，其中的元素都是“非负整数”。计数排序的整体流程如下：</p>
|
||||
<p>先来看一个简单的例子。给定一个长度为 <span class="arithmatex">\(n\)</span> 的数组 <code>nums</code> ，其中的元素都是“非负整数”，计数排序的整体流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>遍历数组，找出数组中的最大数字，记为 <span class="arithmatex">\(m\)</span> ，然后创建一个长度为 <span class="arithmatex">\(m + 1\)</span> 的辅助数组 <code>counter</code> 。</li>
|
||||
<li><strong>借助 <code>counter</code> 统计 <code>nums</code> 中各数字的出现次数</strong>，其中 <code>counter[num]</code> 对应数字 <code>num</code> 的出现次数。统计方法很简单，只需遍历 <code>nums</code>（设当前数字为 <code>num</code>），每轮将 <code>counter[num]</code> 增加 <span class="arithmatex">\(1\)</span> 即可。</li>
|
||||
|
|
@ -3735,7 +3735,7 @@
|
|||
<p>从桶排序的角度看，我们可以将计数排序中的计数数组 <code>counter</code> 的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。</p>
|
||||
</div>
|
||||
<h2 id="1192">11.9.2 完整实现<a class="headerlink" href="#1192" title="Permanent link">¶</a></h2>
|
||||
<p>细心的同学可能发现，<strong>如果输入数据是对象，上述步骤 <code>3.</code> 就失效了</strong>。例如，输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。</p>
|
||||
<p>细心的同学可能发现，<strong>如果输入数据是对象，上述步骤 <code>3.</code> 就失效了</strong>。假设输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。</p>
|
||||
<p>那么如何才能得到原数据的排序结果呢？我们首先计算 <code>counter</code> 的“前缀和”。顾名思义，索引 <code>i</code> 处的前缀和 <code>prefix[i]</code> 等于数组前 <code>i</code> 个元素之和，即：</p>
|
||||
<div class="arithmatex">\[
|
||||
\text{prefix}[i] = \sum_{j=0}^i \text{counter[j]}
|
||||
|
|
@ -3745,7 +3745,7 @@
|
|||
<li>将 <code>num</code> 填入数组 <code>res</code> 的索引 <code>prefix[num] - 1</code> 处。</li>
|
||||
<li>令前缀和 <code>prefix[num]</code> 减小 <span class="arithmatex">\(1\)</span> ，从而得到下次放置 <code>num</code> 的索引。</li>
|
||||
</ol>
|
||||
<p>遍历完成后，数组 <code>res</code> 中就是排序好的结果，最后使用 <code>res</code> 覆盖原数组 <code>nums</code> 即可。</p>
|
||||
<p>遍历完成后，数组 <code>res</code> 中就是排序好的结果，最后使用 <code>res</code> 覆盖原数组 <code>nums</code> 即可。下图展示了完整的计数排序流程。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:8"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label><label for="__tabbed_2_5"><5></label><label for="__tabbed_2_6"><6></label><label for="__tabbed_2_7"><7></label><label for="__tabbed_2_8"><8></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3423,14 +3423,17 @@
|
|||
</ol>
|
||||
<p>以上方法虽然可行，但需要借助一个额外数组来保存弹出的元素，比较浪费空间。在实际中，我们通常使用一种更加优雅的实现方式。</p>
|
||||
<h2 id="1171">11.7.1 算法流程<a class="headerlink" href="#1171" title="Permanent link">¶</a></h2>
|
||||
<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，堆排序的流程如下：</p>
|
||||
<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，堆排序的流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>输入数组并建立大顶堆。完成后，最大元素位于堆顶。</li>
|
||||
<li>将堆顶元素（第一个元素）与堆底元素（最后一个元素）交换。完成交换后，堆的长度减 <span class="arithmatex">\(1\)</span> ，已排序元素数量加 <span class="arithmatex">\(1\)</span> 。</li>
|
||||
<li>从堆顶元素开始，从顶到底执行堆化操作（Sift Down）。完成堆化后，堆的性质得到修复。</li>
|
||||
<li>循环执行第 <code>2.</code> 和 <code>3.</code> 步。循环 <span class="arithmatex">\(n - 1\)</span> 轮后，即可完成数组排序。</li>
|
||||
</ol>
|
||||
<div class="admonition tip">
|
||||
<p class="admonition-title">Tip</p>
|
||||
<p>实际上，元素出堆操作中也包含第 <code>2.</code> 和 <code>3.</code> 步，只是多了一个弹出元素的步骤。</p>
|
||||
</div>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:12"><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" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label><label for="__tabbed_1_10"><10></label><label for="__tabbed_1_11"><11></label><label for="__tabbed_1_12"><12></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3473,7 +3476,7 @@
|
|||
</div>
|
||||
<p align="center"> 图：堆排序步骤 </p>
|
||||
|
||||
<p>在代码实现中，我们使用了与堆章节相同的从顶至底堆化（Sift Down）的函数。值得注意的是，由于堆的长度会随着提取最大元素而减小，因此我们需要给 Sift Down 函数添加一个长度参数 <span class="arithmatex">\(n\)</span> ，用于指定堆的当前有效长度。</p>
|
||||
<p>在代码实现中，我们使用了与堆章节相同的从顶至底堆化 <code>sift_down()</code> 函数。值得注意的是，由于堆的长度会随着提取最大元素而减小，因此我们需要给 <code>sift_down()</code> 函数添加一个长度参数 <span class="arithmatex">\(n\)</span> ，用于指定堆的当前有效长度。</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">
|
||||
|
|
|
|||
|
|
@ -3428,12 +3428,12 @@
|
|||
<h1 id="114">11.4 插入排序<a class="headerlink" href="#114" title="Permanent link">¶</a></h1>
|
||||
<p>「插入排序 insertion sort」是一种简单的排序算法，它的工作原理与手动整理一副牌的过程非常相似。</p>
|
||||
<p>具体来说，我们在未排序区间选择一个基准元素，将该元素与其左侧已排序区间的元素逐一比较大小，并将该元素插入到正确的位置。</p>
|
||||
<p>回忆数组的元素插入操作，设基准元素为 <code>base</code> ，我们需要将从目标索引到 <code>base</code> 之间的所有元素向右移动一位，然后再将 <code>base</code> 赋值给目标索引。</p>
|
||||
<p>下图展示了数组插入元素的操作流程。设基准元素为 <code>base</code> ，我们需要将从目标索引到 <code>base</code> 之间的所有元素向右移动一位，然后再将 <code>base</code> 赋值给目标索引。</p>
|
||||
<p><img alt="单次插入操作" src="../insertion_sort.assets/insertion_operation.png" /></p>
|
||||
<p align="center"> 图：单次插入操作 </p>
|
||||
|
||||
<h2 id="1141">11.4.1 算法流程<a class="headerlink" href="#1141" title="Permanent link">¶</a></h2>
|
||||
<p>插入排序的整体流程如下：</p>
|
||||
<p>插入排序的整体流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>初始状态下，数组的第 1 个元素已完成排序。</li>
|
||||
<li>选取数组的第 2 个元素作为 <code>base</code> ，将其插入到正确位置后，<strong>数组的前 2 个元素已排序</strong>。</li>
|
||||
|
|
|
|||
|
|
@ -3426,7 +3426,7 @@
|
|||
|
||||
|
||||
<h1 id="116">11.6 归并排序<a class="headerlink" href="#116" title="Permanent link">¶</a></h1>
|
||||
<p>「归并排序 merge sort」基于分治思想实现排序，包含“划分”和“合并”两个阶段：</p>
|
||||
<p>「归并排序 merge sort」是一种基于分治策略的排序算法，包含下图所示的“划分”和“合并”阶段：</p>
|
||||
<ol>
|
||||
<li><strong>划分阶段</strong>：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题。</li>
|
||||
<li><strong>合并阶段</strong>：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束。</li>
|
||||
|
|
@ -3435,7 +3435,7 @@
|
|||
<p align="center"> 图：归并排序的划分与合并阶段 </p>
|
||||
|
||||
<h2 id="1161">11.6.1 算法流程<a class="headerlink" href="#1161" title="Permanent link">¶</a></h2>
|
||||
<p>“划分阶段”从顶至底递归地将数组从中点切为两个子数组：</p>
|
||||
<p>如下图所示，“划分阶段”从顶至底递归地将数组从中点切为两个子数组：</p>
|
||||
<ol>
|
||||
<li>计算数组中点 <code>mid</code> ，递归划分左子数组（区间 <code>[left, mid]</code> ）和右子数组（区间 <code>[mid + 1, right]</code> ）。</li>
|
||||
<li>递归执行步骤 <code>1.</code> ，直至子数组区间长度为 1 时，终止递归划分。</li>
|
||||
|
|
@ -3477,7 +3477,7 @@
|
|||
</div>
|
||||
<p align="center"> 图：归并排序步骤 </p>
|
||||
|
||||
<p>观察发现，归并排序的递归顺序与二叉树的后序遍历相同，具体来看：</p>
|
||||
<p>观察发现，归并排序的递归顺序与二叉树的后序遍历相同，对比来看：</p>
|
||||
<ul>
|
||||
<li><strong>后序遍历</strong>：先递归左子树，再递归右子树，最后处理根节点。</li>
|
||||
<li><strong>归并排序</strong>：先递归左子数组，再递归右子数组，最后处理合并。</li>
|
||||
|
|
|
|||
|
|
@ -3454,14 +3454,13 @@
|
|||
|
||||
|
||||
<h1 id="115">11.5 快速排序<a class="headerlink" href="#115" title="Permanent link">¶</a></h1>
|
||||
<p>「快速排序 quick sort」是一种基于分治思想的排序算法，运行高效，应用广泛。</p>
|
||||
<p>快速排序的核心操作是“哨兵划分”，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。具体来说，哨兵划分的流程为：</p>
|
||||
<p>「快速排序 quick sort」是一种基于分治策略的排序算法，运行高效，应用广泛。</p>
|
||||
<p>快速排序的核心操作是“哨兵划分”，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。具体来说，哨兵划分的流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>选取数组最左端元素作为基准数，初始化两个指针 <code>i</code> 和 <code>j</code> 分别指向数组的两端。</li>
|
||||
<li>设置一个循环，在每轮中使用 <code>i</code>（<code>j</code>）分别寻找第一个比基准数大（小）的元素，然后交换这两个元素。</li>
|
||||
<li>循环执行步骤 <code>2.</code> ，直到 <code>i</code> 和 <code>j</code> 相遇时停止，最后将基准数交换至两个子数组的分界线。</li>
|
||||
</ol>
|
||||
<p>哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 <span class="arithmatex">\(\leq\)</span> 基准数 <span class="arithmatex">\(\leq\)</span> 右子数组任意元素”。因此，我们接下来只需对这两个子数组进行排序。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:9"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3495,8 +3494,9 @@
|
|||
</div>
|
||||
<p align="center"> 图：哨兵划分步骤 </p>
|
||||
|
||||
<p>哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 <span class="arithmatex">\(\leq\)</span> 基准数 <span class="arithmatex">\(\leq\)</span> 右子数组任意元素”。因此，我们接下来只需对这两个子数组进行排序。</p>
|
||||
<div class="admonition note">
|
||||
<p class="admonition-title">快速排序的分治思想</p>
|
||||
<p class="admonition-title">快速排序的分治策略</p>
|
||||
<p>哨兵划分的实质是将一个较长数组的排序问题简化为两个较短数组的排序问题。</p>
|
||||
</div>
|
||||
<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>
|
||||
|
|
@ -3793,6 +3793,7 @@
|
|||
</div>
|
||||
</div>
|
||||
<h2 id="1151">11.5.1 算法流程<a class="headerlink" href="#1151" title="Permanent link">¶</a></h2>
|
||||
<p>快速排序的整体流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>首先，对原数组执行一次“哨兵划分”，得到未排序的左子数组和右子数组。</li>
|
||||
<li>然后，对左子数组和右子数组分别递归执行“哨兵划分”。</li>
|
||||
|
|
|
|||
|
|
@ -3415,7 +3415,7 @@
|
|||
<p>上一节我们介绍了计数排序，它适用于数据量 <span class="arithmatex">\(n\)</span> 较大但数据范围 <span class="arithmatex">\(m\)</span> 较小的情况。假设我们需要对 <span class="arithmatex">\(n = 10^6\)</span> 个学号进行排序，而学号是一个 <span class="arithmatex">\(8\)</span> 位数字，这意味着数据范围 <span class="arithmatex">\(m = 10^8\)</span> 非常大，使用计数排序需要分配大量内存空间，而基数排序可以避免这种情况。</p>
|
||||
<p>「基数排序 radix sort」的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。</p>
|
||||
<h2 id="11101">11.10.1 算法流程<a class="headerlink" href="#11101" title="Permanent link">¶</a></h2>
|
||||
<p>以学号数据为例，假设数字的最低位是第 <span class="arithmatex">\(1\)</span> 位，最高位是第 <span class="arithmatex">\(8\)</span> 位，基数排序的步骤如下：</p>
|
||||
<p>以学号数据为例，假设数字的最低位是第 <span class="arithmatex">\(1\)</span> 位，最高位是第 <span class="arithmatex">\(8\)</span> 位，基数排序的流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>初始化位数 <span class="arithmatex">\(k = 1\)</span> 。</li>
|
||||
<li>对学号的第 <span class="arithmatex">\(k\)</span> 位执行“计数排序”。完成后，数据会根据第 <span class="arithmatex">\(k\)</span> 位从小到大排序。</li>
|
||||
|
|
|
|||
|
|
@ -3399,7 +3399,7 @@
|
|||
|
||||
<h1 id="112">11.2 选择排序<a class="headerlink" href="#112" title="Permanent link">¶</a></h1>
|
||||
<p>「选择排序 selection sort」的工作原理非常直接：开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。</p>
|
||||
<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，选择排序的算法流程如下：</p>
|
||||
<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，选择排序的算法流程如下图所示。</p>
|
||||
<ol>
|
||||
<li>初始状态下，所有元素未排序，即未排序（索引）区间为 <span class="arithmatex">\([0, n-1]\)</span> 。</li>
|
||||
<li>选取区间 <span class="arithmatex">\([0, n-1]\)</span> 中的最小元素，将其与索引 <span class="arithmatex">\(0\)</span> 处元素交换。完成后，数组前 1 个元素已排序。</li>
|
||||
|
|
@ -3664,7 +3664,7 @@
|
|||
<ul>
|
||||
<li><strong>时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> 、非自适应排序</strong>：外循环共 <span class="arithmatex">\(n - 1\)</span> 轮，第一轮的未排序区间长度为 <span class="arithmatex">\(n\)</span> ，最后一轮的未排序区间长度为 <span class="arithmatex">\(2\)</span> ，即各轮外循环分别包含 <span class="arithmatex">\(n\)</span> , <span class="arithmatex">\(n - 1\)</span> , <span class="arithmatex">\(\dots\)</span> , <span class="arithmatex">\(2\)</span> 轮内循环，求和为 <span class="arithmatex">\(\frac{(n - 1)(n + 2)}{2}\)</span> 。</li>
|
||||
<li><strong>空间复杂度 <span class="arithmatex">\(O(1)\)</span> 、原地排序</strong>：指针 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 使用常数大小的额外空间。</li>
|
||||
<li><strong>非稳定排序</strong>：在交换元素时，有可能将 <code>nums[i]</code> 交换至其相等元素的右边，导致两者的相对顺序发生改变。</li>
|
||||
<li><strong>非稳定排序</strong>：如下图所示，元素 <code>nums[i]</code> 有可能被交换至与其相等的元素的右边，导致两者相对顺序发生改变。</li>
|
||||
</ul>
|
||||
<p><img alt="选择排序非稳定示例" src="../selection_sort.assets/selection_sort_instability.png" /></p>
|
||||
<p align="center"> 图：选择排序非稳定示例 </p>
|
||||
|
|
|
|||
|
|
@ -3413,7 +3413,7 @@
|
|||
|
||||
<h1 id="111">11.1 排序算法<a class="headerlink" href="#111" title="Permanent link">¶</a></h1>
|
||||
<p>「排序算法 sorting algorithm」用于对一组数据按照特定顺序进行排列。排序算法有着广泛的应用，因为有序数据通常能够被更有效地查找、分析和处理。</p>
|
||||
<p>在排序算法中，数据类型可以是整数、浮点数、字符或字符串等；顺序的判断规则可根据需求设定，如数字大小、字符 ASCII 码顺序或自定义规则。</p>
|
||||
<p>如下图所示，排序算法中的数据类型可以是整数、浮点数、字符或字符串等。排序的判断规则可根据需求设定，如数字大小、字符 ASCII 码顺序或自定义规则。</p>
|
||||
<p><img alt="数据类型和判断规则示例" src="../sorting_algorithm.assets/sorting_examples.png" /></p>
|
||||
<p align="center"> 图：数据类型和判断规则示例 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3407,6 +3407,7 @@
|
|||
<li>计数排序是桶排序的一个特例，它通过统计数据出现的次数来实现排序。计数排序适用于数据量大但数据范围有限的情况，并且要求数据能够转换为正整数。</li>
|
||||
<li>基数排序通过逐位排序来实现数据排序，要求数据能够表示为固定位数的数字。</li>
|
||||
<li>总的来说，我们希望找到一种排序算法，具有高效率、稳定、原地以及正向自适应性等优点。然而，正如其他数据结构和算法一样，没有一种排序算法能够同时满足所有这些条件。在实际应用中，我们需要根据数据的特性来选择合适的排序算法。</li>
|
||||
<li>下图对比了主流排序算法的效率、稳定性、就地性和自适应性等。</li>
|
||||
</ul>
|
||||
<p><img alt="排序算法对比" src="../summary.assets/sorting_algorithms_comparison.png" /></p>
|
||||
<p align="center"> 图：排序算法对比 </p>
|
||||
|
|
|
|||
|
|
@ -3466,7 +3466,7 @@
|
|||
|
||||
|
||||
<h1 id="53">5.3 双向队列<a class="headerlink" href="#53" title="Permanent link">¶</a></h1>
|
||||
<p>对于队列，我们仅能在头部删除或在尾部添加元素。然而，「双向队列 deque」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。</p>
|
||||
<p>在队列中，我们仅能在头部删除或在尾部添加元素。如下图所示，「双向队列 deque」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。</p>
|
||||
<p><img alt="双向队列的操作" src="../deque.assets/deque_operations.png" /></p>
|
||||
<p align="center"> 图：双向队列的操作 </p>
|
||||
|
||||
|
|
@ -3798,7 +3798,7 @@
|
|||
<h3 id="1">1. 基于双向链表的实现<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>回顾上一节内容，我们使用普通单向链表来实现队列，因为它可以方便地删除头节点（对应出队操作）和在尾节点后添加新节点（对应入队操作）。</p>
|
||||
<p>对于双向队列而言，头部和尾部都可以执行入队和出队操作。换句话说，双向队列需要实现另一个对称方向的操作。为此，我们采用“双向链表”作为双向队列的底层数据结构。</p>
|
||||
<p>我们将双向链表的头节点和尾节点视为双向队列的队首和队尾，同时实现在两端添加和删除节点的功能。</p>
|
||||
<p>如下图所示，我们将双向链表的头节点和尾节点视为双向队列的队首和队尾，同时实现在两端添加和删除节点的功能。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:5"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">LinkedListDeque</label><label for="__tabbed_2_2">pushLast()</label><label for="__tabbed_2_3">pushFirst()</label><label for="__tabbed_2_4">popLast()</label><label for="__tabbed_2_5">popFirst()</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3820,7 +3820,7 @@
|
|||
</div>
|
||||
<p align="center"> 图：基于链表实现双向队列的入队出队操作 </p>
|
||||
|
||||
<p>以下是具体实现代码。</p>
|
||||
<p>实现代码如下所示。</p>
|
||||
<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">
|
||||
|
|
@ -5418,7 +5418,7 @@
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="2">2. 基于数组的实现<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。在队列的实现基础上，仅需增加“队首入队”和“队尾出队”的方法。</p>
|
||||
<p>如下图所示，与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:5"><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" /><div class="tabbed-labels"><label for="__tabbed_4_1">ArrayDeque</label><label for="__tabbed_4_2">pushLast()</label><label for="__tabbed_4_3">pushFirst()</label><label for="__tabbed_4_4">popLast()</label><label for="__tabbed_4_5">popFirst()</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -5440,7 +5440,7 @@
|
|||
</div>
|
||||
<p align="center"> 图：基于数组实现双向队列的入队出队操作 </p>
|
||||
|
||||
<p>以下是具体实现代码。</p>
|
||||
<p>在队列的实现基础上，仅需增加“队首入队”和“队尾出队”的方法。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="5:12"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><input id="__tabbed_5_11" name="__tabbed_5" type="radio" /><input id="__tabbed_5_12" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Java</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Python</label><label for="__tabbed_5_4">Go</label><label for="__tabbed_5_5">JS</label><label for="__tabbed_5_6">TS</label><label for="__tabbed_5_7">C</label><label for="__tabbed_5_8">C#</label><label for="__tabbed_5_9">Swift</label><label for="__tabbed_5_10">Zig</label><label for="__tabbed_5_11">Dart</label><label for="__tabbed_5_12">Rust</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3467,7 +3467,7 @@
|
|||
|
||||
<h1 id="52">5.2 队列<a class="headerlink" href="#52" title="Permanent link">¶</a></h1>
|
||||
<p>「队列 queue」是一种遵循先入先出规则的线性数据结构。顾名思义，队列模拟了排队现象，即新来的人不断加入队列的尾部，而位于队列头部的人逐个离开。</p>
|
||||
<p>我们把队列的头部称为“队首”，尾部称为“队尾”，把将元素加入队尾的操作称为“入队”，删除队首元素的操作称为“出队”。</p>
|
||||
<p>如下图所示，我们将队列的头部称为“队首”，尾部称为“队尾”，将把元素加入队尾的操作称为“入队”，删除队首元素的操作称为“出队”。</p>
|
||||
<p><img alt="队列的先入先出规则" src="../queue.assets/queue_operations.png" /></p>
|
||||
<p align="center"> 图：队列的先入先出规则 </p>
|
||||
|
||||
|
|
@ -3750,7 +3750,7 @@
|
|||
<h2 id="522">5.2.2 队列实现<a class="headerlink" href="#522" title="Permanent link">¶</a></h2>
|
||||
<p>为了实现队列，我们需要一种数据结构，可以在一端添加元素，并在另一端删除元素。因此，链表和数组都可以用来实现队列。</p>
|
||||
<h3 id="1">1. 基于链表的实现<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>对于链表实现，我们可以将链表的“头节点”和“尾节点”分别视为“队首”和“队尾”，规定队尾仅可添加节点，队首仅可删除节点。</p>
|
||||
<p>如下图所示，我们可以将链表的“头节点”和“尾节点”分别视为“队首”和“队尾”，规定队尾仅可添加节点，队首仅可删除节点。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:3"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">LinkedListQueue</label><label for="__tabbed_2_2">push()</label><label for="__tabbed_2_3">pop()</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3766,7 +3766,7 @@
|
|||
</div>
|
||||
<p align="center"> 图：基于链表实现队列的入队出队操作 </p>
|
||||
|
||||
<p>以下是用链表实现队列的示例代码。</p>
|
||||
<p>以下是用链表实现队列的代码。</p>
|
||||
<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">
|
||||
|
|
@ -4618,10 +4618,10 @@
|
|||
<h3 id="2">2. 基于数组的实现<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>由于数组删除首元素的时间复杂度为 <span class="arithmatex">\(O(n)\)</span> ，这会导致出队操作效率较低。然而，我们可以采用以下巧妙方法来避免这个问题。</p>
|
||||
<p>我们可以使用一个变量 <code>front</code> 指向队首元素的索引，并维护一个变量 <code>queSize</code> 用于记录队列长度。定义 <code>rear = front + queSize</code> ，这个公式计算出的 <code>rear</code> 指向队尾元素之后的下一个位置。</p>
|
||||
<p>基于此设计，<strong>数组中包含元素的有效区间为 [front, rear - 1]</strong>，进而：</p>
|
||||
<p>基于此设计，<strong>数组中包含元素的有效区间为 <code>[front, rear - 1]</code></strong>，各种操作的实现方法如下图所示。</p>
|
||||
<ul>
|
||||
<li>对于入队操作，将输入元素赋值给 <code>rear</code> 索引处，并将 <code>queSize</code> 增加 1 。</li>
|
||||
<li>对于出队操作，只需将 <code>front</code> 增加 1 ，并将 <code>queSize</code> 减少 1 。</li>
|
||||
<li>入队操作：将输入元素赋值给 <code>rear</code> 索引处，并将 <code>queSize</code> 增加 1 。</li>
|
||||
<li>出队操作：只需将 <code>front</code> 增加 1 ，并将 <code>queSize</code> 减少 1 。</li>
|
||||
</ul>
|
||||
<p>可以看到，入队和出队操作都只需进行一次操作，时间复杂度均为 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:3"><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" /><div class="tabbed-labels"><label for="__tabbed_4_1">ArrayQueue</label><label for="__tabbed_4_2">push()</label><label for="__tabbed_4_3">pop()</label></div>
|
||||
|
|
|
|||
|
|
@ -1121,33 +1121,6 @@
|
|||
5.1.3 两种实现对比
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="5.1.3 两种实现对比">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1_1" class="md-nav__link">
|
||||
1. 支持操作
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#2_1" class="md-nav__link">
|
||||
2. 时间效率
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#3" class="md-nav__link">
|
||||
3. 空间效率
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
</ul>
|
||||
</nav>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
|
|
@ -3474,33 +3447,6 @@
|
|||
5.1.3 两种实现对比
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="5.1.3 两种实现对比">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1_1" class="md-nav__link">
|
||||
1. 支持操作
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#2_1" class="md-nav__link">
|
||||
2. 时间效率
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#3" class="md-nav__link">
|
||||
3. 空间效率
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
</ul>
|
||||
</nav>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
|
|
@ -3536,7 +3482,7 @@
|
|||
<h1 id="51">5.1 栈<a class="headerlink" href="#51" title="Permanent link">¶</a></h1>
|
||||
<p>「栈 stack」是一种遵循先入后出的逻辑的线性数据结构。</p>
|
||||
<p>我们可以将栈类比为桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。我们将盘子替换为各种类型的元素（如整数、字符、对象等），就得到了栈数据结构。</p>
|
||||
<p>在栈中，我们把堆叠元素的顶部称为“栈顶”，底部称为“栈底”。将把元素添加到栈顶的操作叫做“入栈”，而删除栈顶元素的操作叫做“出栈”。</p>
|
||||
<p>如下图所示，我们把堆叠元素的顶部称为“栈顶”，底部称为“栈底”。将把元素添加到栈顶的操作叫做“入栈”，删除栈顶元素的操作叫做“出栈”。</p>
|
||||
<p><img alt="栈的先入后出规则" src="../stack.assets/stack_operations.png" /></p>
|
||||
<p align="center"> 图：栈的先入后出规则 </p>
|
||||
|
||||
|
|
@ -3817,7 +3763,7 @@
|
|||
<p>栈遵循先入后出的原则，因此我们只能在栈顶添加或删除元素。然而，数组和链表都可以在任意位置添加和删除元素，<strong>因此栈可以被视为一种受限制的数组或链表</strong>。换句话说，我们可以“屏蔽”数组或链表的部分无关操作，使其对外表现的逻辑符合栈的特性。</p>
|
||||
<h3 id="1">1. 基于链表的实现<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<p>使用链表来实现栈时，我们可以将链表的头节点视为栈顶，尾节点视为栈底。</p>
|
||||
<p>对于入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。而对于出栈操作，只需将头节点从链表中删除即可。</p>
|
||||
<p>如下图所示，对于入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。而对于出栈操作，只需将头节点从链表中删除即可。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:3"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">LinkedListStack</label><label for="__tabbed_2_2">push()</label><label for="__tabbed_2_3">pop()</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4567,7 +4513,7 @@
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="2">2. 基于数组的实现<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>使用数组实现栈时，我们可以将数组的尾部作为栈顶。在这样的设计下，入栈与出栈操作就分别对应在数组尾部添加元素与删除元素，时间复杂度都为 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<p>使用数组实现栈时，我们可以将数组的尾部作为栈顶。如下图所示，入栈与出栈操作分别对应在数组尾部添加元素与删除元素，时间复杂度都为 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:3"><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" /><div class="tabbed-labels"><label for="__tabbed_4_1">ArrayStack</label><label for="__tabbed_4_2">push()</label><label for="__tabbed_4_3">pop()</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -5153,9 +5099,9 @@
|
|||
</div>
|
||||
</div>
|
||||
<h2 id="513">5.1.3 两种实现对比<a class="headerlink" href="#513" title="Permanent link">¶</a></h2>
|
||||
<h3 id="1_1">1. 支持操作<a class="headerlink" href="#1_1" title="Permanent link">¶</a></h3>
|
||||
<p><strong>支持操作</strong></p>
|
||||
<p>两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问，但这已超出了栈的定义范畴，因此一般不会用到。</p>
|
||||
<h3 id="2_1">2. 时间效率<a class="headerlink" href="#2_1" title="Permanent link">¶</a></h3>
|
||||
<p><strong>时间效率</strong></p>
|
||||
<p>在基于数组的实现中，入栈和出栈操作都是在预先分配好的连续内存中进行，具有很好的缓存本地性，因此效率较高。然而，如果入栈时超出数组容量，会触发扩容机制，导致该次入栈操作的时间复杂度变为 <span class="arithmatex">\(O(n)\)</span> 。</p>
|
||||
<p>在链表实现中，链表的扩容非常灵活，不存在上述数组扩容时效率降低的问题。但是，入栈操作需要初始化节点对象并修改指针，因此效率相对较低。不过，如果入栈元素本身就是节点对象，那么可以省去初始化步骤，从而提高效率。</p>
|
||||
<p>综上所述，当入栈与出栈操作的元素是基本数据类型（如 <code>int</code> , <code>double</code> ）时，我们可以得出以下结论：</p>
|
||||
|
|
@ -5163,7 +5109,7 @@
|
|||
<li>基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。</li>
|
||||
<li>基于链表实现的栈可以提供更加稳定的效率表现。</li>
|
||||
</ul>
|
||||
<h3 id="3">3. 空间效率<a class="headerlink" href="#3" title="Permanent link">¶</a></h3>
|
||||
<p><strong>空间效率</strong></p>
|
||||
<p>在初始化列表时，系统会为列表分配“初始容量”，该容量可能超过实际需求。并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容，扩容后的容量也可能超出实际需求。因此，<strong>基于数组实现的栈可能造成一定的空间浪费</strong>。</p>
|
||||
<p>然而，由于链表节点需要额外存储指针，<strong>因此链表节点占用的空间相对较大</strong>。</p>
|
||||
<p>综上，我们不能简单地确定哪种实现更加节省内存，需要针对具体情况进行分析。</p>
|
||||
|
|
|
|||
|
|
@ -3430,13 +3430,14 @@
|
|||
<p>那么，我们能否用数组来表示二叉树呢？答案是肯定的。</p>
|
||||
<h2 id="731">7.3.1 表示完美二叉树<a class="headerlink" href="#731" title="Permanent link">¶</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 表示任意二叉树<a class="headerlink" href="#732" title="Permanent link">¶</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. 左旋<a class="headerlink" href="#2_1" title="Permanent link">¶</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. 先左旋后右旋<a class="headerlink" href="#3" title="Permanent link">¶</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. 先右旋后左旋<a class="headerlink" href="#4" title="Permanent link">¶</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. 排序
|
||||
4. 中序遍历性质
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
|
@ -3446,7 +3446,7 @@
|
|||
|
||||
<li class="md-nav__item">
|
||||
<a href="#4" class="md-nav__link">
|
||||
4. 排序
|
||||
4. 中序遍历性质
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
|
@ -3494,7 +3494,7 @@
|
|||
|
||||
|
||||
<h1 id="74">7.4 二叉搜索树<a class="headerlink" href="#74" title="Permanent link">¶</a></h1>
|
||||
<p>「二叉搜索树 binary search tree」满足以下条件：</p>
|
||||
<p>如下图所示，「二叉搜索树 binary search tree」满足以下条件：</p>
|
||||
<ol>
|
||||
<li>对于根节点，左子树中所有节点的值 <span class="arithmatex">\(<\)</span> 根节点的值 <span class="arithmatex">\(<\)</span> 右子树中所有节点的值。</li>
|
||||
<li>任意节点的左、右子树也是二叉搜索树，即同样满足条件 <code>1.</code> 。</li>
|
||||
|
|
@ -3505,7 +3505,7 @@
|
|||
<h2 id="741">7.4.1 二叉搜索树的操作<a class="headerlink" href="#741" title="Permanent link">¶</a></h2>
|
||||
<p>我们将二叉搜索树封装为一个类 <code>ArrayBinaryTree</code> ，并声明一个成员变量 <code>root</code> ，指向树的根节点。</p>
|
||||
<h3 id="1">1. 查找节点<a class="headerlink" href="#1" title="Permanent link">¶</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 < num</code> ，说明目标节点在 <code>cur</code> 的右子树中，因此执行 <code>cur = cur.right</code> 。</li>
|
||||
<li>若 <code>cur.val > num</code> ，说明目标节点在 <code>cur</code> 的左子树中，因此执行 <code>cur = cur.left</code> 。</li>
|
||||
|
|
@ -3789,15 +3789,19 @@
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="2">2. 插入节点<a class="headerlink" href="#2" title="Permanent link">¶</a></h3>
|
||||
<p>给定一个待插入元素 <code>num</code> ，为了保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，插入操作分为两步：</p>
|
||||
<p>给定一个待插入元素 <code>num</code> ，为了保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，插入操作流程如下图所示。</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. 删除节点<a class="headerlink" href="#3" title="Permanent link">¶</a></h3>
|
||||
<p>与插入节点类似，我们需要在删除操作后维持二叉搜索树的“左子树 < 根节点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除节点。接下来，根据待删除节点的子节点数量，删除操作需分为三种情况：</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">\(<\)</span> 根 <span class="arithmatex">\(<\)</span> 右”的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。</p>
|
||||
<p>假设我们选择右子树的最小节点（即中序遍历的下一个节点），则删除操作为：</p>
|
||||
<p>当待删除节点的度为 <span class="arithmatex">\(2\)</span> 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左 <span class="arithmatex">\(<\)</span> 根 <span class="arithmatex">\(<\)</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. 排序<a class="headerlink" href="#4" title="Permanent link">¶</a></h3>
|
||||
<p>我们知道，二叉树的中序遍历遵循“左 <span class="arithmatex">\(\rightarrow\)</span> 根 <span class="arithmatex">\(\rightarrow\)</span> 右”的遍历顺序，而二叉搜索树满足“左子节点 <span class="arithmatex">\(<\)</span> 根节点 <span class="arithmatex">\(<\)</span> 右子节点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：<strong>二叉搜索树的中序遍历序列是升序的</strong>。</p>
|
||||
<h3 id="4">4. 中序遍历性质<a class="headerlink" href="#4" title="Permanent link">¶</a></h3>
|
||||
<p>如下图所示，二叉树的中序遍历遵循“左 <span class="arithmatex">\(\rightarrow\)</span> 根 <span class="arithmatex">\(\rightarrow\)</span> 右”的遍历顺序，而二叉搜索树满足“左子节点 <span class="arithmatex">\(<\)</span> 根节点 <span class="arithmatex">\(<\)</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 二叉搜索树的效率<a class="headerlink" href="#742" title="Permanent link">¶</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 二叉树基本操作
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#713" class="md-nav__link">
|
||||
7.1.3 常见二叉树类型
|
||||
</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. 初始化二叉树
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
</ul>
|
||||
</nav>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#713" class="md-nav__link">
|
||||
7.1.3 插入与删除节点
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#714" class="md-nav__link">
|
||||
7.1.4 常见二叉树类型
|
||||
</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. 完美二叉树
|
||||
</a>
|
||||
|
||||
|
|
@ -1436,8 +1456,8 @@
|
|||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#714" class="md-nav__link">
|
||||
7.1.4 二叉树的退化
|
||||
<a href="#715" class="md-nav__link">
|
||||
7.1.5 二叉树的退化
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
|
@ -3434,18 +3454,38 @@
|
|||
7.1.2 二叉树基本操作
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#713" class="md-nav__link">
|
||||
7.1.3 常见二叉树类型
|
||||
</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. 初始化二叉树
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
</ul>
|
||||
</nav>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#713" class="md-nav__link">
|
||||
7.1.3 插入与删除节点
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#714" class="md-nav__link">
|
||||
7.1.4 常见二叉树类型
|
||||
</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. 完美二叉树
|
||||
</a>
|
||||
|
||||
|
|
@ -3478,8 +3518,8 @@
|
|||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#714" class="md-nav__link">
|
||||
7.1.4 二叉树的退化
|
||||
<a href="#715" class="md-nav__link">
|
||||
7.1.5 二叉树的退化
|
||||
</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 二叉树常见术语<a class="headerlink" href="#711" title="Permanent link">¶</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 二叉树基本操作<a class="headerlink" href="#712" title="Permanent link">¶</a></h2>
|
||||
<p><strong>初始化二叉树</strong>。与链表类似，首先初始化节点，然后构建引用指向（即指针）。</p>
|
||||
<h3 id="1">1. 初始化二叉树<a class="headerlink" href="#1" title="Permanent link">¶</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 插入与删除节点<a class="headerlink" href="#713" title="Permanent link">¶</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 常见二叉树类型<a class="headerlink" href="#713" title="Permanent link">¶</a></h2>
|
||||
<h3 id="1">1. 完美二叉树<a class="headerlink" href="#1" title="Permanent link">¶</a></h3>
|
||||
<h2 id="714">7.1.4 常见二叉树类型<a class="headerlink" href="#714" title="Permanent link">¶</a></h2>
|
||||
<h3 id="1_1">1. 完美二叉树<a class="headerlink" href="#1_1" title="Permanent link">¶</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. 完全二叉树<a class="headerlink" href="#2" title="Permanent link">¶</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. 完满二叉树<a class="headerlink" href="#3" title="Permanent link">¶</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. 平衡二叉树<a class="headerlink" href="#4" title="Permanent link">¶</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 二叉树的退化<a class="headerlink" href="#714" title="Permanent link">¶</a></h2>
|
||||
<h2 id="715">7.1.5 二叉树的退化<a class="headerlink" href="#715" title="Permanent link">¶</a></h2>
|
||||
<p>当二叉树的每层节点都被填满时，达到“完美二叉树”；而当所有节点都偏向一侧时，二叉树退化为“链表”。</p>
|
||||
<ul>
|
||||
<li>完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势。</li>
|
||||
|
|
|
|||
|
|
@ -3415,7 +3415,7 @@
|
|||
<p>从物理结构的角度来看，树是一种基于链表的数据结构，因此其遍历方式是通过指针逐个访问节点。然而，树是一种非线性数据结构，这使得遍历树比遍历链表更加复杂，需要借助搜索算法来实现。</p>
|
||||
<p>二叉树常见的遍历方式包括层序遍历、前序遍历、中序遍历和后序遍历等。</p>
|
||||
<h2 id="721">7.2.1 层序遍历<a class="headerlink" href="#721" title="Permanent link">¶</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 前序、中序、后序遍历<a class="headerlink" href="#722" title="Permanent link">¶</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>
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
202
sitemap.xml
202
sitemap.xml
|
|
@ -2,507 +2,507 @@
|
|||
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/contribution/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/installation/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/array/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/linked_list/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/list/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/backtracking_algorithm/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/n_queens_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/permutations_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/subset_sum_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/performance_evaluation/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/space_complexity/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/time_complexity/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/basic_data_types/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/character_encoding/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/classification_of_data_structure/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/number_encoding/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/binary_search_recur/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/build_binary_tree_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/divide_and_conquer/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/hanota_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/dp_problem_features/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/dp_solution_pipeline/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/edit_distance_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/intro_to_dynamic_programming/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/knapsack_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/unbounded_knapsack_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph_operations/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph_traversal/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/fractional_knapsack_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/greedy_algorithm/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/max_capacity_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/max_product_cutting_problem/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_algorithm/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_collision/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_map/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/build_heap/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/heap/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/top_k/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/algorithms_are_everywhere/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/what_is_dsa/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/about_the_book/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/suggestions/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_reference/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/binary_search/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/binary_search_edge/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/binary_search_insertion/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/replace_linear_by_hashing/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/searching_algorithm_revisited/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/bubble_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/bucket_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/counting_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/heap_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/insertion_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/merge_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/quick_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/radix_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/selection_sort/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/sorting_algorithm/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/deque/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/queue/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/stack/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/array_representation_of_tree/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/avl_tree/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_search_tree/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_tree/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_tree_traversal/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/summary/</loc>
|
||||
<lastmod>2023-08-20</lastmod>
|
||||
<lastmod>2023-08-21</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
</urlset>
|
||||
BIN
sitemap.xml.gz
BIN
sitemap.xml.gz
Binary file not shown.
Loading…
Reference in a new issue