This commit is contained in:
krahets 2023-08-20 13:37:20 +08:00
parent 88e0b11361
commit 96fded547b
35 changed files with 777 additions and 716 deletions

View File

@ -944,50 +944,50 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
初始化数组
<a href="#1" class="md-nav__link">
1. &nbsp; 初始化数组
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
访问元素
<a href="#2" class="md-nav__link">
2. &nbsp; 访问元素
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
插入元素
<a href="#3" class="md-nav__link">
3. &nbsp; 插入元素
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
删除元素
<a href="#4" class="md-nav__link">
4. &nbsp; 删除元素
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
遍历数组
<a href="#5" class="md-nav__link">
5. &nbsp; 遍历数组
</a>
</li>
<li class="md-nav__item">
<a href="#_6" class="md-nav__link">
查找元素
<a href="#6" class="md-nav__link">
6. &nbsp; 查找元素
</a>
</li>
<li class="md-nav__item">
<a href="#_7" class="md-nav__link">
扩容数组
<a href="#7" class="md-nav__link">
7. &nbsp; 扩容数组
</a>
</li>
@ -3445,50 +3445,50 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
初始化数组
<a href="#1" class="md-nav__link">
1. &nbsp; 初始化数组
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
访问元素
<a href="#2" class="md-nav__link">
2. &nbsp; 访问元素
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
插入元素
<a href="#3" class="md-nav__link">
3. &nbsp; 插入元素
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
删除元素
<a href="#4" class="md-nav__link">
4. &nbsp; 删除元素
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
遍历数组
<a href="#5" class="md-nav__link">
5. &nbsp; 遍历数组
</a>
</li>
<li class="md-nav__item">
<a href="#_6" class="md-nav__link">
查找元素
<a href="#6" class="md-nav__link">
6. &nbsp; 查找元素
</a>
</li>
<li class="md-nav__item">
<a href="#_7" class="md-nav__link">
扩容数组
<a href="#7" class="md-nav__link">
7. &nbsp; 扩容数组
</a>
</li>
@ -3541,7 +3541,7 @@
<p align="center"> 图:数组定义与存储方式 </p>
<h2 id="411">4.1.1 &nbsp; 数组常用操作<a class="headerlink" href="#411" title="Permanent link">&para;</a></h2>
<h3 id="_1">初始化数组<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 初始化数组<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>我们可以根据需求选用数组的两种初始化方式:无初始值、给定初始值。在未指定初始值的情况下,大多数编程语言会将数组元素初始化为 <span class="arithmatex">\(0\)</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">
@ -3625,7 +3625,7 @@
</div>
</div>
</div>
<h3 id="_2">访问元素<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 访问元素<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>数组元素被存储在连续的内存空间中,这意味着计算数组元素的内存地址非常容易。给定数组内存地址(即首元素内存地址)和某个元素的索引,我们可以使用以下公式计算得到该元素的内存地址,从而直接访问此元素。</p>
<div class="highlight"><pre><span></span><code><a id="__codelineno-12-1" name="__codelineno-12-1" href="#__codelineno-12-1"></a><span class="c1"># 元素内存地址 = 数组内存地址(首元素内存地址) + 元素长度 * 元素索引</span>
<a id="__codelineno-12-2" name="__codelineno-12-2" href="#__codelineno-12-2"></a><span class="nv">elementAddr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>firtstElementAddr<span class="w"> </span>+<span class="w"> </span>elementLength<span class="w"> </span>*<span class="w"> </span>elementIndex
@ -3771,7 +3771,7 @@
</div>
</div>
</div>
<h3 id="_3">插入元素<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 插入元素<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>数组元素在内存中是“紧挨着的”,它们之间没有空间再存放任何数据。这意味着如果想要在数组中间插入一个元素,则需要将该元素之后的所有元素都向后移动一位,之后再把元素赋值给该索引。</p>
<p>值得注意的是,由于数组的长度是固定的,因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。</p>
<p><img alt="数组插入元素" src="../array.assets/array_insert_element.png" /></p>
@ -3924,7 +3924,7 @@
</div>
</div>
</div>
<h3 id="_4">删除元素<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 删除元素<a class="headerlink" href="#4" title="Permanent link">&para;</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>
@ -4061,7 +4061,7 @@
<li><strong>丢失元素</strong>:由于数组的长度不可变,因此在插入元素后,超出数组长度范围的元素会丢失。</li>
<li><strong>内存浪费</strong>:我们可以初始化一个比较长的数组,只用前面一部分,这样在插入数据时,丢失的末尾元素都是“无意义”的,但这样做也会造成部分内存空间的浪费。</li>
</ul>
<h3 id="_5">遍历数组<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
<h3 id="5">5. &nbsp; 遍历数组<a class="headerlink" href="#5" title="Permanent link">&para;</a></h3>
<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">
@ -4246,7 +4246,7 @@
</div>
</div>
</div>
<h3 id="_6">查找元素<a class="headerlink" href="#_6" title="Permanent link">&para;</a></h3>
<h3 id="6">6. &nbsp; 查找元素<a class="headerlink" href="#6" title="Permanent link">&para;</a></h3>
<p>在数组中查找指定元素需要遍历数组,每轮判断元素值是否匹配,若匹配则输出对应索引。</p>
<p>因为数组是线性数据结构,所以上述查找操作被称为「线性查找」。</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>
@ -4386,7 +4386,7 @@
</div>
</div>
</div>
<h3 id="_7">扩容数组<a class="headerlink" href="#_7" title="Permanent link">&para;</a></h3>
<h3 id="7">7. &nbsp; 扩容数组<a class="headerlink" href="#7" title="Permanent link">&para;</a></h3>
<p>在复杂的系统环境中,程序难以保证数组之后的内存空间是可用的,从而无法安全地扩展数组容量。因此在大多数编程语言中,<strong>数组的长度是不可变的</strong></p>
<p>如果我们希望扩容数组,则需重新建立一个更大的数组,然后把原数组元素依次拷贝到新数组。这是一个 <span class="arithmatex">\(O(n)\)</span> 的操作,在数组很大的情况下是非常耗时的。</p>
<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>

View File

@ -964,36 +964,36 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
初始化链表
<a href="#1" class="md-nav__link">
1. &nbsp; 初始化链表
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
插入节点
<a href="#2" class="md-nav__link">
2. &nbsp; 插入节点
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
删除节点
<a href="#3" class="md-nav__link">
3. &nbsp; 删除节点
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
访问节点
<a href="#4" class="md-nav__link">
4. &nbsp; 访问节点
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
查找节点
<a href="#5" class="md-nav__link">
5. &nbsp; 查找节点
</a>
</li>
@ -3438,36 +3438,36 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
初始化链表
<a href="#1" class="md-nav__link">
1. &nbsp; 初始化链表
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
插入节点
<a href="#2" class="md-nav__link">
2. &nbsp; 插入节点
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
删除节点
<a href="#3" class="md-nav__link">
3. &nbsp; 删除节点
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
访问节点
<a href="#4" class="md-nav__link">
4. &nbsp; 访问节点
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
查找节点
<a href="#5" class="md-nav__link">
5. &nbsp; 查找节点
</a>
</li>
@ -3683,7 +3683,7 @@
</div>
</div>
<h2 id="421">4.2.1 &nbsp; 链表常用操作<a class="headerlink" href="#421" title="Permanent link">&para;</a></h2>
<h3 id="_1">初始化链表<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 初始化链表<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>建立链表分为两步,第一步是初始化各个节点对象,第二步是构建引用指向关系。初始化完成后,我们就可以从链表的头节点出发,通过引用指向 <code>next</code> 依次访问所有节点。</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">
@ -3871,7 +3871,7 @@
</div>
</div>
<p>数组整体是一个变量,比如数组 <code>nums</code> 包含元素 <code>nums[0]</code> , <code>nums[1]</code> 等,而链表是由多个独立的节点对象组成的。<strong>我们通常将头节点当作链表的代称</strong>,比如以上代码中的链表可被记做链表 <code>n0</code></p>
<h3 id="_2">插入节点<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 插入节点<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p><strong>在链表中插入节点非常容易</strong>。假设我们想在相邻的两个节点 <code>n0</code> , <code>n1</code> 之间插入一个新节点 <code>P</code> ,则只需要改变两个节点引用(指针)即可,时间复杂度为 <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>
@ -3989,7 +3989,7 @@
</div>
</div>
</div>
<h3 id="_3">删除节点<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 删除节点<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>在链表中删除节点也非常简便,只需改变一个节点的引用(指针)即可。</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>
@ -4150,7 +4150,7 @@
</div>
</div>
</div>
<h3 id="_4">访问节点<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 访问节点<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p><strong>在链表访问节点的效率较低</strong>。如上节所述,我们可以在 <span class="arithmatex">\(O(1)\)</span> 时间下访问数组中的任意元素。链表则不然,程序需要从头节点出发,逐个向后遍历,直至找到目标节点。也就是说,访问链表的第 <span class="arithmatex">\(i\)</span> 个节点需要循环 <span class="arithmatex">\(i - 1\)</span> 轮,时间复杂度为 <span class="arithmatex">\(O(n)\)</span></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">
@ -4301,7 +4301,7 @@
</div>
</div>
</div>
<h3 id="_5">查找节点<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
<h3 id="5">5. &nbsp; 查找节点<a class="headerlink" href="#5" title="Permanent link">&para;</a></h3>
<p>遍历链表,查找链表内值为 <code>target</code> 的节点,输出节点在链表中的索引。此过程也属于「线性查找」。</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">

View File

@ -984,43 +984,43 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
初始化列表
<a href="#1" class="md-nav__link">
1. &nbsp; 初始化列表
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
访问元素
<a href="#2" class="md-nav__link">
2. &nbsp; 访问元素
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
插入与删除元素
<a href="#3" class="md-nav__link">
3. &nbsp; 插入与删除元素
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
遍历列表
<a href="#4" class="md-nav__link">
4. &nbsp; 遍历列表
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
拼接列表
<a href="#5" class="md-nav__link">
5. &nbsp; 拼接列表
</a>
</li>
<li class="md-nav__item">
<a href="#_6" class="md-nav__link">
排序列表
<a href="#6" class="md-nav__link">
6. &nbsp; 排序列表
</a>
</li>
@ -3431,43 +3431,43 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
初始化列表
<a href="#1" class="md-nav__link">
1. &nbsp; 初始化列表
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
访问元素
<a href="#2" class="md-nav__link">
2. &nbsp; 访问元素
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
插入与删除元素
<a href="#3" class="md-nav__link">
3. &nbsp; 插入与删除元素
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
遍历列表
<a href="#4" class="md-nav__link">
4. &nbsp; 遍历列表
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
拼接列表
<a href="#5" class="md-nav__link">
5. &nbsp; 拼接列表
</a>
</li>
<li class="md-nav__item">
<a href="#_6" class="md-nav__link">
排序列表
<a href="#6" class="md-nav__link">
6. &nbsp; 排序列表
</a>
</li>
@ -3511,7 +3511,7 @@
<p><strong>数组长度不可变导致实用性降低</strong>。在实际中,我们可能事先无法确定需要存储多少数据,这使数组长度的选择变得困难。若长度过小,需要在持续添加数据时频繁扩容数组;若长度过大,则会造成内存空间的浪费。</p>
<p>为解决此问题,出现了一种被称为「动态数组 Dynamic Array」的数据结构即长度可变的数组也常被称为「列表 List」。列表基于数组实现继承了数组的优点并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素而无需担心超过容量限制。</p>
<h2 id="431">4.3.1 &nbsp; 列表常用操作<a class="headerlink" href="#431" title="Permanent link">&para;</a></h2>
<h3 id="_1">初始化列表<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 初始化列表<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>我们通常使用“无初始值”和“有初始值”这两种初始化方法。</p>
<div class="tabbed-set tabbed-alternate" data-tabs="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">
@ -3611,7 +3611,7 @@
</div>
</div>
</div>
<h3 id="_2">访问元素<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 访问元素<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>列表本质上是数组,因此可以在 <span class="arithmatex">\(O(1)\)</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">
@ -3708,7 +3708,7 @@
</div>
</div>
</div>
<h3 id="_3">插入与删除元素<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 插入与删除元素<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>相较于数组,列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 <span class="arithmatex">\(O(1)\)</span> ,但插入和删除元素的效率仍与数组相同,时间复杂度为 <span class="arithmatex">\(O(n)\)</span></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">
@ -3916,7 +3916,7 @@
</div>
</div>
</div>
<h3 id="_4">遍历列表<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 遍历列表<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<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">
@ -4079,7 +4079,7 @@
</div>
</div>
</div>
<h3 id="_5">拼接列表<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
<h3 id="5">5. &nbsp; 拼接列表<a class="headerlink" href="#5" title="Permanent link">&para;</a></h3>
<p>给定一个新列表 <code>list1</code> ,我们可以将该列表拼接到原列表的尾部。</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">
@ -4158,7 +4158,7 @@
</div>
</div>
</div>
<h3 id="_6">排序列表<a class="headerlink" href="#_6" title="Permanent link">&para;</a></h3>
<h3 id="6">6. &nbsp; 排序列表<a class="headerlink" href="#6" title="Permanent link">&para;</a></h3>
<p>完成列表排序后,我们便可以使用在数组类算法题中经常考察的“二分查找”和“双指针”算法。</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">

View File

@ -2649,22 +2649,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
逐行放置策略
<a href="#1" class="md-nav__link">
1. &nbsp; 逐行放置策略
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
列与对角线剪枝
<a href="#2" class="md-nav__link">
2. &nbsp; 列与对角线剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
代码实现
<a href="#3" class="md-nav__link">
3. &nbsp; 代码实现
</a>
</li>
@ -3382,22 +3382,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
逐行放置策略
<a href="#1" class="md-nav__link">
1. &nbsp; 逐行放置策略
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
列与对角线剪枝
<a href="#2" class="md-nav__link">
2. &nbsp; 列与对角线剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
代码实现
<a href="#3" class="md-nav__link">
3. &nbsp; 代码实现
</a>
</li>
@ -3438,7 +3438,7 @@
<p><img alt="n 皇后问题的约束条件" src="../n_queens_problem.assets/n_queens_constraints.png" /></p>
<p align="center">n 皇后问题的约束条件 </p>
<h3 id="_1">逐行放置策略<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 逐行放置策略<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>皇后的数量和棋盘的行数都为 <span class="arithmatex">\(n\)</span> ,因此我们容易得到一个推论:<strong>棋盘每行都允许且只允许放置一个皇后</strong></p>
<p>也就是说,我们可以采取逐行放置策略:从第一行开始,在每行放置一个皇后,直至最后一行结束。</p>
<p>如下图所示,为 <span class="arithmatex">\(4\)</span> 皇后问题的逐行放置过程。受画幅限制,下图仅展开了第一行的其中一个搜索分支,并且将不满足列约束和对角线约束的方案都进行了剪枝。</p>
@ -3446,7 +3446,7 @@
<p align="center"> 图:逐行放置策略 </p>
<p>本质上看,<strong>逐行放置策略起到了剪枝的作用</strong>,它避免了同一行出现多个皇后的所有搜索分支。</p>
<h3 id="_2">列与对角线剪枝<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 列与对角线剪枝<a class="headerlink" href="#2" title="Permanent link">&para;</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>
@ -3454,7 +3454,7 @@
<p><img alt="处理列约束和对角线约束" src="../n_queens_problem.assets/n_queens_cols_diagonals.png" /></p>
<p align="center"> 图:处理列约束和对角线约束 </p>
<h3 id="_3">代码实现<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 代码实现<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>请注意,<span class="arithmatex">\(n\)</span> 维方阵中 <span class="arithmatex">\(row - col\)</span> 的范围是 <span class="arithmatex">\([-n + 1, n - 1]\)</span> <span class="arithmatex">\(row + col\)</span> 的范围是 <span class="arithmatex">\([0, 2n - 2]\)</span> ,所以主对角线和次对角线的数量都为 <span class="arithmatex">\(2n - 1\)</span> ,即数组 <code>diag1</code><code>diag2</code> 的长度都为 <span class="arithmatex">\(2n - 1\)</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">

View File

@ -2617,15 +2617,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
重复选择剪枝
<a href="#1" class="md-nav__link">
1. &nbsp; 重复选择剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
代码实现
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
@ -2644,22 +2644,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
相等元素剪枝
<a href="#1_1" class="md-nav__link">
1. &nbsp; 相等元素剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
代码实现
<a href="#2_1" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
两种剪枝对比
<a href="#3" class="md-nav__link">
3. &nbsp; 两种剪枝对比
</a>
</li>
@ -3430,15 +3430,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
重复选择剪枝
<a href="#1" class="md-nav__link">
1. &nbsp; 重复选择剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
代码实现
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
@ -3457,22 +3457,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
相等元素剪枝
<a href="#1_1" class="md-nav__link">
1. &nbsp; 相等元素剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
代码实现
<a href="#2_1" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
两种剪枝对比
<a href="#3" class="md-nav__link">
3. &nbsp; 两种剪枝对比
</a>
</li>
@ -3545,7 +3545,7 @@
<p><img alt="全排列的递归树" src="../permutations_problem.assets/permutations_i.png" /></p>
<p align="center"> 图:全排列的递归树 </p>
<h3 id="_1">重复选择剪枝<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 重复选择剪枝<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>为了实现每个元素只被选择一次,我们考虑引入一个布尔型数组 <code>selected</code> ,其中 <code>selected[i]</code> 表示 <code>choices[i]</code> 是否已被选择。剪枝的实现原理为:</p>
<ul>
<li>在做出选择 <code>choice[i]</code> 后,我们就将 <code>selected[i]</code> 赋值为 <span class="arithmatex">\(\text{True}\)</span> ,代表它已被选择。</li>
@ -3556,7 +3556,7 @@
<p align="center"> 图:全排列剪枝示例 </p>
<p>观察上图发现,该剪枝操作将搜索空间大小从 <span class="arithmatex">\(O(n^n)\)</span> 降低至 <span class="arithmatex">\(O(n!)\)</span></p>
<h3 id="_2">代码实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>想清楚以上信息之后,我们就可以在框架代码中做“完形填空”了。为了缩短代码行数,我们不单独实现框架代码中的各个函数,而是将他们展开在 <code>backtrack()</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">
@ -3967,14 +3967,14 @@
<p align="center"> 图:重复排列 </p>
<p>那么如何去除重复的排列呢?最直接地,考虑借助一个哈希表,直接对排列结果进行去重。然而这样做不够优雅,<strong>因为生成重复排列的搜索分支是没有必要的,应当被提前识别并剪枝</strong>,这样可以进一步提升算法效率。</p>
<h3 id="_3">相等元素剪枝<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="1_1">1. &nbsp; 相等元素剪枝<a class="headerlink" href="#1_1" title="Permanent link">&para;</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>本质上看,<strong>我们的目标是在某一轮选择中,保证多个相等的元素仅被选择一次</strong></p>
<p><img alt="重复排列剪枝" src="../permutations_problem.assets/permutations_ii_pruning.png" /></p>
<p align="center"> 图:重复排列剪枝 </p>
<h3 id="_4">代码实现<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="2_1">2. &nbsp; 代码实现<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
<p>在上一题的代码的基础上,我们考虑在每一轮选择中开启一个哈希表 <code>duplicated</code> ,用于记录该轮中已经尝试过的元素,并将重复元素剪枝。</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">
@ -4354,7 +4354,7 @@
</div>
<p>假设元素两两之间互不相同,则 <span class="arithmatex">\(n\)</span> 个元素共有 <span class="arithmatex">\(n!\)</span> 种排列(阶乘);在记录结果时,需要复制长度为 <span class="arithmatex">\(n\)</span> 的列表,使用 <span class="arithmatex">\(O(n)\)</span> 时间。因此,<strong>时间复杂度为 <span class="arithmatex">\(O(n!n)\)</span></strong></p>
<p>最大递归深度为 <span class="arithmatex">\(n\)</span> ,使用 <span class="arithmatex">\(O(n)\)</span> 栈帧空间。<code>selected</code> 使用 <span class="arithmatex">\(O(n)\)</span> 空间。同一时刻最多共有 <span class="arithmatex">\(n\)</span><code>duplicated</code> ,使用 <span class="arithmatex">\(O(n^2)\)</span> 空间。<strong>因此空间复杂度为 <span class="arithmatex">\(O(n^2)\)</span></strong></p>
<h3 id="_5">两种剪枝对比<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 两种剪枝对比<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>请注意,虽然 <code>selected</code><code>duplicated</code> 都用作剪枝,但两者的目标不同:</p>
<ul>
<li><strong>重复选择剪枝</strong>:整个搜索过程中只有一个 <code>selected</code> 。它记录的是当前状态中包含哪些元素,作用是避免某个元素在 <code>state</code> 中重复出现。</li>

View File

@ -2637,22 +2637,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
参考全排列解法
<a href="#1" class="md-nav__link">
1. &nbsp; 参考全排列解法
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
重复子集剪枝
<a href="#2" class="md-nav__link">
2. &nbsp; 重复子集剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
代码实现
<a href="#3" class="md-nav__link">
3. &nbsp; 代码实现
</a>
</li>
@ -2671,15 +2671,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
相等元素剪枝
<a href="#1_1" class="md-nav__link">
1. &nbsp; 相等元素剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
代码实现
<a href="#2_1" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
@ -3430,22 +3430,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
参考全排列解法
<a href="#1" class="md-nav__link">
1. &nbsp; 参考全排列解法
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
重复子集剪枝
<a href="#2" class="md-nav__link">
2. &nbsp; 重复子集剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
代码实现
<a href="#3" class="md-nav__link">
3. &nbsp; 代码实现
</a>
</li>
@ -3464,15 +3464,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
相等元素剪枝
<a href="#1_1" class="md-nav__link">
1. &nbsp; 相等元素剪枝
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
代码实现
<a href="#2_1" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
@ -3516,7 +3516,7 @@
<li>输入集合中的元素可以被无限次重复选取。</li>
<li>子集是不区分元素顺序的,比如 <span class="arithmatex">\(\{4, 5\}\)</span><span class="arithmatex">\(\{5, 4\}\)</span> 是同一个子集。</li>
</ul>
<h3 id="_1">参考全排列解法<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 参考全排列解法<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>类似于全排列问题,我们可以把子集的生成过程想象成一系列选择的结果,并在选择过程中实时更新“元素和”,当元素和等于 <code>target</code> 时,就将子集记录至结果列表。</p>
<p>而与全排列问题不同的是,<strong>本题集合中的元素可以被无限次选取</strong>,因此无需借助 <code>selected</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>
@ -3920,7 +3920,7 @@
<li>当数组元素较多,尤其是当 <code>target</code> 较大时,搜索过程会产生大量的重复子集。</li>
<li>比较子集(数组)的异同非常耗时,需要先排序数组,再比较数组中每个元素的异同。</li>
</ul>
<h3 id="_2">重复子集剪枝<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 重复子集剪枝<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p><strong>我们考虑在搜索过程中通过剪枝进行去重</strong>。观察下图,重复子集是在以不同顺序选择数组元素时产生的,具体来看:</p>
<ol>
<li>第一轮和第二轮分别选择 <span class="arithmatex">\(3\)</span> , <span class="arithmatex">\(4\)</span> ,会生成包含这两个元素的所有子集,记为 <span class="arithmatex">\([3, 4, \cdots]\)</span></li>
@ -3936,7 +3936,7 @@
<p align="center"> 图:不同选择顺序导致的重复子集 </p>
<p>总结来看,给定输入数组 <span class="arithmatex">\([x_1, x_2, \cdots, x_n]\)</span> ,设搜索过程中的选择序列为 <span class="arithmatex">\([x_{i_1}, x_{i_2}, \cdots , x_{i_m}]\)</span> ,则该选择序列需要满足 <span class="arithmatex">\(i_1 \leq i_2 \leq \cdots \leq i_m\)</span> <strong>不满足该条件的选择序列都会造成重复,应当剪枝</strong></p>
<h3 id="_3">代码实现<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 代码实现<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>为实现该剪枝,我们初始化变量 <code>start</code> ,用于指示遍历起点。<strong>当做出选择 <span class="arithmatex">\(x_{i}\)</span> 后,设定下一轮从索引 <span class="arithmatex">\(i\)</span> 开始遍历</strong>。这样做就可以让选择序列满足 <span class="arithmatex">\(i_1 \leq i_2 \leq \cdots \leq i_m\)</span> ,从而保证子集唯一。</p>
<p>除此之外,我们还对代码进行了两项优化:</p>
<ul>
@ -4376,10 +4376,10 @@
<p><img alt="相等元素导致的重复子集" src="../subset_sum_problem.assets/subset_sum_ii_repeat.png" /></p>
<p align="center"> 图:相等元素导致的重复子集 </p>
<h3 id="_4">相等元素剪枝<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="1_1">1. &nbsp; 相等元素剪枝<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
<p>为解决此问题,<strong>我们需要限制相等元素在每一轮中只被选择一次</strong>。实现方式比较巧妙:由于数组是已排序的,因此相等元素都是相邻的。这意味着在某轮选择中,若当前元素与其左边元素相等,则说明它已经被选择过,因此直接跳过当前元素。</p>
<p>与此同时,<strong>本题规定中的每个数组元素只能被选择一次</strong>。幸运的是,我们也可以利用变量 <code>start</code> 来满足该约束:当做出选择 <span class="arithmatex">\(x_{i}\)</span> 后,设定下一轮从索引 <span class="arithmatex">\(i + 1\)</span> 开始向后遍历。这样即能去除重复子集,也能避免重复选择元素。</p>
<h3 id="_5">代码实现<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
<h3 id="2_1">2. &nbsp; 代码实现<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
<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">

View File

@ -3444,10 +3444,10 @@
<p><strong>展开完整测试非常耗费资源</strong>。随着输入数据量的变化,算法会表现出不同的效率。例如,在输入数据量较小时,算法 <code>A</code> 的运行时间比算法 <code>B</code> 更少;而输入数据量较大时,测试结果可能恰恰相反。因此,为了得到有说服力的结论,我们需要测试各种规模的输入数据,而这样需要耗费大量的计算资源。</p>
<h2 id="212">2.1.2 &nbsp; 理论估算<a class="headerlink" href="#212" title="Permanent link">&para;</a></h2>
<p>由于实际测试具有较大的局限性,我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 Asymptotic Complexity Analysis」简称为「复杂度分析」。</p>
<p><strong>复杂度分析评估的是算法运行效率随着输入数据量增多时的增长趋势</strong>。这个定义有些拗口,我们可以将其分为三个重点来理解:</p>
<p>复杂度分析评估的是算法执行所需的时间和空间资源。<strong>它被表示为一个函数,描述了随着输入数据大小的增加,算法所需时间(空间)的增长趋势</strong>。这个定义有些拗口,我们可以将其分为三个重点来理解:</p>
<ol>
<li>算法运行效率”可分为运行时间和占用空间两部分,与之对应地,复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。</li>
<li>“随着输入数据量增多时”意味着复杂度反映了算法运行效率与输入数据量之间的关系。</li>
<li>时间(空间)”分别对应「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。</li>
<li>“随着输入数据大小的增加”意味着复杂度反映了算法运行效率与输入数据量之间的关系。</li>
<li>“增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势,而非具体的运行时间或占用空间。</li>
</ol>
<p><strong>复杂度分析克服了实际测试方法的弊端</strong>。首先,它独立于测试环境,分析结果适用于所有运行平台。其次,它可以体现不同数据量下的算法效率,尤其是在大数据量下的算法性能。</p>

View File

@ -682,36 +682,36 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#o1" class="md-nav__link">
常数阶 \(O(1)\)
<a href="#1-o1" class="md-nav__link">
1. &nbsp; 常数阶 \(O(1)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on" class="md-nav__link">
线性阶 \(O(n)\)
<a href="#2-on" class="md-nav__link">
2. &nbsp; 线性阶 \(O(n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on2" class="md-nav__link">
平方阶 \(O(n^2)\)
<a href="#3-on2" class="md-nav__link">
3. &nbsp; 平方阶 \(O(n^2)\)
</a>
</li>
<li class="md-nav__item">
<a href="#o2n" class="md-nav__link">
指数阶 \(O(2^n)\)
<a href="#4-o2n" class="md-nav__link">
4. &nbsp; 指数阶 \(O(2^n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#olog-n" class="md-nav__link">
对数阶 \(O(\log n)\)
<a href="#5-olog-n" class="md-nav__link">
5. &nbsp; 对数阶 \(O(\log n)\)
</a>
</li>
@ -3452,36 +3452,36 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#o1" class="md-nav__link">
常数阶 \(O(1)\)
<a href="#1-o1" class="md-nav__link">
1. &nbsp; 常数阶 \(O(1)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on" class="md-nav__link">
线性阶 \(O(n)\)
<a href="#2-on" class="md-nav__link">
2. &nbsp; 线性阶 \(O(n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on2" class="md-nav__link">
平方阶 \(O(n^2)\)
<a href="#3-on2" class="md-nav__link">
3. &nbsp; 平方阶 \(O(n^2)\)
</a>
</li>
<li class="md-nav__item">
<a href="#o2n" class="md-nav__link">
指数阶 \(O(2^n)\)
<a href="#4-o2n" class="md-nav__link">
4. &nbsp; 指数阶 \(O(2^n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#olog-n" class="md-nav__link">
对数阶 \(O(\log n)\)
<a href="#5-olog-n" class="md-nav__link">
5. &nbsp; 对数阶 \(O(\log n)\)
</a>
</li>
@ -4121,7 +4121,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
<p class="admonition-title">Tip</p>
<p>部分示例代码需要一些前置知识,包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方,可以在学习完后面章节后再来复习。</p>
</div>
<h3 id="o1">常数阶 <span class="arithmatex">\(O(1)\)</span><a class="headerlink" href="#o1" title="Permanent link">&para;</a></h3>
<h3 id="1-o1">1. &nbsp; 常数阶 <span class="arithmatex">\(O(1)\)</span><a class="headerlink" href="#1-o1" title="Permanent link">&para;</a></h3>
<p>常数阶常见于数量与输入数据大小 <span class="arithmatex">\(n\)</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>
@ -4431,7 +4431,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
</div>
</div>
</div>
<h3 id="on">线性阶 <span class="arithmatex">\(O(n)\)</span><a class="headerlink" href="#on" title="Permanent link">&para;</a></h3>
<h3 id="2-on">2. &nbsp; 线性阶 <span class="arithmatex">\(O(n)\)</span><a class="headerlink" href="#2-on" title="Permanent link">&para;</a></h3>
<p>线性阶常见于元素数量与 <span class="arithmatex">\(n\)</span> 成正比的数组、链表、栈、队列等。</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">
@ -4798,7 +4798,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
<p><img alt="递归函数产生的线性阶空间复杂度" src="../space_complexity.assets/space_complexity_recursive_linear.png" /></p>
<p align="center"> 图:递归函数产生的线性阶空间复杂度 </p>
<h3 id="on2">平方阶 <span class="arithmatex">\(O(n^2)\)</span><a class="headerlink" href="#on2" title="Permanent link">&para;</a></h3>
<h3 id="3-on2">3. &nbsp; 平方阶 <span class="arithmatex">\(O(n^2)\)</span><a class="headerlink" href="#3-on2" title="Permanent link">&para;</a></h3>
<p>平方阶常见于矩阵和图,元素数量与 <span class="arithmatex">\(n\)</span> 成平方关系。</p>
<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">
@ -5133,7 +5133,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
<p><img alt="递归函数产生的平方阶空间复杂度" src="../space_complexity.assets/space_complexity_recursive_quadratic.png" /></p>
<p align="center"> 图:递归函数产生的平方阶空间复杂度 </p>
<h3 id="o2n">指数阶 <span class="arithmatex">\(O(2^n)\)</span><a class="headerlink" href="#o2n" title="Permanent link">&para;</a></h3>
<h3 id="4-o2n">4. &nbsp; 指数阶 <span class="arithmatex">\(O(2^n)\)</span><a class="headerlink" href="#4-o2n" title="Permanent link">&para;</a></h3>
<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">
@ -5282,7 +5282,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
<p><img alt="满二叉树产生的指数阶空间复杂度" src="../space_complexity.assets/space_complexity_exponential.png" /></p>
<p align="center"> 图:满二叉树产生的指数阶空间复杂度 </p>
<h3 id="olog-n">对数阶 <span class="arithmatex">\(O(\log n)\)</span><a class="headerlink" href="#olog-n" title="Permanent link">&para;</a></h3>
<h3 id="5-olog-n">5. &nbsp; 对数阶 <span class="arithmatex">\(O(\log n)\)</span><a class="headerlink" href="#5-olog-n" title="Permanent link">&para;</a></h3>
<p>对数阶常见于分治算法和数据类型转换等。</p>
<p>例如“归并排序”算法,输入长度为 <span class="arithmatex">\(n\)</span> 的数组,每轮递归将数组从中点划分为两半,形成高度为 <span class="arithmatex">\(\log n\)</span> 的递归树,使用 <span class="arithmatex">\(O(\log n)\)</span> 栈帧空间。</p>
<p>再例如“数字转化为字符串”,输入任意正整数 <span class="arithmatex">\(n\)</span> ,它的位数为 <span class="arithmatex">\(\log_{10} n\)</span> ,即对应字符串长度为 <span class="arithmatex">\(\log_{10} n\)</span> ,因此空间复杂度为 <span class="arithmatex">\(O(\log_{10} n) = O(\log n)\)</span></p>

View File

@ -662,15 +662,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
第一步:统计操作数量
<a href="#1" class="md-nav__link">
1. &nbsp; 第一步:统计操作数量
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
第二步:判断渐近上界
<a href="#2" class="md-nav__link">
2. &nbsp; 第二步:判断渐近上界
</a>
</li>
@ -689,50 +689,50 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#o1" class="md-nav__link">
常数阶 \(O(1)\)
<a href="#1-o1" class="md-nav__link">
1. &nbsp; 常数阶 \(O(1)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on" class="md-nav__link">
线性阶 \(O(n)\)
<a href="#2-on" class="md-nav__link">
2. &nbsp; 线性阶 \(O(n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on2" class="md-nav__link">
平方阶 \(O(n^2)\)
<a href="#3-on2" class="md-nav__link">
3. &nbsp; 平方阶 \(O(n^2)\)
</a>
</li>
<li class="md-nav__item">
<a href="#o2n" class="md-nav__link">
指数阶 \(O(2^n)\)
<a href="#4-o2n" class="md-nav__link">
4. &nbsp; 指数阶 \(O(2^n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#olog-n" class="md-nav__link">
对数阶 \(O(\log n)\)
<a href="#5-olog-n" class="md-nav__link">
5. &nbsp; 对数阶 \(O(\log n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on-log-n" class="md-nav__link">
线性对数阶 \(O(n \log n)\)
<a href="#6-on-log-n" class="md-nav__link">
6. &nbsp; 线性对数阶 \(O(n \log n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on_1" class="md-nav__link">
阶乘阶 \(O(n!)\)
<a href="#7-on" class="md-nav__link">
7. &nbsp; 阶乘阶 \(O(n!)\)
</a>
</li>
@ -3493,15 +3493,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
第一步:统计操作数量
<a href="#1" class="md-nav__link">
1. &nbsp; 第一步:统计操作数量
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
第二步:判断渐近上界
<a href="#2" class="md-nav__link">
2. &nbsp; 第二步:判断渐近上界
</a>
</li>
@ -3520,50 +3520,50 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#o1" class="md-nav__link">
常数阶 \(O(1)\)
<a href="#1-o1" class="md-nav__link">
1. &nbsp; 常数阶 \(O(1)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on" class="md-nav__link">
线性阶 \(O(n)\)
<a href="#2-on" class="md-nav__link">
2. &nbsp; 线性阶 \(O(n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on2" class="md-nav__link">
平方阶 \(O(n^2)\)
<a href="#3-on2" class="md-nav__link">
3. &nbsp; 平方阶 \(O(n^2)\)
</a>
</li>
<li class="md-nav__item">
<a href="#o2n" class="md-nav__link">
指数阶 \(O(2^n)\)
<a href="#4-o2n" class="md-nav__link">
4. &nbsp; 指数阶 \(O(2^n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#olog-n" class="md-nav__link">
对数阶 \(O(\log n)\)
<a href="#5-olog-n" class="md-nav__link">
5. &nbsp; 对数阶 \(O(\log n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on-log-n" class="md-nav__link">
线性对数阶 \(O(n \log n)\)
<a href="#6-on-log-n" class="md-nav__link">
6. &nbsp; 线性对数阶 \(O(n \log n)\)
</a>
</li>
<li class="md-nav__item">
<a href="#on_1" class="md-nav__link">
阶乘阶 \(O(n!)\)
<a href="#7-on" class="md-nav__link">
7. &nbsp; 阶乘阶 \(O(n!)\)
</a>
</li>
@ -4157,7 +4157,7 @@ $$</p>
<h2 id="223">2.2.3 &nbsp; 推算方法<a class="headerlink" href="#223" title="Permanent link">&para;</a></h2>
<p>渐近上界的数学味儿有点重,如果你感觉没有完全理解,也无需担心。因为在实际使用中,我们只需要掌握推算方法,数学意义可以逐渐领悟。</p>
<p>根据定义,确定 <span class="arithmatex">\(f(n)\)</span> 之后,我们便可得到时间复杂度 <span class="arithmatex">\(O(f(n))\)</span> 。那么如何确定渐近上界 <span class="arithmatex">\(f(n)\)</span> 呢?总体分为两步:首先统计操作数量,然后判断渐近上界。</p>
<h3 id="_1">第一步:统计操作数量<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 第一步:统计操作数量<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>针对代码,逐行从上到下计算即可。然而,由于上述 <span class="arithmatex">\(c \cdot f(n)\)</span> 中的常数项 <span class="arithmatex">\(c\)</span> 可以取任意大小,<strong>因此操作数量 <span class="arithmatex">\(T(n)\)</span> 中的各种系数、常数项都可以被忽略</strong>。根据此原则,可以总结出以下计数简化技巧:</p>
<ol>
<li><strong>忽略 <span class="arithmatex">\(T(n)\)</span> 中的常数项</strong>。因为它们都与 <span class="arithmatex">\(n\)</span> 无关,所以对时间复杂度不产生影响。</li>
@ -4365,7 +4365,7 @@ T(n) &amp; = n^2 + n &amp; \text{偷懒统计 (o.O)}
</div>
</div>
</div>
<h3 id="_2">第二步:判断渐近上界<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 第二步:判断渐近上界<a class="headerlink" href="#2" title="Permanent link">&para;</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 align="center"> 表:多项式时间复杂度示例 </p>
@ -4417,7 +4417,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n \log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!
<p class="admonition-title">Tip</p>
<p>部分示例代码需要一些预备知识,包括数组、递归等。如果你遇到不理解的部分,可以在学习完后面章节后再回顾。现阶段,请先专注于理解时间复杂度的含义和推算方法。</p>
</div>
<h3 id="o1">常数阶 <span class="arithmatex">\(O(1)\)</span><a class="headerlink" href="#o1" title="Permanent link">&para;</a></h3>
<h3 id="1-o1">1. &nbsp; 常数阶 <span class="arithmatex">\(O(1)\)</span><a class="headerlink" href="#1-o1" title="Permanent link">&para;</a></h3>
<p>常数阶的操作数量与输入数据大小 <span class="arithmatex">\(n\)</span> 无关,即不随着 <span class="arithmatex">\(n\)</span> 的变化而变化。</p>
<p>对于以下算法,尽管操作数量 <code>size</code> 可能很大,但由于其与数据大小 <span class="arithmatex">\(n\)</span> 无关,因此时间复杂度仍为 <span class="arithmatex">\(O(1)\)</span></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>
@ -4563,7 +4563,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n \log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!
</div>
</div>
</div>
<h3 id="on">线性阶 <span class="arithmatex">\(O(n)\)</span><a class="headerlink" href="#on" title="Permanent link">&para;</a></h3>
<h3 id="2-on">2. &nbsp; 线性阶 <span class="arithmatex">\(O(n)\)</span><a class="headerlink" href="#2-on" title="Permanent link">&para;</a></h3>
<p>线性阶的操作数量相对于输入数据大小以线性级别增长。线性阶通常出现在单层循环中。</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">
@ -4841,7 +4841,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n \log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!
</div>
</div>
<p>值得注意的是,<strong>数据大小 <span class="arithmatex">\(n\)</span> 需根据输入数据的类型来具体确定</strong>。比如在第一个示例中,变量 <span class="arithmatex">\(n\)</span> 为输入数据大小;在第二个示例中,数组长度 <span class="arithmatex">\(n\)</span> 为数据大小。</p>
<h3 id="on2">平方阶 <span class="arithmatex">\(O(n^2)\)</span><a class="headerlink" href="#on2" title="Permanent link">&para;</a></h3>
<h3 id="3-on2">3. &nbsp; 平方阶 <span class="arithmatex">\(O(n^2)\)</span><a class="headerlink" href="#3-on2" title="Permanent link">&para;</a></h3>
<p>平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中,外层循环和内层循环都为 <span class="arithmatex">\(O(n)\)</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">
@ -5273,7 +5273,7 @@ O((n - 1) \frac{n}{2}) = O(n^2)
</div>
</div>
</div>
<h3 id="o2n">指数阶 <span class="arithmatex">\(O(2^n)\)</span><a class="headerlink" href="#o2n" title="Permanent link">&para;</a></h3>
<h3 id="4-o2n">4. &nbsp; 指数阶 <span class="arithmatex">\(O(2^n)\)</span><a class="headerlink" href="#4-o2n" title="Permanent link">&para;</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>以下代码模拟了细胞分裂的过程。</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>
@ -5592,7 +5592,7 @@ O((n - 1) \frac{n}{2}) = O(n^2)
</div>
</div>
<p>指数阶增长非常迅速,在穷举法(暴力搜索、回溯等)中比较常见。对于数据规模较大的问题,指数阶是不可接受的,通常需要使用「动态规划」或「贪心」等算法来解决。</p>
<h3 id="olog-n">对数阶 <span class="arithmatex">\(O(\log n)\)</span><a class="headerlink" href="#olog-n" title="Permanent link">&para;</a></h3>
<h3 id="5-olog-n">5. &nbsp; 对数阶 <span class="arithmatex">\(O(\log n)\)</span><a class="headerlink" href="#5-olog-n" title="Permanent link">&para;</a></h3>
<p>与指数阶相反,对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 <span class="arithmatex">\(n\)</span> ,由于每轮缩减到一半,因此循环次数是 <span class="arithmatex">\(\log_2 n\)</span> ,即 <span class="arithmatex">\(2^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">
@ -5857,7 +5857,7 @@ O((n - 1) \frac{n}{2}) = O(n^2)
</div>
</div>
<p>对数阶常出现于基于「分治」的算法中,体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢,是理想的时间复杂度,仅次于常数阶。</p>
<h3 id="on-log-n">线性对数阶 <span class="arithmatex">\(O(n \log n)\)</span><a class="headerlink" href="#on-log-n" title="Permanent link">&para;</a></h3>
<h3 id="6-on-log-n">6. &nbsp; 线性对数阶 <span class="arithmatex">\(O(n \log n)\)</span><a class="headerlink" href="#6-on-log-n" title="Permanent link">&para;</a></h3>
<p>线性对数阶常出现于嵌套循环中,两层循环的时间复杂度分别为 <span class="arithmatex">\(O(\log n)\)</span><span class="arithmatex">\(O(n)\)</span></p>
<p>主流排序算法的时间复杂度通常为 <span class="arithmatex">\(O(n \log n)\)</span> ,例如快速排序、归并排序、堆排序等。</p>
<div class="tabbed-set tabbed-alternate" data-tabs="14:12"><input checked="checked" id="__tabbed_14_1" name="__tabbed_14" type="radio" /><input id="__tabbed_14_2" name="__tabbed_14" type="radio" /><input id="__tabbed_14_3" name="__tabbed_14" type="radio" /><input id="__tabbed_14_4" name="__tabbed_14" type="radio" /><input id="__tabbed_14_5" name="__tabbed_14" type="radio" /><input id="__tabbed_14_6" name="__tabbed_14" type="radio" /><input id="__tabbed_14_7" name="__tabbed_14" type="radio" /><input id="__tabbed_14_8" name="__tabbed_14" type="radio" /><input id="__tabbed_14_9" name="__tabbed_14" type="radio" /><input id="__tabbed_14_10" name="__tabbed_14" type="radio" /><input id="__tabbed_14_11" name="__tabbed_14" type="radio" /><input id="__tabbed_14_12" name="__tabbed_14" type="radio" /><div class="tabbed-labels"><label for="__tabbed_14_1">Java</label><label for="__tabbed_14_2">C++</label><label for="__tabbed_14_3">Python</label><label for="__tabbed_14_4">Go</label><label for="__tabbed_14_5">JS</label><label for="__tabbed_14_6">TS</label><label for="__tabbed_14_7">C</label><label for="__tabbed_14_8">C#</label><label for="__tabbed_14_9">Swift</label><label for="__tabbed_14_10">Zig</label><label for="__tabbed_14_11">Dart</label><label for="__tabbed_14_12">Rust</label></div>
@ -6025,7 +6025,7 @@ O((n - 1) \frac{n}{2}) = O(n^2)
<p><img alt="线性对数阶的时间复杂度" src="../time_complexity.assets/time_complexity_logarithmic_linear.png" /></p>
<p align="center"> 图:线性对数阶的时间复杂度 </p>
<h3 id="on_1">阶乘阶 <span class="arithmatex">\(O(n!)\)</span><a class="headerlink" href="#on_1" title="Permanent link">&para;</a></h3>
<h3 id="7-on">7. &nbsp; 阶乘阶 <span class="arithmatex">\(O(n!)\)</span><a class="headerlink" href="#7-on" title="Permanent link">&para;</a></h3>
<p>阶乘阶对应数学上的“全排列”问题。给定 <span class="arithmatex">\(n\)</span> 个互不重复的元素,求其所有可能的排列方案,方案数量为:</p>
<div class="arithmatex">\[
n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1

View File

@ -2424,8 +2424,8 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
基于分治实现二分
<a href="#1" class="md-nav__link">
1. &nbsp; 基于分治实现二分
</a>
</li>
@ -3376,8 +3376,8 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
基于分治实现二分
<a href="#1" class="md-nav__link">
1. &nbsp; 基于分治实现二分
</a>
</li>
@ -3423,7 +3423,7 @@
<li><strong>子问题的解无需合并</strong>:二分查找旨在查找一个特定元素,因此不需要将子问题的解进行合并。当子问题得到解决时,原问题也会同时得到解决。</li>
</ul>
<p>分治能够提升搜索效率,本质上是因为暴力搜索每轮只能排除一个选项,<strong>而分治搜索每轮可以排除一半选项</strong></p>
<h3 id="_1">基于分治实现二分<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 基于分治实现二分<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>在之前的章节中,二分查找是基于递推(迭代)实现的。现在我们基于分治(递归)来实现它。</p>
<div class="admonition question">
<p class="admonition-title">Question</p>

View File

@ -2452,29 +2452,29 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
判断是否为分治问题
<a href="#1" class="md-nav__link">
1. &nbsp; 判断是否为分治问题
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
如何划分子树
<a href="#2" class="md-nav__link">
2. &nbsp; 如何划分子树
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
基于变量描述子树区间
<a href="#3" class="md-nav__link">
3. &nbsp; 基于变量描述子树区间
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
代码实现
<a href="#4" class="md-nav__link">
4. &nbsp; 代码实现
</a>
</li>
@ -3397,29 +3397,29 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
判断是否为分治问题
<a href="#1" class="md-nav__link">
1. &nbsp; 判断是否为分治问题
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
如何划分子树
<a href="#2" class="md-nav__link">
2. &nbsp; 如何划分子树
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
基于变量描述子树区间
<a href="#3" class="md-nav__link">
3. &nbsp; 基于变量描述子树区间
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
代码实现
<a href="#4" class="md-nav__link">
4. &nbsp; 代码实现
</a>
</li>
@ -3455,14 +3455,14 @@
<p><img alt="构建二叉树的示例数据" src="../build_binary_tree_problem.assets/build_tree_example.png" /></p>
<p align="center"> 图:构建二叉树的示例数据 </p>
<h3 id="_1">判断是否为分治问题<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 判断是否为分治问题<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>原问题定义为从 <code>preorder</code><code>inorder</code> 构建二叉树。我们首先从分治的角度分析这道题:</p>
<ul>
<li><strong>问题可以被分解</strong>:从分治的角度切入,我们可以将原问题划分为两个子问题:构建左子树、构建右子树,加上一步操作:初始化根节点。而对于每个子树(子问题),我们仍然可以复用以上划分方法,将其划分为更小的子树(子问题),直至达到最小子问题(空子树)时终止。</li>
<li><strong>子问题是独立的</strong>:左子树和右子树是相互独立的,它们之间没有交集。在构建左子树时,我们只需要关注中序遍历和前序遍历中与左子树对应的部分。右子树同理。</li>
<li><strong>子问题的解可以合并</strong>:一旦得到了左子树和右子树(子问题的解),我们就可以将它们链接到根节点上,得到原问题的解。</li>
</ul>
<h3 id="_2">如何划分子树<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 如何划分子树<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>根据以上分析,这道题是可以使用分治来求解的,但问题是:<strong>如何通过前序遍历 <code>preorder</code> 和中序遍历 <code>inorder</code> 来划分左子树和右子树呢</strong></p>
<p>根据定义,<code>preorder</code><code>inorder</code> 都可以被划分为三个部分:</p>
<ul>
@ -3478,7 +3478,7 @@
<p><img alt="在前序和中序遍历中划分子树" src="../build_binary_tree_problem.assets/build_tree_preorder_inorder_division.png" /></p>
<p align="center"> 图:在前序和中序遍历中划分子树 </p>
<h3 id="_3">基于变量描述子树区间<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 基于变量描述子树区间<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>根据以上划分方法,<strong>我们已经得到根节点、左子树、右子树在 <code>preorder</code><code>inorder</code> 中的索引区间</strong>。而为了描述这些索引区间,我们需要借助几个指针变量:</p>
<ul>
<li>将当前树的根节点在 <code>preorder</code> 中的索引记为 <span class="arithmatex">\(i\)</span></li>
@ -3520,7 +3520,7 @@
<p><img alt="根节点和左右子树的索引区间表示" src="../build_binary_tree_problem.assets/build_tree_division_pointers.png" /></p>
<p align="center"> 图:根节点和左右子树的索引区间表示 </p>
<h3 id="_4">代码实现<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 代码实现<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p>为了提升查询 <span class="arithmatex">\(m\)</span> 的效率,我们借助一个哈希表 <code>hmap</code> 来存储数组 <code>inorder</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">

View File

@ -2411,15 +2411,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
操作数量优化
<a href="#1" class="md-nav__link">
1. &nbsp; 操作数量优化
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
并行计算优化
<a href="#2" class="md-nav__link">
2. &nbsp; 并行计算优化
</a>
</li>
@ -3425,15 +3425,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
操作数量优化
<a href="#1" class="md-nav__link">
1. &nbsp; 操作数量优化
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
并行计算优化
<a href="#2" class="md-nav__link">
2. &nbsp; 并行计算优化
</a>
</li>
@ -3503,7 +3503,7 @@
<h2 id="1212">12.1.2 &nbsp; 通过分治提升效率<a class="headerlink" href="#1212" title="Permanent link">&para;</a></h2>
<p>分治不仅可以有效地解决算法问题,<strong>往往还可以带来算法效率的提升</strong>。在排序算法中,快速排序、归并排序、堆排序相较于选择、冒泡、插入排序更快,就是因为它们应用了分治策略。</p>
<p>那么,我们不禁发问:<strong>为什么分治可以提升算法效率,其底层逻辑是什么</strong>?换句话说,将大问题分解为多个子问题、解决子问题、将子问题的解合并为原问题的解,这几步的效率为什么比直接解决原问题的效率更高?这个问题可以从操作数量和并行计算两方面来讨论。</p>
<h3 id="_1">操作数量优化<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 操作数量优化<a class="headerlink" href="#1" title="Permanent link">&para;</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((\frac{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)
@ -3522,7 +3522,7 @@ n(n - 4) &amp; &gt; 0
<p><strong>这意味着当 <span class="arithmatex">\(n &gt; 4\)</span> 时,划分后的操作数量更少,排序效率应该更高</strong>。请注意,划分后的时间复杂度仍然是平方阶 <span class="arithmatex">\(O(n^2)\)</span> ,只是复杂度中的常数项变小了。</p>
<p>进一步想,<strong>如果我们把子数组不断地再从中点划分为两个子数组</strong>,直至子数组只剩一个元素时停止划分呢?这种思路实际上就是「归并排序」,时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span></p>
<p>再思考,<strong>如果我们多设置几个划分点</strong>,将原数组平均划分为 <span class="arithmatex">\(k\)</span> 个子数组呢?这种情况与「桶排序」非常类似,它非常适合排序海量数据,理论上时间复杂度可以达到 <span class="arithmatex">\(O(n + k)\)</span></p>
<h3 id="_2">并行计算优化<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 并行计算优化<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>我们知道,分治生成的子问题是相互独立的,<strong>因此通常可以并行解决</strong>。也就是说,分治不仅可以降低算法的时间复杂度,<strong>还有利于操作系统的并行优化</strong></p>
<p>并行优化在多核或多处理器的环境中尤其有效,因为系统可以同时处理多个子问题,更加充分地利用计算资源,从而显著减少总体的运行时间。</p>
<p>比如在桶排序中,我们将海量的数据平均分配到各个桶中,则可所有桶的排序任务分散到各个计算单元,完成后再进行结果合并。</p>

View File

@ -2480,22 +2480,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
考虑基本情况
<a href="#1" class="md-nav__link">
1. &nbsp; 考虑基本情况
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
子问题分解
<a href="#2" class="md-nav__link">
2. &nbsp; 子问题分解
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
代码实现
<a href="#3" class="md-nav__link">
3. &nbsp; 代码实现
</a>
</li>
@ -3390,22 +3390,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
考虑基本情况
<a href="#1" class="md-nav__link">
1. &nbsp; 考虑基本情况
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
子问题分解
<a href="#2" class="md-nav__link">
2. &nbsp; 子问题分解
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
代码实现
<a href="#3" class="md-nav__link">
3. &nbsp; 代码实现
</a>
</li>
@ -3448,7 +3448,7 @@
<p align="center"> 图:汉诺塔问题示例 </p>
<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">考虑基本情况<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 考虑基本情况<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<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">&lt;1&gt;</label><label for="__tabbed_1_2">&lt;2&gt;</label></div>
<div class="tabbed-content">
@ -3487,7 +3487,7 @@
</div>
<p align="center"> 图:规模为 2 问题的解 </p>
<h3 id="_2">子问题分解<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 子问题分解<a class="headerlink" href="#2" title="Permanent link">&para;</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>
<ol>
<li><code>B</code> 为目标柱、<code>C</code> 为缓冲柱,将两个圆盘从 <code>A</code> 移动至 <code>B</code></li>
@ -3524,7 +3524,7 @@
<p><img alt="汉诺塔问题的分治策略" src="../hanota_problem.assets/hanota_divide_and_conquer.png" /></p>
<p align="center"> 图:汉诺塔问题的分治策略 </p>
<h3 id="_3">代码实现<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 代码实现<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>在代码中,我们声明一个递归函数 <code>dfs(i, src, buf, tar)</code> ,它的作用是将柱 <code>src</code> 顶部的 <span class="arithmatex">\(i\)</span> 个圆盘借助缓冲柱 <code>buf</code> 移动至目标柱 <code>tar</code></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">

View File

@ -2857,29 +2857,29 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
方法一:暴力搜索
<a href="#1" class="md-nav__link">
1. &nbsp; 方法一:暴力搜索
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
方法二:记忆化搜索
<a href="#2" class="md-nav__link">
2. &nbsp; 方法二:记忆化搜索
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
方法三:动态规划
<a href="#3" class="md-nav__link">
3. &nbsp; 方法三:动态规划
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
状态压缩
<a href="#4" class="md-nav__link">
4. &nbsp; 状态压缩
</a>
</li>
@ -3432,29 +3432,29 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
方法一:暴力搜索
<a href="#1" class="md-nav__link">
1. &nbsp; 方法一:暴力搜索
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
方法二:记忆化搜索
<a href="#2" class="md-nav__link">
2. &nbsp; 方法二:记忆化搜索
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
方法三:动态规划
<a href="#3" class="md-nav__link">
3. &nbsp; 方法三:动态规划
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
状态压缩
<a href="#4" class="md-nav__link">
4. &nbsp; 状态压缩
</a>
</li>
@ -3557,7 +3557,7 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
<p>状态转移顺序的核心是要保证在计算当前问题的解时,所有它依赖的更小子问题的解都已经被正确地计算出来。</p>
</div>
<p>根据以上分析,我们已经可以直接写出动态规划代码。然而子问题分解是一种从顶至底的思想,因此按照“暴力搜索 <span class="arithmatex">\(\rightarrow\)</span> 记忆化搜索 <span class="arithmatex">\(\rightarrow\)</span> 动态规划”的顺序实现更加符合思维习惯。</p>
<h3 id="_1">方法一:暴力搜索<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 方法一:暴力搜索<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>从状态 <span class="arithmatex">\([i, j]\)</span> 开始搜索,不断分解为更小的状态 <span class="arithmatex">\([i-1, j]\)</span><span class="arithmatex">\([i, j-1]\)</span> ,包括以下递归要素:</p>
<ul>
<li><strong>递归参数</strong>:状态 <span class="arithmatex">\([i, j]\)</span></li>
@ -3756,7 +3756,7 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
<p align="center"> 图:暴力搜索递归树 </p>
<p>每个状态都有向下和向右两种选择,从左上角走到右下角总共需要 <span class="arithmatex">\(m + n - 2\)</span> 步,所以最差时间复杂度为 <span class="arithmatex">\(O(2^{m + n})\)</span> 。请注意,这种计算方式未考虑临近网格边界的情况,当到达网络边界时只剩下一种选择。因此实际的路径数量会少一些。</p>
<h3 id="_2">方法二:记忆化搜索<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 方法二:记忆化搜索<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>我们引入一个和网格 <code>grid</code> 相同尺寸的记忆列表 <code>mem</code> ,用于记录各个子问题的解,并将重叠子问题进行剪枝。</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">
@ -3994,7 +3994,7 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
<p><img alt="记忆化搜索递归树" src="../dp_solution_pipeline.assets/min_path_sum_dfs_mem.png" /></p>
<p align="center"> 图:记忆化搜索递归树 </p>
<h3 id="_3">方法三:动态规划<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 方法三:动态规划<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<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">
@ -4281,7 +4281,7 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
</div>
<p align="center"> 图:最小路径和的动态规划过程 </p>
<h3 id="_4">状态压缩<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 状态压缩<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p>由于每个格子只与其左边和上边的格子有关,因此我们可以只用一个单行数组来实现 <span class="arithmatex">\(dp\)</span> 表。</p>
<p>请注意,因为数组 <code>dp</code> 只能表示一行的状态,所以我们无法提前初始化首列状态,而是在遍历每行中更新它。</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>

View File

@ -2926,15 +2926,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
代码实现
<a href="#1" class="md-nav__link">
1. &nbsp; 动态规划思路
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
状态压缩
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#3" class="md-nav__link">
3. &nbsp; 状态压缩
</a>
</li>
@ -3383,15 +3390,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
代码实现
<a href="#1" class="md-nav__link">
1. &nbsp; 动态规划思路
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
状态压缩
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#3" class="md-nav__link">
3. &nbsp; 状态压缩
</a>
</li>
@ -3436,6 +3450,7 @@
<p><img alt="基于决策树模型表示编辑距离问题" src="../edit_distance_problem.assets/edit_distance_decision_tree.png" /></p>
<p align="center"> 图:基于决策树模型表示编辑距离问题 </p>
<h3 id="1">1. &nbsp; 动态规划思路<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p><strong>第一步:思考每轮的决策,定义状态,从而得到 <span class="arithmatex">\(dp\)</span></strong></p>
<p>每一轮的决策是对字符串 <span class="arithmatex">\(s\)</span> 进行一次编辑操作。</p>
<p>我们希望在编辑操作的过程中,问题的规模逐渐缩小,这样才能构建子问题。设字符串 <span class="arithmatex">\(s\)</span><span class="arithmatex">\(t\)</span> 的长度分别为 <span class="arithmatex">\(n\)</span><span class="arithmatex">\(m\)</span> ,我们先考虑两字符串尾部的字符 <span class="arithmatex">\(s[n-1]\)</span><span class="arithmatex">\(t[m-1]\)</span> </p>
@ -3467,7 +3482,7 @@ dp[i, j] = dp[i-1, j-1]
<p><strong>第三步:确定边界条件和状态转移顺序</strong></p>
<p>当两字符串都为空时,编辑步数为 <span class="arithmatex">\(0\)</span> ,即 <span class="arithmatex">\(dp[0, 0] = 0\)</span> 。当 <span class="arithmatex">\(s\)</span> 为空但 <span class="arithmatex">\(t\)</span> 不为空时,最少编辑步数等于 <span class="arithmatex">\(t\)</span> 的长度,即首行 <span class="arithmatex">\(dp[0, j] = j\)</span> 。当 <span class="arithmatex">\(s\)</span> 不为空但 <span class="arithmatex">\(t\)</span> 为空时,等于 <span class="arithmatex">\(s\)</span> 的长度,即首列 <span class="arithmatex">\(dp[i, 0] = i\)</span></p>
<p>观察状态转移方程,解 <span class="arithmatex">\(dp[i, j]\)</span> 依赖左方、上方、左上方的解,因此通过两层循环正序遍历整个 <span class="arithmatex">\(dp\)</span> 表即可。</p>
<h3 id="_1">代码实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<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">
@ -3788,7 +3803,7 @@ dp[i, j] = dp[i-1, j-1]
</div>
<p align="center"> 图:编辑距离的动态规划过程 </p>
<h3 id="_2">状态压缩<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 状态压缩<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>由于 <span class="arithmatex">\(dp[i,j]\)</span> 是由上方 <span class="arithmatex">\(dp[i-1, j]\)</span> 、左方 <span class="arithmatex">\(dp[i, j-1]\)</span> 、左上方状态 <span class="arithmatex">\(dp[i-1, j-1]\)</span> 转移而来,而正序遍历会丢失左上方 <span class="arithmatex">\(dp[i-1, j-1]\)</span> ,倒序遍历无法提前构建 <span class="arithmatex">\(dp[i, j-1]\)</span> ,因此两种遍历顺序都不可取。</p>
<p>为此,我们可以使用一个变量 <code>leftup</code> 来暂存左上方的解 <span class="arithmatex">\(dp[i-1, j-1]\)</span> ,从而只需考虑左方和上方的解。此时的情况与完全背包问题相同,可使用正序遍历。</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>

View File

@ -2870,29 +2870,29 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
方法一:暴力搜索
<a href="#1" class="md-nav__link">
1. &nbsp; 方法一:暴力搜索
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
方法二:记忆化搜索
<a href="#2" class="md-nav__link">
2. &nbsp; 方法二:记忆化搜索
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
方法三:动态规划
<a href="#3" class="md-nav__link">
3. &nbsp; 方法三:动态规划
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
状态压缩
<a href="#4" class="md-nav__link">
4. &nbsp; 状态压缩
</a>
</li>
@ -3397,29 +3397,29 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
方法一:暴力搜索
<a href="#1" class="md-nav__link">
1. &nbsp; 方法一:暴力搜索
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
方法二:记忆化搜索
<a href="#2" class="md-nav__link">
2. &nbsp; 方法二:记忆化搜索
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
方法三:动态规划
<a href="#3" class="md-nav__link">
3. &nbsp; 方法三:动态规划
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
状态压缩
<a href="#4" class="md-nav__link">
4. &nbsp; 状态压缩
</a>
</li>
@ -3479,7 +3479,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
<p>当无物品或无剩余背包容量时最大价值为 <span class="arithmatex">\(0\)</span> ,即首列 <span class="arithmatex">\(dp[i, 0]\)</span> 和首行 <span class="arithmatex">\(dp[0, c]\)</span> 都等于 <span class="arithmatex">\(0\)</span></p>
<p>当前状态 <span class="arithmatex">\([i, c]\)</span> 从上方的状态 <span class="arithmatex">\([i-1, c]\)</span> 和左上方的状态 <span class="arithmatex">\([i-1, c-wgt[i-1]]\)</span> 转移而来,因此通过两层循环正序遍历整个 <span class="arithmatex">\(dp\)</span> 表即可。</p>
<p>根据以上分析,我们接下来按顺序实现暴力搜索、记忆化搜索、动态规划解法。</p>
<h3 id="_1">方法一:暴力搜索<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 方法一:暴力搜索<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>搜索代码包含以下要素:</p>
<ul>
<li><strong>递归参数</strong>:状态 <span class="arithmatex">\([i, c]\)</span></li>
@ -3676,7 +3676,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
<p><img alt="0-1 背包的暴力搜索递归树" src="../knapsack_problem.assets/knapsack_dfs.png" /></p>
<p align="center">0-1 背包的暴力搜索递归树 </p>
<h3 id="_2">方法二:记忆化搜索<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 方法二:记忆化搜索<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>为了保证重叠子问题只被计算一次,我们借助记忆列表 <code>mem</code> 来记录子问题的解,其中 <code>mem[i][c]</code> 对应 <span class="arithmatex">\(dp[i, c]\)</span></p>
<p>引入记忆化之后,<strong>时间复杂度取决于子问题数量</strong>,也就是 <span class="arithmatex">\(O(n \times cap)\)</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>
@ -3918,7 +3918,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
<p><img alt="0-1 背包的记忆化搜索递归树" src="../knapsack_problem.assets/knapsack_dfs_mem.png" /></p>
<p align="center">0-1 背包的记忆化搜索递归树 </p>
<h3 id="_3">方法三:动态规划<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 方法三:动态规划<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>动态规划实质上就是在状态转移中填充 <span class="arithmatex">\(dp\)</span> 表的过程,代码如下所示。</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">
@ -4182,7 +4182,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
</div>
<p align="center">0-1 背包的动态规划过程 </p>
<h3 id="_4">状态压缩<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 状态压缩<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p>由于每个状态都只与其上一行的状态有关,因此我们可以使用两个数组滚动前进,将空间复杂度从 <span class="arithmatex">\(O(n^2)\)</span> 将低至 <span class="arithmatex">\(O(n)\)</span></p>
<p>进一步思考,我们是否可以仅用一个数组实现状态压缩呢?观察可知,每个状态都是由正上方或左上方的格子转移过来的。假设只有一个数组,当开始遍历第 <span class="arithmatex">\(i\)</span> 行时,该数组存储的仍然是第 <span class="arithmatex">\(i-1\)</span> 行的状态。</p>
<ul>

View File

@ -2906,15 +2906,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
代码实现
<a href="#1" class="md-nav__link">
1. &nbsp; 动态规划思路
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
状态压缩
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#3" class="md-nav__link">
3. &nbsp; 状态压缩
</a>
</li>
@ -2933,15 +2940,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
代码实现
<a href="#1_1" class="md-nav__link">
1. &nbsp; 动态规划思路
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
状态压缩
<a href="#2_1" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#3_1" class="md-nav__link">
3. &nbsp; 状态压缩
</a>
</li>
@ -2960,15 +2974,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
代码实现
<a href="#1_2" class="md-nav__link">
1. &nbsp; 动态规划思路
</a>
</li>
<li class="md-nav__item">
<a href="#_6" class="md-nav__link">
状态压缩
<a href="#2_2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#3_2" class="md-nav__link">
3. &nbsp; 状态压缩
</a>
</li>
@ -3458,15 +3479,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
代码实现
<a href="#1" class="md-nav__link">
1. &nbsp; 动态规划思路
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
状态压缩
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#3" class="md-nav__link">
3. &nbsp; 状态压缩
</a>
</li>
@ -3485,15 +3513,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
代码实现
<a href="#1_1" class="md-nav__link">
1. &nbsp; 动态规划思路
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
状态压缩
<a href="#2_1" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#3_1" class="md-nav__link">
3. &nbsp; 状态压缩
</a>
</li>
@ -3512,15 +3547,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
代码实现
<a href="#1_2" class="md-nav__link">
1. &nbsp; 动态规划思路
</a>
</li>
<li class="md-nav__item">
<a href="#_6" class="md-nav__link">
状态压缩
<a href="#2_2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#3_2" class="md-nav__link">
3. &nbsp; 状态压缩
</a>
</li>
@ -3563,6 +3605,7 @@
<p><img alt="完全背包问题的示例数据" src="../unbounded_knapsack_problem.assets/unbounded_knapsack_example.png" /></p>
<p align="center"> 图:完全背包问题的示例数据 </p>
<h3 id="1">1. &nbsp; 动态规划思路<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>完全背包和 0-1 背包问题非常相似,<strong>区别仅在于不限制物品的选择次数</strong></p>
<ul>
<li>在 0-1 背包中,每个物品只有一个,因此将物品 <span class="arithmatex">\(i\)</span> 放入背包后,只能从前 <span class="arithmatex">\(i-1\)</span> 个物品中选择。</li>
@ -3577,7 +3620,7 @@
<div class="arithmatex">\[
dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
\]</div>
<h3 id="_1">代码实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>对比两道题目的代码,状态转移中有一处从 <span class="arithmatex">\(i-1\)</span> 变为 <span class="arithmatex">\(i\)</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">
@ -3792,7 +3835,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
</div>
</div>
</div>
<h3 id="_2">状态压缩<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 状态压缩<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>由于当前状态是从左边和上边的状态转移而来,<strong>因此状态压缩后应该对 <span class="arithmatex">\(dp\)</span> 表中的每一行采取正序遍历</strong></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">&lt;1&gt;</label><label for="__tabbed_2_2">&lt;2&gt;</label><label for="__tabbed_2_3">&lt;3&gt;</label><label for="__tabbed_2_4">&lt;4&gt;</label><label for="__tabbed_2_5">&lt;5&gt;</label><label for="__tabbed_2_6">&lt;6&gt;</label></div>
@ -4040,6 +4083,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
<p><img alt="零钱兑换问题的示例数据" src="../unbounded_knapsack_problem.assets/coin_change_example.png" /></p>
<p align="center"> 图:零钱兑换问题的示例数据 </p>
<h3 id="1_1">1. &nbsp; 动态规划思路<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
<p><strong>零钱兑换可以看作是完全背包的一种特殊情况</strong>,两者具有以下联系与不同点:</p>
<ul>
<li>两道题可以相互转换,“物品”对应于“硬币”、“物品重量”对应于“硬币面值”、“背包容量”对应于“目标金额”。</li>
@ -4061,7 +4105,7 @@ dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
<p><strong>第三步:确定边界条件和状态转移顺序</strong></p>
<p>当目标金额为 <span class="arithmatex">\(0\)</span> 时,凑出它的最少硬币个数为 <span class="arithmatex">\(0\)</span> ,即首列所有 <span class="arithmatex">\(dp[i, 0]\)</span> 都等于 <span class="arithmatex">\(0\)</span></p>
<p>当无硬币时,<strong>无法凑出任意 <span class="arithmatex">\(&gt; 0\)</span> 的目标金额</strong>,即是无效解。为使状态转移方程中的 <span class="arithmatex">\(\min()\)</span> 函数能够识别并过滤无效解,我们考虑使用 <span class="arithmatex">\(+ \infty\)</span> 来表示它们,即令首行所有 <span class="arithmatex">\(dp[0, a]\)</span> 都等于 <span class="arithmatex">\(+ \infty\)</span></p>
<h3 id="_3">代码实现<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="2_1">2. &nbsp; 代码实现<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
<p>大多数编程语言并未提供 <span class="arithmatex">\(+ \infty\)</span> 变量,只能使用整型 <code>int</code> 的最大值来代替。而这又会导致大数越界:状态转移方程中的 <span class="arithmatex">\(+ 1\)</span> 操作可能发生溢出。</p>
<p>为此,我们采用数字 <span class="arithmatex">\(amt + 1\)</span> 来表示无效解,因为凑出 <span class="arithmatex">\(amt\)</span> 的硬币个数最多为 <span class="arithmatex">\(amt\)</span> 个。</p>
<p>最后返回前,判断 <span class="arithmatex">\(dp[n, amt]\)</span> 是否等于 <span class="arithmatex">\(amt + 1\)</span> ,若是则返回 <span class="arithmatex">\(-1\)</span> ,代表无法凑出目标金额。</p>
@ -4381,7 +4425,7 @@ dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
</div>
<p align="center"> 图:零钱兑换问题的动态规划过程 </p>
<h3 id="_4">状态压缩<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="3_1">3. &nbsp; 状态压缩<a class="headerlink" href="#3_1" title="Permanent link">&para;</a></h3>
<p>零钱兑换的状态压缩的处理方式和完全背包一致。</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">
@ -4634,13 +4678,14 @@ dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
<p><img alt="零钱兑换问题 II 的示例数据" src="../unbounded_knapsack_problem.assets/coin_change_ii_example.png" /></p>
<p align="center"> 图:零钱兑换问题 II 的示例数据 </p>
<h3 id="1_2">1. &nbsp; 动态规划思路<a class="headerlink" href="#1_2" title="Permanent link">&para;</a></h3>
<p>相比于上一题,本题目标是组合数量,因此子问题变为:<strong><span class="arithmatex">\(i\)</span> 种硬币能够凑出金额 <span class="arithmatex">\(a\)</span> 的组合数量</strong>。而 <span class="arithmatex">\(dp\)</span> 表仍然是尺寸为 <span class="arithmatex">\((n+1) \times (amt + 1)\)</span> 的二维矩阵。</p>
<p>当前状态的组合数量等于不选当前硬币与选当前硬币这两种决策的组合数量之和。状态转移方程为:</p>
<div class="arithmatex">\[
dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]]
\]</div>
<p>当目标金额为 <span class="arithmatex">\(0\)</span> 时,无需选择任何硬币即可凑出目标金额,因此应将首列所有 <span class="arithmatex">\(dp[i, 0]\)</span> 都初始化为 <span class="arithmatex">\(1\)</span> 。当无硬币时,无法凑出任何 <span class="arithmatex">\(&gt;0\)</span> 的目标金额,因此首行所有 <span class="arithmatex">\(dp[0, a]\)</span> 都等于 <span class="arithmatex">\(0\)</span></p>
<h3 id="_5">代码实现<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
<h3 id="2_2">2. &nbsp; 代码实现<a class="headerlink" href="#2_2" title="Permanent link">&para;</a></h3>
<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">
@ -4889,7 +4934,7 @@ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]]
</div>
</div>
</div>
<h3 id="_6">状态压缩<a class="headerlink" href="#_6" title="Permanent link">&para;</a></h3>
<h3 id="3_2">3. &nbsp; 状态压缩<a class="headerlink" href="#3_2" title="Permanent link">&para;</a></h3>
<p>状态压缩处理方式相同,删除硬币维度即可。</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">

View File

@ -1737,15 +1737,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
邻接矩阵
<a href="#1" class="md-nav__link">
1. &nbsp; 邻接矩阵
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
邻接表
<a href="#2" class="md-nav__link">
2. &nbsp; 邻接表
</a>
</li>
@ -3431,15 +3431,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
邻接矩阵
<a href="#1" class="md-nav__link">
1. &nbsp; 邻接矩阵
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
邻接表
<a href="#2" class="md-nav__link">
2. &nbsp; 邻接表
</a>
</li>
@ -3521,7 +3521,7 @@ G &amp; = \{ V, E \} \newline
</ul>
<h2 id="913">9.1.3 &nbsp; 图的表示<a class="headerlink" href="#913" title="Permanent link">&para;</a></h2>
<p>图的常用表示方法包括「邻接矩阵」和「邻接表」。以下使用无向图进行举例。</p>
<h3 id="_1">邻接矩阵<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 邻接矩阵<a class="headerlink" href="#1" title="Permanent link">&para;</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>
<p><img alt="图的邻接矩阵表示" src="../graph.assets/adjacency_matrix.png" /></p>
@ -3534,7 +3534,7 @@ G &amp; = \{ V, E \} \newline
<li>将邻接矩阵的元素从 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(0\)</span> 替换为权重,则可表示有权图。</li>
</ul>
<p>使用邻接矩阵表示图时,我们可以直接访问矩阵元素以获取边,因此增删查操作的效率很高,时间复杂度均为 <span class="arithmatex">\(O(1)\)</span> 。然而,矩阵的空间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> ,内存占用较多。</p>
<h3 id="_2">邻接表<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 邻接表<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<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>

View File

@ -1763,15 +1763,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
算法实现
<a href="#1" class="md-nav__link">
1. &nbsp; 算法实现
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
复杂度分析
<a href="#2" class="md-nav__link">
2. &nbsp; 复杂度分析
</a>
</li>
@ -1790,15 +1790,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
算法实现
<a href="#1_1" class="md-nav__link">
1. &nbsp; 算法实现
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
复杂度分析
<a href="#2_1" class="md-nav__link">
2. &nbsp; 复杂度分析
</a>
</li>
@ -3423,15 +3423,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
算法实现
<a href="#1" class="md-nav__link">
1. &nbsp; 算法实现
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
复杂度分析
<a href="#2" class="md-nav__link">
2. &nbsp; 复杂度分析
</a>
</li>
@ -3450,15 +3450,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
算法实现
<a href="#1_1" class="md-nav__link">
1. &nbsp; 算法实现
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
复杂度分析
<a href="#2_1" class="md-nav__link">
2. &nbsp; 复杂度分析
</a>
</li>
@ -3503,7 +3503,7 @@
<p><img alt="图的广度优先遍历" src="../graph_traversal.assets/graph_bfs.png" /></p>
<p align="center"> 图:图的广度优先遍历 </p>
<h3 id="_1">算法实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 算法实现<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>BFS 通常借助「队列」来实现。队列具有“先入先出”的性质,这与 BFS 的“由近及远”的思想异曲同工。</p>
<ol>
<li>将遍历起始顶点 <code>startVet</code> 加入队列,并开启循环。</li>
@ -3897,7 +3897,7 @@
<p class="admonition-title">广度优先遍历的序列是否唯一?</p>
<p>不唯一。广度优先遍历只要求按“由近及远”的顺序遍历,<strong>而多个相同距离的顶点的遍历顺序是允许被任意打乱的</strong>。以上图为例,顶点 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(3\)</span> 的访问顺序可以交换、顶点 <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(4\)</span> , <span class="arithmatex">\(6\)</span> 的访问顺序也可以任意交换。</p>
</div>
<h3 id="_2">复杂度分析<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 复杂度分析<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<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 &nbsp; 深度优先遍历<a class="headerlink" href="#932" title="Permanent link">&para;</a></h2>
@ -3905,7 +3905,7 @@
<p><img alt="图的深度优先遍历" src="../graph_traversal.assets/graph_dfs.png" /></p>
<p align="center"> 图:图的深度优先遍历 </p>
<h3 id="_3">算法实现<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="1_1">1. &nbsp; 算法实现<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
<p>这种“走到尽头 + 回溯”的算法形式通常基于递归来实现。与 BFS 类似,在 DFS 中我们也需要借助一个哈希表 <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">
@ -4283,7 +4283,7 @@
<p>与广度优先遍历类似,深度优先遍历序列的顺序也不是唯一的。给定某顶点,先往哪个方向探索都可以,即邻接顶点的顺序可以任意打乱,都是深度优先遍历。</p>
<p>以树的遍历为例,“根 <span class="arithmatex">\(\rightarrow\)</span><span class="arithmatex">\(\rightarrow\)</span> 右”、“左 <span class="arithmatex">\(\rightarrow\)</span><span class="arithmatex">\(\rightarrow\)</span> 右”、“左 <span class="arithmatex">\(\rightarrow\)</span><span class="arithmatex">\(\rightarrow\)</span> 根”分别对应前序、中序、后序遍历,它们展示了三种不同的遍历优先级,然而这三者都属于深度优先遍历。</p>
</div>
<h3 id="_4">复杂度分析<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="2_1">2. &nbsp; 复杂度分析<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
<p><strong>时间复杂度:</strong> 所有顶点都会被访问 <span class="arithmatex">\(1\)</span> 次,使用 <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> 顶点数量最多为 <span class="arithmatex">\(|V|\)</span> ,递归深度最大为 <span class="arithmatex">\(|V|\)</span> ,因此使用 <span class="arithmatex">\(O(|V|)\)</span> 空间。</p>

View File

@ -3087,22 +3087,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
贪心策略确定
<a href="#1" class="md-nav__link">
1. &nbsp; 贪心策略确定
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
代码实现
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
正确性证明
<a href="#3" class="md-nav__link">
3. &nbsp; 正确性证明
</a>
</li>
@ -3390,22 +3390,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
贪心策略确定
<a href="#1" class="md-nav__link">
1. &nbsp; 贪心策略确定
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
代码实现
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
正确性证明
<a href="#3" class="md-nav__link">
3. &nbsp; 正确性证明
</a>
</li>
@ -3451,7 +3451,7 @@
<p><img alt="物品在单位重量下的价值" src="../fractional_knapsack_problem.assets/fractional_knapsack_unit_value.png" /></p>
<p align="center"> 图:物品在单位重量下的价值 </p>
<h3 id="_1">贪心策略确定<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 贪心策略确定<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>最大化背包内物品总价值,<strong>本质上是要最大化单位重量下的物品价值</strong>。由此便可推出本题的贪心策略:</p>
<ol>
<li>将物品按照单位价值从高到低进行排序。</li>
@ -3461,7 +3461,7 @@
<p><img alt="分数背包的贪心策略" src="../fractional_knapsack_problem.assets/fractional_knapsack_greedy_strategy.png" /></p>
<p align="center"> 图:分数背包的贪心策略 </p>
<h3 id="_2">代码实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>我们建立了一个物品类 <code>Item</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">
@ -3758,7 +3758,7 @@
</div>
<p>最差情况下,需要遍历整个物品列表,<strong>因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong> ,其中 <span class="arithmatex">\(n\)</span> 为物品数量。</p>
<p>由于初始化了一个 <code>Item</code> 对象列表,<strong>因此空间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong></p>
<h3 id="_3">正确性证明<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 正确性证明<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<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>

View File

@ -3115,22 +3115,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
贪心策略确定
<a href="#1" class="md-nav__link">
1. &nbsp; 贪心策略确定
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
代码实现
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
正确性证明
<a href="#3" class="md-nav__link">
3. &nbsp; 正确性证明
</a>
</li>
@ -3390,22 +3390,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
贪心策略确定
<a href="#1" class="md-nav__link">
1. &nbsp; 贪心策略确定
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
代码实现
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
正确性证明
<a href="#3" class="md-nav__link">
3. &nbsp; 正确性证明
</a>
</li>
@ -3449,7 +3449,7 @@
cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
\]</div>
<p>设数组长度为 <span class="arithmatex">\(n\)</span> ,两个隔板的组合数量(即状态总数)为 <span class="arithmatex">\(C_n^2 = \frac{n(n - 1)}{2}\)</span> 个。最直接地,<strong>我们可以穷举所有状态</strong>,从而求得最大容量,时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span></p>
<h3 id="_1">贪心策略确定<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 贪心策略确定<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>这道题还有更高效率的解法。如下图所示,现选取一个状态 <span class="arithmatex">\([i, j]\)</span> ,其满足索引 <span class="arithmatex">\(i &lt; j\)</span> 且高度 <span class="arithmatex">\(ht[i] &lt; ht[j]\)</span> ,即 <span class="arithmatex">\(i\)</span> 为短板、 <span class="arithmatex">\(j\)</span> 为长板。</p>
<p><img alt="初始状态" src="../max_capacity_problem.assets/max_capacity_initial_state.png" /></p>
<p align="center"> 图:初始状态 </p>
@ -3506,7 +3506,7 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
</div>
<p align="center"> 图:最大容量问题的贪心过程 </p>
<h3 id="_2">代码实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>代码循环最多 <span class="arithmatex">\(n\)</span> 轮,<strong>因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong></p>
<p>变量 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> , <span class="arithmatex">\(res\)</span> 使用常数大小额外空间,<strong>因此空间复杂度为 <span class="arithmatex">\(O(1)\)</span></strong></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>
@ -3692,7 +3692,7 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
</div>
</div>
</div>
<h3 id="_3">正确性证明<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 正确性证明<a class="headerlink" href="#3" title="Permanent link">&para;</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>
<div class="arithmatex">\[

View File

@ -3143,22 +3143,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
贪心策略确定
<a href="#1" class="md-nav__link">
1. &nbsp; 贪心策略确定
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
代码实现
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
正确性证明
<a href="#3" class="md-nav__link">
3. &nbsp; 正确性证明
</a>
</li>
@ -3390,22 +3390,22 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
贪心策略确定
<a href="#1" class="md-nav__link">
1. &nbsp; 贪心策略确定
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
代码实现
<a href="#2" class="md-nav__link">
2. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
正确性证明
<a href="#3" class="md-nav__link">
3. &nbsp; 正确性证明
</a>
</li>
@ -3450,7 +3450,7 @@ n = \sum_{i=1}^{m}n_i
\max(\prod_{i=1}^{m}n_i)
\]</div>
<p>我们需要思考的是:切分数量 <span class="arithmatex">\(m\)</span> 应该多大,每个 <span class="arithmatex">\(n_i\)</span> 应该是多少?</p>
<h3 id="_1">贪心策略确定<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 贪心策略确定<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>根据经验,两个整数的乘积往往比它们的加和更大。假设从 <span class="arithmatex">\(n\)</span> 中分出一个因子 <span class="arithmatex">\(2\)</span> ,则它们的乘积为 <span class="arithmatex">\(2(n-2)\)</span> 。我们将该乘积与 <span class="arithmatex">\(n\)</span> 作比较:</p>
<div class="arithmatex">\[
\begin{aligned}
@ -3477,7 +3477,7 @@ n &amp; \geq 4
<li>当余数为 <span class="arithmatex">\(2\)</span> 时,不继续划分,保留之。</li>
<li>当余数为 <span class="arithmatex">\(1\)</span> 时,由于 <span class="arithmatex">\(2 \times 2 &gt; 1 \times 3\)</span> ,因此应将最后一个 <span class="arithmatex">\(3\)</span> 替换为 <span class="arithmatex">\(2\)</span></li>
</ol>
<h3 id="_2">代码实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>在代码中,我们无需通过循环来切分整数,而可以利用向下整除运算得到 <span class="arithmatex">\(3\)</span> 的个数 <span class="arithmatex">\(a\)</span> ,用取模运算得到余数 <span class="arithmatex">\(b\)</span> ,此时有:</p>
<div class="arithmatex">\[
n = 3 a + b
@ -3672,7 +3672,7 @@ n = 3 a + b
<li>函数 <code>math.pow()</code> 内部调用 C 语言库的 <code>pow()</code> 函数,其执行浮点取幂,时间复杂度为 <span class="arithmatex">\(O(1)\)</span></li>
</ul>
<p>变量 <span class="arithmatex">\(a\)</span> , <span class="arithmatex">\(b\)</span> 使用常数大小的额外空间,<strong>因此空间复杂度为 <span class="arithmatex">\(O(1)\)</span></strong></p>
<h3 id="_3">正确性证明<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 正确性证明<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>使用反证法,只分析 <span class="arithmatex">\(n \geq 3\)</span> 的情况。</p>
<ol>
<li><strong>所有因子 <span class="arithmatex">\(\leq 3\)</span></strong> :假设最优切分方案中存在 <span class="arithmatex">\(\geq 4\)</span> 的因子 <span class="arithmatex">\(x\)</span> ,那么一定可以将其继续划分为 <span class="arithmatex">\(2(x-2)\)</span> ,从而获得更大的乘积。这与假设矛盾。</li>

View File

@ -1265,15 +1265,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
线性探测
<a href="#1" class="md-nav__link">
1. &nbsp; 线性探测
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
多次哈希
<a href="#2" class="md-nav__link">
2. &nbsp; 多次哈希
</a>
</li>
@ -3417,15 +3417,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
线性探测
<a href="#1" class="md-nav__link">
1. &nbsp; 线性探测
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
多次哈希
<a href="#2" class="md-nav__link">
2. &nbsp; 多次哈希
</a>
</li>
@ -4591,7 +4591,7 @@
</div>
<h2 id="622">6.2.2 &nbsp; 开放寻址<a class="headerlink" href="#622" title="Permanent link">&para;</a></h2>
<p>「开放寻址 Open Addressing」不引入额外的数据结构而是通过“多次探测”来处理哈希冲突探测方式主要包括线性探测、平方探测、多次哈希等。</p>
<h3 id="_1">线性探测<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 线性探测<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>线性探测采用固定步长的线性查找来进行探测,对应的哈希表操作方法为:</p>
<ul>
<li><strong>插入元素</strong>:通过哈希函数计算数组索引,若发现桶内已有元素,则从冲突位置向后线性遍历(步长通常为 <span class="arithmatex">\(1\)</span> ),直至找到空位,将元素插入其中。</li>
@ -5852,7 +5852,7 @@
</div>
</div>
</div>
<h3 id="_2">多次哈希<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 多次哈希<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>顾名思义,多次哈希方法是使用多个哈希函数 <span class="arithmatex">\(f_1(x)\)</span> , <span class="arithmatex">\(f_2(x)\)</span> , <span class="arithmatex">\(f_3(x)\)</span> , <span class="arithmatex">\(\cdots\)</span> 进行探测。</p>
<ul>
<li><strong>插入元素</strong>:若哈希函数 <span class="arithmatex">\(f_1(x)\)</span> 出现冲突,则尝试 <span class="arithmatex">\(f_2(x)\)</span> ,以此类推,直到找到空位后插入元素。</li>

View File

@ -3426,12 +3426,13 @@
<h1 id="82">8.2 &nbsp; 建堆操作<a class="headerlink" href="#82" title="Permanent link">&para;</a></h1>
<p>如果我们想要根据输入列表生成一个堆,这个过程被称为「建堆」。</p>
<p>在某些情况下,我们希望使用一个列表的所有元素来构建一个堆,这个过程被称为「建堆」。</p>
<h2 id="821">8.2.1 &nbsp; 借助入堆方法实现<a class="headerlink" href="#821" title="Permanent link">&para;</a></h2>
<p>最直接的方法是借助“元素入堆操作”实现,首先创建一个空堆,然后将列表元素依次添加到堆中</p>
<p>设元素数量为 <span class="arithmatex">\(n\)</span> 则最后一个元素入堆的时间复杂度为 <span class="arithmatex">\(O(\log n)\)</span> 。在依次添加元素时,堆的平均长度为 <span class="arithmatex">\(\frac{n}{2}\)</span> ,因此该方法的总体时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span></p>
<p>最直接的方法是借助“元素入堆操作”实现。我们首先创建一个空堆,然后将列表元素依次执行“入堆”</p>
<p>设元素数量为 <span class="arithmatex">\(n\)</span> 入堆操作使用 <span class="arithmatex">\(O(\log{n})\)</span> 时间,因此将所有元素入堆的时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span></p>
<h2 id="822">8.2.2 &nbsp; 基于堆化操作实现<a class="headerlink" href="#822" title="Permanent link">&para;</a></h2>
<p>有趣的是,存在一种更高效的建堆方法,其时间复杂度仅为 <span class="arithmatex">\(O(n)\)</span> 。我们先将列表所有元素原封不动添加到堆中,<strong>然后迭代地对各个节点执行“从顶至底堆化”</strong>。当然,<strong>我们不需要对叶节点执行堆化操作</strong>,因为它们没有子节点。</p>
<p>有趣的是,存在一种更高效的建堆方法,其时间复杂度可以达到 <span class="arithmatex">\(O(n)\)</span> 。我们先将列表所有元素原封不动添加到堆中,然后倒序遍历该堆,依次对每个节点执行“从顶至底堆化”。</p>
<p>请注意,因为叶节点没有子节点,所以无需堆化。在代码实现中,我们从最后一个节点的父节点开始进行堆化。</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">
@ -3590,7 +3591,7 @@
<h2 id="823">8.2.3 &nbsp; 复杂度分析<a class="headerlink" href="#823" title="Permanent link">&para;</a></h2>
<p>为什么第二种建堆方法的时间复杂度是 <span class="arithmatex">\(O(n)\)</span> ?我们来展开推算一下。</p>
<ul>
<li>完全二叉树中,设节点总数为 <span class="arithmatex">\(n\)</span> ,则叶节点数量为 <span class="arithmatex">\((n + 1) / 2\)</span> ,其中 <span class="arithmatex">\(/\)</span> 为向下整除。因此,在排除叶节点后,需要堆化的节点数量为 <span class="arithmatex">\((n - 1)/2\)</span> ,复杂度为 <span class="arithmatex">\(O(n)\)</span></li>
<li>完全二叉树中,设节点总数为 <span class="arithmatex">\(n\)</span> ,则叶节点数量为 <span class="arithmatex">\((n + 1) / 2\)</span> ,其中 <span class="arithmatex">\(/\)</span> 为向下整除。因此,在排除叶节点后,需要堆化的节点数量为 <span class="arithmatex">\((n - 1)/2\)</span> ,复杂度为 <span class="arithmatex">\(O(n)\)</span></li>
<li>在从顶至底堆化的过程中,每个节点最多堆化到叶节点,因此最大迭代次数为二叉树高度 <span class="arithmatex">\(O(\log n)\)</span></li>
</ul>
<p>将上述两者相乘,可得到建堆过程的时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span><strong>然而,这个估算结果并不准确,因为我们没有考虑到二叉树底层节点数量远多于顶层节点的特性</strong></p>
@ -3609,7 +3610,7 @@ T(h) &amp; = 2^0h + 2^1(h-1) + 2^2(h-2) + \cdots + 2^{h-1}\times1 \newline
2 T(h) &amp; = 2^1h + 2^2(h-1) + 2^3(h-2) + \cdots + 2^{h}\times1 \newline
\end{aligned}
\]</div>
<p><strong>使用错位相减法</strong>,令下式 <span class="arithmatex">\(2 T(h)\)</span> 减去上式 <span class="arithmatex">\(T(h)\)</span> ,可得</p>
<p>使用错位相减法,用下式 <span class="arithmatex">\(2 T(h)\)</span> 减去上式 <span class="arithmatex">\(T(h)\)</span> ,可得</p>
<div class="arithmatex">\[
2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \cdots + 2^{h-1} + 2^h
\]</div>

View File

@ -1583,29 +1583,29 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
堆的存储与表示
<a href="#1" class="md-nav__link">
1. &nbsp; 堆的存储与表示
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
访问堆顶元素
<a href="#2" class="md-nav__link">
2. &nbsp; 访问堆顶元素
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
元素入堆
<a href="#3" class="md-nav__link">
3. &nbsp; 元素入堆
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
堆顶元素出堆
<a href="#4" class="md-nav__link">
4. &nbsp; 堆顶元素出堆
</a>
</li>
@ -3431,29 +3431,29 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
堆的存储与表示
<a href="#1" class="md-nav__link">
1. &nbsp; 堆的存储与表示
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
访问堆顶元素
<a href="#2" class="md-nav__link">
2. &nbsp; 访问堆顶元素
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
元素入堆
<a href="#3" class="md-nav__link">
3. &nbsp; 元素入堆
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
堆顶元素出堆
<a href="#4" class="md-nav__link">
4. &nbsp; 堆顶元素出堆
</a>
</li>
@ -3813,7 +3813,7 @@
</div>
<h2 id="812">8.1.2 &nbsp; 堆的实现<a class="headerlink" href="#812" title="Permanent link">&para;</a></h2>
<p>下文实现的是大顶堆。若要将其转换为小顶堆,只需将所有大小逻辑判断取逆(例如,将 <span class="arithmatex">\(\geq\)</span> 替换为 <span class="arithmatex">\(\leq\)</span> )。感兴趣的读者可以自行实现。</p>
<h3 id="_1">堆的存储与表示<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 堆的存储与表示<a class="headerlink" href="#1" title="Permanent link">&para;</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>
@ -4028,7 +4028,7 @@
</div>
</div>
</div>
<h3 id="_2">访问堆顶元素<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 访问堆顶元素<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<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">
@ -4117,7 +4117,7 @@
</div>
</div>
</div>
<h3 id="_3">元素入堆<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 元素入堆<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>给定元素 <code>val</code> ,我们首先将其添加到堆底。添加之后,由于 val 可能大于堆中其他元素,堆的成立条件可能已被破坏。因此,<strong>需要修复从插入节点到根节点的路径上的各个节点</strong>,这个操作被称为「堆化 Heapify」。</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">&lt;1&gt;</label><label for="__tabbed_4_2">&lt;2&gt;</label><label for="__tabbed_4_3">&lt;3&gt;</label><label for="__tabbed_4_4">&lt;4&gt;</label><label for="__tabbed_4_5">&lt;5&gt;</label><label for="__tabbed_4_6">&lt;6&gt;</label><label for="__tabbed_4_7">&lt;7&gt;</label><label for="__tabbed_4_8">&lt;8&gt;</label><label for="__tabbed_4_9">&lt;9&gt;</label></div>
@ -4470,7 +4470,7 @@
</div>
</div>
</div>
<h3 id="_4">堆顶元素出堆<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 堆顶元素出堆<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p>堆顶元素是二叉树的根节点,即列表首元素。如果我们直接从列表中删除首元素,那么二叉树中所有节点的索引都会发生变化,这将使得后续使用堆化修复变得困难。为了尽量减少元素索引的变动,我们采取以下操作步骤:</p>
<ol>
<li>交换堆顶元素与堆底元素(即交换根节点与最右叶节点)。</li>

View File

@ -1945,15 +1945,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
复用查找左边界
<a href="#1" class="md-nav__link">
1. &nbsp; 复用查找左边界
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
转化为查找元素
<a href="#2" class="md-nav__link">
2. &nbsp; 转化为查找元素
</a>
</li>
@ -3418,15 +3418,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
复用查找左边界
<a href="#1" class="md-nav__link">
1. &nbsp; 复用查找左边界
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
转化为查找元素
<a href="#2" class="md-nav__link">
2. &nbsp; 转化为查找元素
</a>
</li>
@ -3585,7 +3585,7 @@
<h2 id="1032">10.3.2 &nbsp; 查找右边界<a class="headerlink" href="#1032" title="Permanent link">&para;</a></h2>
<p>那么如何查找最右一个 <code>target</code> 呢?最直接的方式是修改代码,替换在 <code>nums[m] == target</code> 情况下的指针收缩操作。代码在此省略,有兴趣的同学可以自行实现。</p>
<p>下面我们介绍两种更加取巧的方法。</p>
<h3 id="_1">复用查找左边界<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 复用查找左边界<a class="headerlink" href="#1" title="Permanent link">&para;</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><img alt="将查找右边界转化为查找左边界" src="../binary_search_edge.assets/binary_search_right_edge_by_left_edge.png" /></p>
@ -3714,7 +3714,7 @@
</div>
</div>
</div>
<h3 id="_2">转化为查找元素<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 转化为查找元素<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>我们知道,当数组不包含 <code>target</code> 时,最后 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 会分别指向首个大于、小于 <code>target</code> 的元素。</p>
<p>根据上述结论,我们可以构造一个数组中不存在的元素,用于查找左右边界:</p>
<ul>

View File

@ -1138,15 +1138,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
基于双向链表的实现
<a href="#1" class="md-nav__link">
1. &nbsp; 基于双向链表的实现
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
基于数组的实现
<a href="#2" class="md-nav__link">
2. &nbsp; 基于数组的实现
</a>
</li>
@ -3417,15 +3417,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
基于双向链表的实现
<a href="#1" class="md-nav__link">
1. &nbsp; 基于双向链表的实现
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
基于数组的实现
<a href="#2" class="md-nav__link">
2. &nbsp; 基于数组的实现
</a>
</li>
@ -3795,7 +3795,7 @@
</div>
<h2 id="532">5.3.2 &nbsp; 双向队列实现 *<a class="headerlink" href="#532" title="Permanent link">&para;</a></h2>
<p>双向队列的实现与队列类似,可以选择链表或数组作为底层数据结构。</p>
<h3 id="_1">基于双向链表的实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 基于双向链表的实现<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>回顾上一节内容,我们使用普通单向链表来实现队列,因为它可以方便地删除头节点(对应出队操作)和在尾节点后添加新节点(对应入队操作)。</p>
<p>对于双向队列而言,头部和尾部都可以执行入队和出队操作。换句话说,双向队列需要实现另一个对称方向的操作。为此,我们采用「双向链表」作为双向队列的底层数据结构。</p>
<p>我们将双向链表的头节点和尾节点视为双向队列的队首和队尾,同时实现在两端添加和删除节点的功能。</p>
@ -5417,7 +5417,7 @@
</div>
</div>
</div>
<h3 id="_2">基于数组的实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 基于数组的实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<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">

View File

@ -1118,15 +1118,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
基于链表的实现
<a href="#1" class="md-nav__link">
1. &nbsp; 基于链表的实现
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
基于数组的实现
<a href="#2" class="md-nav__link">
2. &nbsp; 基于数组的实现
</a>
</li>
@ -3417,15 +3417,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
基于链表的实现
<a href="#1" class="md-nav__link">
1. &nbsp; 基于链表的实现
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
基于数组的实现
<a href="#2" class="md-nav__link">
2. &nbsp; 基于数组的实现
</a>
</li>
@ -3749,7 +3749,7 @@
</div>
<h2 id="522">5.2.2 &nbsp; 队列实现<a class="headerlink" href="#522" title="Permanent link">&para;</a></h2>
<p>为了实现队列,我们需要一种数据结构,可以在一端添加元素,并在另一端删除元素。因此,链表和数组都可以用来实现队列。</p>
<h3 id="_1">基于链表的实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 基于链表的实现<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>对于链表实现,我们可以将链表的「头节点」和「尾节点」分别视为队首和队尾,规定队尾仅可添加节点,而队首仅可删除节点。</p>
<div class="tabbed-set tabbed-alternate" data-tabs="2: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">
@ -4615,7 +4615,7 @@
</div>
</div>
</div>
<h3 id="_2">基于数组的实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 基于数组的实现<a class="headerlink" href="#2" title="Permanent link">&para;</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>

View File

@ -1098,15 +1098,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
基于链表的实现
<a href="#1" class="md-nav__link">
1. &nbsp; 基于链表的实现
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
基于数组的实现
<a href="#2" class="md-nav__link">
2. &nbsp; 基于数组的实现
</a>
</li>
@ -1125,22 +1125,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
支持操作
<a href="#1_1" class="md-nav__link">
1. &nbsp; 支持操作
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
时间效率
<a href="#2_1" class="md-nav__link">
2. &nbsp; 时间效率
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
空间效率
<a href="#3" class="md-nav__link">
3. &nbsp; 空间效率
</a>
</li>
@ -3451,15 +3451,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
基于链表的实现
<a href="#1" class="md-nav__link">
1. &nbsp; 基于链表的实现
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
基于数组的实现
<a href="#2" class="md-nav__link">
2. &nbsp; 基于数组的实现
</a>
</li>
@ -3478,22 +3478,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
支持操作
<a href="#1_1" class="md-nav__link">
1. &nbsp; 支持操作
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
时间效率
<a href="#2_1" class="md-nav__link">
2. &nbsp; 时间效率
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
空间效率
<a href="#3" class="md-nav__link">
3. &nbsp; 空间效率
</a>
</li>
@ -3815,7 +3815,7 @@
<h2 id="512">5.1.2 &nbsp; 栈的实现<a class="headerlink" href="#512" title="Permanent link">&para;</a></h2>
<p>为了深入了解栈的运行机制,我们来尝试自己实现一个栈类。</p>
<p>栈遵循先入后出的原则,因此我们只能在栈顶添加或删除元素。然而,数组和链表都可以在任意位置添加和删除元素,<strong>因此栈可以被视为一种受限制的数组或链表</strong>。换句话说,我们可以“屏蔽”数组或链表的部分无关操作,使其对外表现的逻辑符合栈的特性。</p>
<h3 id="_1">基于链表的实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 基于链表的实现<a class="headerlink" href="#1" title="Permanent link">&para;</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">LinkedListStack</label><label for="__tabbed_2_2">push()</label><label for="__tabbed_2_3">pop()</label></div>
@ -4566,7 +4566,7 @@
</div>
</div>
</div>
<h3 id="_2">基于数组的实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 基于数组的实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<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">
@ -5153,9 +5153,9 @@
</div>
</div>
<h2 id="513">5.1.3 &nbsp; 两种实现对比<a class="headerlink" href="#513" title="Permanent link">&para;</a></h2>
<h3 id="_3">支持操作<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="1_1">1. &nbsp; 支持操作<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
<p>两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问,但这已超出了栈的定义范畴,因此一般不会用到。</p>
<h3 id="_4">时间效率<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="2_1">2. &nbsp; 时间效率<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
<p>在基于数组的实现中,入栈和出栈操作都是在预先分配好的连续内存中进行,具有很好的缓存本地性,因此效率较高。然而,如果入栈时超出数组容量,会触发扩容机制,导致该次入栈操作的时间复杂度变为 <span class="arithmatex">\(O(n)\)</span></p>
<p>在链表实现中,链表的扩容非常灵活,不存在上述数组扩容时效率降低的问题。但是,入栈操作需要初始化节点对象并修改指针,因此效率相对较低。不过,如果入栈元素本身就是节点对象,那么可以省去初始化步骤,从而提高效率。</p>
<p>综上所述,当入栈与出栈操作的元素是基本数据类型(如 <code>int</code> , <code>double</code> )时,我们可以得出以下结论:</p>
@ -5163,7 +5163,7 @@
<li>基于数组实现的栈在触发扩容时效率会降低,但由于扩容是低频操作,因此平均效率更高。</li>
<li>基于链表实现的栈可以提供更加稳定的效率表现。</li>
</ul>
<h3 id="_5">空间效率<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 空间效率<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>在初始化列表时,系统会为列表分配“初始容量”,该容量可能超过实际需求。并且,扩容机制通常是按照特定倍率(例如 2 倍)进行扩容,扩容后的容量也可能超出实际需求。因此,<strong>基于数组实现的栈可能造成一定的空间浪费</strong></p>
<p>然而,由于链表节点需要额外存储指针,<strong>因此链表节点占用的空间相对较大</strong></p>
<p>综上,我们不能简单地确定哪种实现更加节省内存,需要针对具体情况进行分析。</p>

View File

@ -1469,15 +1469,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
节点高度
<a href="#1" class="md-nav__link">
1. &nbsp; 节点高度
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
节点平衡因子
<a href="#2" class="md-nav__link">
2. &nbsp; 节点平衡因子
</a>
</li>
@ -1496,36 +1496,36 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
右旋
<a href="#1_1" class="md-nav__link">
1. &nbsp; 右旋
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
左旋
<a href="#2_1" class="md-nav__link">
2. &nbsp; 左旋
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
先左旋后右旋
<a href="#3" class="md-nav__link">
3. &nbsp; 先左旋后右旋
</a>
</li>
<li class="md-nav__item">
<a href="#_6" class="md-nav__link">
先右旋后左旋
<a href="#4" class="md-nav__link">
4. &nbsp; 先右旋后左旋
</a>
</li>
<li class="md-nav__item">
<a href="#_7" class="md-nav__link">
旋转的选择
<a href="#5" class="md-nav__link">
5. &nbsp; 旋转的选择
</a>
</li>
@ -1544,22 +1544,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_8" class="md-nav__link">
插入节点
<a href="#1_2" class="md-nav__link">
1. &nbsp; 插入节点
</a>
</li>
<li class="md-nav__item">
<a href="#_9" class="md-nav__link">
删除节点
<a href="#2_2" class="md-nav__link">
2. &nbsp; 删除节点
</a>
</li>
<li class="md-nav__item">
<a href="#_10" class="md-nav__link">
查找节点
<a href="#3_1" class="md-nav__link">
3. &nbsp; 查找节点
</a>
</li>
@ -3485,15 +3485,15 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
节点高度
<a href="#1" class="md-nav__link">
1. &nbsp; 节点高度
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
节点平衡因子
<a href="#2" class="md-nav__link">
2. &nbsp; 节点平衡因子
</a>
</li>
@ -3512,36 +3512,36 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
右旋
<a href="#1_1" class="md-nav__link">
1. &nbsp; 右旋
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
左旋
<a href="#2_1" class="md-nav__link">
2. &nbsp; 左旋
</a>
</li>
<li class="md-nav__item">
<a href="#_5" class="md-nav__link">
先左旋后右旋
<a href="#3" class="md-nav__link">
3. &nbsp; 先左旋后右旋
</a>
</li>
<li class="md-nav__item">
<a href="#_6" class="md-nav__link">
先右旋后左旋
<a href="#4" class="md-nav__link">
4. &nbsp; 先右旋后左旋
</a>
</li>
<li class="md-nav__item">
<a href="#_7" class="md-nav__link">
旋转的选择
<a href="#5" class="md-nav__link">
5. &nbsp; 旋转的选择
</a>
</li>
@ -3560,22 +3560,22 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_8" class="md-nav__link">
插入节点
<a href="#1_2" class="md-nav__link">
1. &nbsp; 插入节点
</a>
</li>
<li class="md-nav__item">
<a href="#_9" class="md-nav__link">
删除节点
<a href="#2_2" class="md-nav__link">
2. &nbsp; 删除节点
</a>
</li>
<li class="md-nav__item">
<a href="#_10" class="md-nav__link">
查找节点
<a href="#3_1" class="md-nav__link">
3. &nbsp; 查找节点
</a>
</li>
@ -3628,7 +3628,7 @@
<p>G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorithm for the organization of information" 中提出了「AVL 树」。论文中详细描述了一系列操作确保在持续添加和删除节点后AVL 树不会退化,从而使得各种操作的时间复杂度保持在 <span class="arithmatex">\(O(\log n)\)</span> 级别。换句话说在需要频繁进行增删查改操作的场景中AVL 树能始终保持高效的数据操作性能,具有很好的应用价值。</p>
<h2 id="751-avl">7.5.1 &nbsp; AVL 树常见术语<a class="headerlink" href="#751-avl" title="Permanent link">&para;</a></h2>
<p>「AVL 树」既是二叉搜索树也是平衡二叉树,同时满足这两类二叉树的所有性质,因此也被称为「平衡二叉搜索树」。</p>
<h3 id="_1">节点高度<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 节点高度<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>在操作 AVL 树时,我们需要获取节点的高度,因此需要为 AVL 树的节点类添加 <code>height</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">
@ -3979,7 +3979,7 @@
</div>
</div>
</div>
<h3 id="_2">节点平衡因子<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 节点平衡因子<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>节点的「平衡因子 Balance Factor」定义为节点左子树的高度减去右子树的高度同时规定空节点的平衡因子为 0 。我们同样将获取节点平衡因子的功能封装成函数,方便后续使用。</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">
@ -4122,7 +4122,7 @@
<h2 id="752-avl">7.5.2 &nbsp; AVL 树旋转<a class="headerlink" href="#752-avl" title="Permanent link">&para;</a></h2>
<p>AVL 树的特点在于「旋转 Rotation」操作它能够在不影响二叉树的中序遍历序列的前提下使失衡节点重新恢复平衡。换句话说<strong>旋转操作既能保持树的「二叉搜索树」属性,也能使树重新变为「平衡二叉树」</strong></p>
<p>我们将平衡因子绝对值 <span class="arithmatex">\(&gt; 1\)</span> 的节点称为「失衡节点」。根据节点失衡情况的不同,旋转操作分为四种:右旋、左旋、先右旋后左旋、先左旋后右旋。下面我们将详细介绍这些旋转操作。</p>
<h3 id="_3">右旋<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="1_1">1. &nbsp; 右旋<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
<p>如下图所示,节点下方为平衡因子。从底至顶看,二叉树中首个失衡节点是“节点 3”。我们关注以该失衡节点为根节点的子树将该节点记为 <code>node</code> ,其左子节点记为 <code>child</code> ,执行「右旋」操作。完成右旋后,子树已经恢复平衡,并且仍然保持二叉搜索树的特性。</p>
<div class="tabbed-set tabbed-alternate" data-tabs="4:4"><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" /><div class="tabbed-labels"><label for="__tabbed_4_1">&lt;1&gt;</label><label for="__tabbed_4_2">&lt;2&gt;</label><label for="__tabbed_4_3">&lt;3&gt;</label><label for="__tabbed_4_4">&lt;4&gt;</label></div>
<div class="tabbed-content">
@ -4348,7 +4348,7 @@
</div>
</div>
</div>
<h3 id="_4">左旋<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="2_1">2. &nbsp; 左旋<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
<p>相应的,如果考虑上述失衡二叉树的“镜像”,则需要执行「左旋」操作。</p>
<p><img alt="左旋操作" src="../avl_tree.assets/avltree_left_rotate.png" /></p>
<p align="center"> 图:左旋操作 </p>
@ -4559,17 +4559,17 @@
</div>
</div>
</div>
<h3 id="_5">先左旋后右旋<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 先左旋后右旋<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>对于下图中的失衡节点 3仅使用左旋或右旋都无法使子树恢复平衡。此时需要先左旋后右旋即先对 <code>child</code> 执行「左旋」,再对 <code>node</code> 执行「右旋」。</p>
<p><img alt="先左旋后右旋" src="../avl_tree.assets/avltree_left_right_rotate.png" /></p>
<p align="center"> 图:先左旋后右旋 </p>
<h3 id="_6">先右旋后左旋<a class="headerlink" href="#_6" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 先右旋后左旋<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p>同理,对于上述失衡二叉树的镜像情况,需要先右旋后左旋,即先对 <code>child</code> 执行「右旋」,然后对 <code>node</code> 执行「左旋」。</p>
<p><img alt="先右旋后左旋" src="../avl_tree.assets/avltree_right_left_rotate.png" /></p>
<p align="center"> 图:先右旋后左旋 </p>
<h3 id="_7">旋转的选择<a class="headerlink" href="#_7" title="Permanent link">&para;</a></h3>
<h3 id="5">5. &nbsp; 旋转的选择<a class="headerlink" href="#5" title="Permanent link">&para;</a></h3>
<p>下图展示的四种失衡情况与上述案例逐个对应,分别需要采用右旋、左旋、先右后左、先左后右的旋转操作。</p>
<p><img alt="AVL 树的四种旋转情况" src="../avl_tree.assets/avltree_rotation_cases.png" /></p>
<p align="center">AVL 树的四种旋转情况 </p>
@ -5001,7 +5001,7 @@
</div>
</div>
<h2 id="753-avl">7.5.3 &nbsp; AVL 树常用操作<a class="headerlink" href="#753-avl" title="Permanent link">&para;</a></h2>
<h3 id="_8">插入节点<a class="headerlink" href="#_8" title="Permanent link">&para;</a></h3>
<h3 id="1_2">1. &nbsp; 插入节点<a class="headerlink" href="#1_2" title="Permanent link">&para;</a></h3>
<p>「AVL 树」的节点插入操作与「二叉搜索树」在主体上类似。唯一的区别在于,在 AVL 树中插入节点后,从该节点到根节点的路径上可能会出现一系列失衡节点。因此,<strong>我们需要从这个节点开始,自底向上执行旋转操作,使所有失衡节点恢复平衡</strong></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">
@ -5331,7 +5331,7 @@
</div>
</div>
</div>
<h3 id="_9">删除节点<a class="headerlink" href="#_9" title="Permanent link">&para;</a></h3>
<h3 id="2_2">2. &nbsp; 删除节点<a class="headerlink" href="#2_2" title="Permanent link">&para;</a></h3>
<p>类似地,在二叉搜索树的删除节点方法的基础上,需要从底至顶地执行旋转操作,使所有失衡节点恢复平衡。</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">
@ -5868,7 +5868,7 @@
</div>
</div>
</div>
<h3 id="_10">查找节点<a class="headerlink" href="#_10" title="Permanent link">&para;</a></h3>
<h3 id="3_1">3. &nbsp; 查找节点<a class="headerlink" href="#3_1" title="Permanent link">&para;</a></h3>
<p>AVL 树的节点查找操作与二叉搜索树一致,在此不再赘述。</p>
<h2 id="754-avl">7.5.4 &nbsp; AVL 树典型应用<a class="headerlink" href="#754-avl" title="Permanent link">&para;</a></h2>
<ul>

View File

@ -1449,29 +1449,29 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
查找节点
<a href="#1" class="md-nav__link">
1. &nbsp; 查找节点
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
插入节点
<a href="#2" class="md-nav__link">
2. &nbsp; 插入节点
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
删除节点
<a href="#3" class="md-nav__link">
3. &nbsp; 删除节点
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
排序
<a href="#4" class="md-nav__link">
4. &nbsp; 排序
</a>
</li>
@ -3424,29 +3424,29 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
查找节点
<a href="#1" class="md-nav__link">
1. &nbsp; 查找节点
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
插入节点
<a href="#2" class="md-nav__link">
2. &nbsp; 插入节点
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
删除节点
<a href="#3" class="md-nav__link">
3. &nbsp; 删除节点
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
排序
<a href="#4" class="md-nav__link">
4. &nbsp; 排序
</a>
</li>
@ -3504,7 +3504,7 @@
<h2 id="741">7.4.1 &nbsp; 二叉搜索树的操作<a class="headerlink" href="#741" title="Permanent link">&para;</a></h2>
<p>我们将二叉搜索树封装为一个类 <code>ArrayBinaryTree</code> ,并声明一个成员变量 <code>root</code> ,指向树的根节点。</p>
<h3 id="_1">查找节点<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 查找节点<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>给定目标节点值 <code>num</code> ,可以根据二叉搜索树的性质来查找。我们声明一个节点 <code>cur</code> ,从二叉树的根节点 <code>root</code> 出发,循环比较节点值 <code>cur.val</code><code>num</code> 之间的大小关系</p>
<ul>
<li><code>cur.val &lt; num</code> ,说明目标节点在 <code>cur</code> 的右子树中,因此执行 <code>cur = cur.right</code></li>
@ -3788,7 +3788,7 @@
</div>
</div>
</div>
<h3 id="_2">插入节点<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 插入节点<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>给定一个待插入元素 <code>num</code> ,为了保持二叉搜索树“左子树 &lt; 根节点 &lt; 右子树”的性质,插入操作分为两步:</p>
<ol>
<li><strong>查找插入位置</strong>:与查找操作相似,从根节点出发,根据当前节点值和 <code>num</code> 的大小关系循环向下搜索,直到越过叶节点(遍历至 <span class="arithmatex">\(\text{None}\)</span> )时跳出循环。</li>
@ -4172,7 +4172,7 @@
</div>
<p>为了插入节点,我们需要利用辅助节点 <code>pre</code> 保存上一轮循环的节点,这样在遍历至 <span class="arithmatex">\(\text{None}\)</span> 时,我们可以获取到其父节点,从而完成节点插入操作。</p>
<p>与查找节点相同,插入节点使用 <span class="arithmatex">\(O(\log n)\)</span> 时间。</p>
<h3 id="_3">删除节点<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 删除节点<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>与插入节点类似,我们需要在删除操作后维持二叉搜索树的“左子树 &lt; 根节点 &lt; 右子树”的性质。首先,我们需要在二叉树中执行查找操作,获取待删除节点。接下来,根据待删除节点的子节点数量,删除操作需分为三种情况:</p>
<p>当待删除节点的度为 <span class="arithmatex">\(0\)</span> 时,表示待删除节点是叶节点,可以直接删除。</p>
<p><img alt="在二叉搜索树中删除节点(度为 0" src="../binary_search_tree.assets/bst_remove_case1.png" /></p>
@ -4898,7 +4898,7 @@ void insert(int num) {
</div>
</div>
</div>
<h3 id="_4">排序<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 排序<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p>我们知道,二叉树的中序遍历遵循“左 <span class="arithmatex">\(\rightarrow\)</span><span class="arithmatex">\(\rightarrow\)</span> 右”的遍历顺序,而二叉搜索树满足“左子节点 <span class="arithmatex">\(&lt;\)</span> 根节点 <span class="arithmatex">\(&lt;\)</span> 右子节点”的大小关系。因此,在二叉搜索树中进行中序遍历时,总是会优先遍历下一个最小节点,从而得出一个重要性质:<strong>二叉搜索树的中序遍历序列是升序的</strong></p>
<p>利用中序遍历升序的性质,我们在二叉搜索树中获取有序数据仅需 <span class="arithmatex">\(O(n)\)</span> 时间,无需额外排序,非常高效。</p>
<p><img alt="二叉搜索树的中序遍历序列" src="../binary_search_tree.assets/bst_inorder_traversal.png" /></p>

View File

@ -1403,29 +1403,29 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
完美二叉树
<a href="#1" class="md-nav__link">
1. &nbsp; 完美二叉树
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
完全二叉树
<a href="#2" class="md-nav__link">
2. &nbsp; 完全二叉树
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
完满二叉树
<a href="#3" class="md-nav__link">
3. &nbsp; 完满二叉树
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
平衡二叉树
<a href="#4" class="md-nav__link">
4. &nbsp; 平衡二叉树
</a>
</li>
@ -3445,29 +3445,29 @@
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#_1" class="md-nav__link">
完美二叉树
<a href="#1" class="md-nav__link">
1. &nbsp; 完美二叉树
</a>
</li>
<li class="md-nav__item">
<a href="#_2" class="md-nav__link">
完全二叉树
<a href="#2" class="md-nav__link">
2. &nbsp; 完全二叉树
</a>
</li>
<li class="md-nav__item">
<a href="#_3" class="md-nav__link">
完满二叉树
<a href="#3" class="md-nav__link">
3. &nbsp; 完满二叉树
</a>
</li>
<li class="md-nav__item">
<a href="#_4" class="md-nav__link">
平衡二叉树
<a href="#4" class="md-nav__link">
4. &nbsp; 平衡二叉树
</a>
</li>
@ -3953,7 +3953,7 @@
<p>需要注意的是,插入节点可能会改变二叉树的原有逻辑结构,而删除节点通常意味着删除该节点及其所有子树。因此,在二叉树中,插入与删除操作通常是由一套操作配合完成的,以实现有实际意义的操作。</p>
</div>
<h2 id="713">7.1.3 &nbsp; 常见二叉树类型<a class="headerlink" href="#713" title="Permanent link">&para;</a></h2>
<h3 id="_1">完美二叉树<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
<h3 id="1">1. &nbsp; 完美二叉树<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>「完美二叉树 Perfect Binary Tree」除了最底层外其余所有层的节点都被完全填满。在完美二叉树中叶节点的度为 <span class="arithmatex">\(0\)</span> ,其余所有节点的度都为 <span class="arithmatex">\(2\)</span> ;若树高度为 <span class="arithmatex">\(h\)</span> ,则节点总数为 <span class="arithmatex">\(2^{h+1} - 1\)</span> ,呈现标准的指数级关系,反映了自然界中常见的细胞分裂现象。</p>
<div class="admonition tip">
<p class="admonition-title">Tip</p>
@ -3962,17 +3962,17 @@
<p><img alt="完美二叉树" src="../binary_tree.assets/perfect_binary_tree.png" /></p>
<p align="center"> 图:完美二叉树 </p>
<h3 id="_2">完全二叉树<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<h3 id="2">2. &nbsp; 完全二叉树<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<p>「完全二叉树 Complete Binary Tree」只有最底层的节点未被填满且最底层节点尽量靠左填充。</p>
<p><img alt="完全二叉树" src="../binary_tree.assets/complete_binary_tree.png" /></p>
<p align="center"> 图:完全二叉树 </p>
<h3 id="_3">完满二叉树<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
<h3 id="3">3. &nbsp; 完满二叉树<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>「完满二叉树 Full Binary Tree」除了叶节点之外其余所有节点都有两个子节点。</p>
<p><img alt="完满二叉树" src="../binary_tree.assets/full_binary_tree.png" /></p>
<p align="center"> 图:完满二叉树 </p>
<h3 id="_4">平衡二叉树<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
<h3 id="4">4. &nbsp; 平衡二叉树<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p>「平衡二叉树 Balanced Binary Tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。</p>
<p><img alt="平衡二叉树" src="../binary_tree.assets/balanced_binary_tree.png" /></p>
<p align="center"> 图:平衡二叉树 </p>

File diff suppressed because one or more lines are too long

View File

@ -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-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_appendix/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_appendix/contribution/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_appendix/installation/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/array/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/linked_list/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/list/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_backtracking/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_backtracking/backtracking_algorithm/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_backtracking/n_queens_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_backtracking/permutations_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_backtracking/subset_sum_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_backtracking/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_computational_complexity/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_computational_complexity/performance_evaluation/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_computational_complexity/space_complexity/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_computational_complexity/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_computational_complexity/time_complexity/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_data_structure/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_data_structure/basic_data_types/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_data_structure/character_encoding/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_data_structure/classification_of_data_structure/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_data_structure/number_encoding/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_data_structure/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/binary_search_recur/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/build_binary_tree_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/divide_and_conquer/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/hanota_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_dynamic_programming/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_dynamic_programming/dp_problem_features/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_dynamic_programming/dp_solution_pipeline/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_dynamic_programming/edit_distance_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_dynamic_programming/intro_to_dynamic_programming/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_dynamic_programming/knapsack_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_dynamic_programming/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_dynamic_programming/unbounded_knapsack_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_graph/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_graph/graph/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_graph/graph_operations/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_graph/graph_traversal/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_graph/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_greedy/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_greedy/fractional_knapsack_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_greedy/greedy_algorithm/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_greedy/max_capacity_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_greedy/max_product_cutting_problem/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_greedy/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_hashing/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_hashing/hash_algorithm/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_hashing/hash_collision/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_hashing/hash_map/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_hashing/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_heap/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_heap/build_heap/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_heap/heap/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_heap/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_heap/top_k/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_introduction/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_introduction/algorithms_are_everywhere/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_introduction/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_introduction/what_is_dsa/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_preface/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_preface/about_the_book/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_preface/suggestions/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_preface/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_reference/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_searching/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_searching/binary_search/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_searching/binary_search_edge/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_searching/binary_search_insertion/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_searching/replace_linear_by_hashing/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_searching/searching_algorithm_revisited/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_searching/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/bubble_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/bucket_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/counting_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/heap_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/insertion_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/merge_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/quick_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/radix_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/selection_sort/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/sorting_algorithm/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_sorting/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_stack_and_queue/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_stack_and_queue/deque/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_stack_and_queue/queue/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_stack_and_queue/stack/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_stack_and_queue/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_tree/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_tree/array_representation_of_tree/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_tree/avl_tree/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_tree/binary_search_tree/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_tree/binary_tree/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_tree/binary_tree_traversal/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
<url>
<loc>https://www.hello-algo.com/chapter_tree/summary/</loc>
<lastmod>2023-08-19</lastmod>
<lastmod>2023-08-20</lastmod>
<changefreq>daily</changefreq>
</url>
</urlset>

Binary file not shown.