github_mirrors/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-02-03 07:01:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

deploy

Browse Source
This commit is contained in:
krahets 2023-08-29 20:57:26 +08:00
parent 6ae6c480e0
commit 8c4d24795c
32 changed files with 574 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
chapter_array_and_linkedlist/summary/index.html
View File

@ -1026,8 +1026,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#441-q-a" class="md-nav__link">
4.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#441-q-a" class="md-nav__link">
4.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,13 +3442,14 @@
<h1 id="44">4.4 &nbsp; 小结<a class="headerlink" href="#44" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>数组和链表是两种基本的数据结构，分别代表数据在计算机内存中的两种存储方式：连续空间存储和离散空间存储。两者的特点呈现出互补的特性。</li>
<li>数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变。</li>
<li>链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、循环链表、双向链表。</li>
<li>动态数组，又称列表，是基于数组实现的一种数据结构。它保留了数组的优势，同时可以灵活调整长度。列表的出现极大地提高了数组的易用性，但可能导致部分内存空间浪费。</li>
</ul>
<h2 id="441-q-a">4.4.1 &nbsp; Q &amp; A<a class="headerlink" href="#441-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">数组存储在栈上和存储在堆上，对时间效率和空间效率是否有影响？</p>
<p>栈内存分配由编译器自动完成，而堆内存由程序员在代码中分配（注意，这里的栈和堆和数据结构中的栈和堆不是同一概念）。</p>

76
chapter_backtracking/summary/index.html
View File

@ -2662,6 +2662,17 @@
<label class="md-nav__link md-nav__link--active" for="__toc">
<span class="md-ellipsis">
13.5 &nbsp; 小结
</span>
<span class="md-nav__icon md-icon"></span>
</label>
<a href="./" class="md-nav__link md-nav__link--active">
@ -2672,6 +2683,39 @@
</a>
<nav class="md-nav md-nav--secondary" aria-label="目录">
<label class="md-nav__title" for="__toc">
<span class="md-nav__icon md-icon"></span>
目录
</label>
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
</ul>
</nav>
</li>
@ -3354,6 +3398,28 @@
<label class="md-nav__title" for="__toc">
<span class="md-nav__icon md-icon"></span>
目录
</label>
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
</ul>
</nav>
</div>
</div>
@ -3376,6 +3442,7 @@
<h1 id="135">13.5 &nbsp; 小结<a class="headerlink" href="#135" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>回溯算法本质是穷举法，通过对解空间进行深度优先遍历来寻找符合条件的解。在搜索过程中，遇到满足条件的解则记录，直至找到所有解或遍历完成后结束。</li>
<li>回溯算法的搜索过程包括尝试与回退两个部分。它通过深度优先搜索来尝试各种选择，当遇到不满足约束条件的情况时，则撤销上一步的选择，退回到之前的状态，并继续尝试其他选择。尝试与回退是两个方向相反的操作。</li>
@ -3388,6 +3455,15 @@
<li><span class="arithmatex">\(n\)</span> 皇后旨在寻找将 <span class="arithmatex">\(n\)</span> 个皇后放置到 <span class="arithmatex">\(n \times n\)</span> 尺寸棋盘上的方案，要求所有皇后两两之间无法攻击对方。该问题的约束条件有行约束、列约束、主对角线和副对角线约束。为满足行约束，我们采用按行放置的策略，保证每一行放置一个皇后。</li>
<li>列约束和对角线约束的处理方式类似。对于列约束，我们利用一个数组来记录每一列是否有皇后，从而指示选中的格子是否合法。对于对角线约束，我们借助两个数组来分别记录该主、副对角线是否存在皇后；难点在于找处在到同一主（副）对角线上格子满足的行列索引规律。</li>
</ul>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">怎么理解回溯和递归的关系？</p>
<p>总的来看，回溯是一种“算法策略”，而递归更像是一个“工具”。</p>
<ul>
<li>回溯算法通常基于递归实现。然而，回溯是递归的应用场景之一，是递归在搜索问题中的应用。</li>
<li>递归的结构体现了“子问题分解”的解题范式，常用于解决分治、回溯、动态规划（记忆化递归）等问题。</li>
</ul>
</div>

25
chapter_computational_complexity/summary/index.html
View File

@ -710,8 +710,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#251-q-a" class="md-nav__link">
2.5.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#251-q-a" class="md-nav__link">
2.5.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,6 +3442,7 @@
<h1 id="25">2.5 &nbsp; 小结<a class="headerlink" href="#25" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p><strong>算法效率评估</strong></p>
<ul>
<li>时间效率和空间效率是衡量算法优劣的两个主要评价指标。</li>
@ -3450,7 +3465,7 @@
<li>我们通常只关注最差空间复杂度，即统计算法在最差输入数据和最差运行时间点下的空间复杂度。</li>
<li>常见空间复杂度从小到大排列有 <span class="arithmatex">\(O(1)\)</span>、<span class="arithmatex">\(O(\log n)\)</span>、<span class="arithmatex">\(O(n)\)</span>、<span class="arithmatex">\(O(n^2)\)</span> 和 <span class="arithmatex">\(O(2^n)\)</span> 等。</li>
</ul>
<h2 id="251-q-a">2.5.1 &nbsp; Q &amp; A<a class="headerlink" href="#251-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">尾递归的空间复杂度是 <span class="arithmatex">\(O(1)\)</span> 吗？</p>
<p>理论上，尾递归函数的空间复杂度可以被优化至 <span class="arithmatex">\(O(1)\)</span> 。不过绝大多数编程语言（例如 Java、Python、C++、Go、C# 等）都不支持自动优化尾递归，因此通常认为空间复杂度是 <span class="arithmatex">\(O(n)\)</span> 。</p>

2
chapter_data_structure/basic_data_types/index.html
View File

@ -3480,7 +3480,7 @@
<li>即使表示布尔量仅需 1 位（<span class="arithmatex">\(0\)</span> 或 <span class="arithmatex">\(1\)</span>），它在内存中通常被存储为 1 字节。这是因为现代计算机 CPU 通常将 1 字节作为最小寻址内存单元。</li>
</ul>
<p>那么，基本数据类型与数据结构之间有什么联系呢？我们知道，数据结构是在计算机中组织与存储数据的方式。它的主语是“结构”而非“数据”。</p>
<p>如果想要表示“一排数字”，我们自然会想到使用数组。这是因为数组的线性结构可以表示数字的相邻关系和顺序关系，但至于存储的内容是整数 <code>int</code>、小数 <code>float</code>或是字符 <code>char</code> ，则与“数据结构”无关。</p>
<p>如果想要表示“一排数字”，我们自然会想到使用数组。这是因为数组的线性结构可以表示数字的相邻关系和顺序关系，但至于存储的内容是整数 <code>int</code>、小数 <code>float</code> 或是字符 <code>char</code> ，则与“数据结构”无关。</p>
<p>换句话说，<strong>基本数据类型提供了数据的“内容类型”，而数据结构提供了数据的“组织方式”</strong>。例如以下代码，我们用相同的数据结构（数组）来存储与表示不同的基本数据类型，包括 <code>int</code>、<code>float</code>、<code>char</code>、<code>bool</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">

2
chapter_data_structure/classification_of_data_structure/index.html
View File

@ -3479,7 +3479,7 @@
<p>基于数组实现的数据结构也被称为“静态数据结构”，这意味着此类数据结构在初始化后长度不可变。相对应地，基于链表实现的数据结构被称为“动态数据结构”，这类数据结构在初始化后，仍可以在程序运行过程中对其长度进行调整。</p>
<div class="admonition tip">
<p class="admonition-title">Tip</p>
<p>如若感觉理解物理结构有困难，建议先阅读下一章“数组与链表”，然后再回顾本节内容。</p>
<p>如果你感觉物理结构理解起来有困难，建议先阅读下一章“数组与链表”，然后再回顾本节内容。</p>
</div>

25
chapter_data_structure/summary/index.html
View File

@ -879,8 +879,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#351-q-a" class="md-nav__link">
3.5.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#351-q-a" class="md-nav__link">
3.5.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,6 +3442,7 @@
<h1 id="35">3.5 &nbsp; 小结<a class="headerlink" href="#35" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>数据结构可以从逻辑结构和物理结构两个角度进行分类。逻辑结构描述了数据元素之间的逻辑关系，而物理结构描述了数据在计算机内存中的存储方式。</li>
<li>常见的逻辑结构包括线性、树状和网状等。通常我们根据逻辑结构将数据结构分为线性（数组、链表、栈、队列）和非线性（树、图、堆）两种。哈希表的实现可能同时包含线性和非线性结构。</li>
@ -3440,7 +3455,7 @@
<li>ASCII 码是最早出现的英文字符集，长度为 1 字节，共收录 127 个字符。GBK 字符集是常用的中文字符集，共收录两万多个汉字。Unicode 致力于提供一个完整的字符集标准，收录世界内各种语言的字符，从而解决由于字符编码方法不一致而导致的乱码问题。</li>
<li>UTF-8 是最受欢迎的 Unicode 编码方法，通用性非常好。它是一种变长的编码方法，具有很好的扩展性，有效提升了存储空间的使用效率。UTF-16 和 UTF-32 是等长的编码方法。在编码中文时，UTF-16 比 UTF-8 的占用空间更小。Java 和 C# 等编程语言默认使用 UTF-16 编码。</li>
</ul>
<h2 id="351-q-a">3.5.1 &nbsp; Q &amp; A<a class="headerlink" href="#351-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">为什么哈希表同时包含线性数据结构和非线性数据结构？</p>
<p>哈希表底层是数组，而为了解决哈希冲突，我们可能会使用“链式地址”（后续哈希表章节会讲）。在拉链法中，数组中每个地址（桶）指向一个链表；当这个链表长度超过一定阈值时，又可能被转化为树（通常为红黑树）。因此，哈希表可能同时包含线性（数组、链表）和非线性（树）数据结构。</p>

2
chapter_divide_and_conquer/hanota_problem/index.html
View File

@ -3879,7 +3879,7 @@
<div class="admonition quote">
<p class="admonition-title">Quote</p>
<p>汉诺塔问题源自一种古老的传说故事。在古印度的一个寺庙里，僧侣们有三根高大的钻石柱子，以及 <span class="arithmatex">\(64\)</span> 个大小不一的金圆盘。僧侣们不断地移动原盘，他们相信在最后一个圆盘被正确放置的那一刻，这个世界就会结束。</p>
<p>然而根据以上分析，即使僧侣们每秒钟移动一次，总共需要大约 <span class="arithmatex">\(2^{64} \approx 1.84×10^{19}\)</span> 秒，合约 <span class="arithmatex">\(5850\)</span> 亿年，远远超过了现在对宇宙年龄的估计。所以，倘若这个传说是真的，我们应该不需要担心世界末日的到来。</p>
<p>然而，即使僧侣们每秒钟移动一次，总共需要大约 <span class="arithmatex">\(2^{64} \approx 1.84×10^{19}\)</span> 秒，合约 <span class="arithmatex">\(5850\)</span> 亿年，远远超过了现在对宇宙年龄的估计。所以，倘若这个传说是真的，我们应该不需要担心世界末日的到来。</p>
</div>

8
chapter_graph/graph_traversal/index.html
View File

@ -3522,12 +3522,8 @@
<h1 id="93">9.3 &nbsp; 图的遍历<a class="headerlink" href="#93" title="Permanent link">&para;</a></h1>
<div class="admonition note">
<p class="admonition-title">图与树的关系</p>
<p>树代表的是“一对多”的关系，而图则具有更高的自由度，可以表示任意的“多对多”关系。因此，我们可以把树看作是图的一种特例。显然，<strong>树的遍历操作也是图的遍历操作的一种特例</strong>，建议你在学习本章节时融会贯通两者的概念与实现方法。</p>
</div>
<p>图和树都是非线性数据结构，都需要使用搜索算法来实现遍历操作。</p>
<p>与树类似，图的遍历方式也可分为两种，即「广度优先遍历 breadth-first traversal」和「深度优先遍历 depth-first traversal」。它们也被称为「广度优先搜索 breadth-first search」和「深度优先搜索 depth-first search」，简称 BFS 和 DFS 。</p>
<p>树代表的是“一对多”的关系，而图则具有更高的自由度，可以表示任意的“多对多”关系。因此，我们可以把树看作是图的一种特例。显然，<strong>树的遍历操作也是图的遍历操作的一种特例</strong>。</p>
<p>图和树都都需要应用搜索算法来实现遍历操作。图的遍历方式可分为两种：「广度优先遍历 breadth-first traversal」和「深度优先遍历 depth-first traversal」。它们也常被称为「广度优先搜索 breadth-first search」和「深度优先搜索 depth-first search」，简称 BFS 和 DFS 。</p>
<h2 id="931">9.3.1 &nbsp; 广度优先遍历<a class="headerlink" href="#931" title="Permanent link">&para;</a></h2>
<p><strong>广度优先遍历是一种由近及远的遍历方式，从某个节点出发，始终优先访问距离最近的顶点，并一层层向外扩张</strong>。如图 9-9 所示，从左上角顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接顶点，以此类推，直至所有顶点访问完毕。</p>
<p><img alt="图的广度优先遍历" src="../graph_traversal.assets/graph_bfs.png" /></p>

25
chapter_graph/summary/index.html
View File

@ -1805,8 +1805,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#941-q-a" class="md-nav__link">
9.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#941-q-a" class="md-nav__link">
9.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,6 +3442,7 @@
<h1 id="94">9.4 &nbsp; 小结<a class="headerlink" href="#94" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>图由顶点和边组成，可以被表示为一组顶点和一组边构成的集合。</li>
<li>相较于线性关系（链表）和分治关系（树），网络关系（图）具有更高的自由度，因而更为复杂。</li>
@ -3441,7 +3456,7 @@
<li>图的广度优先遍历是一种由近及远、层层扩张的搜索方式，通常借助队列实现。</li>
<li>图的深度优先遍历是一种优先走到底、无路可走时再回溯的搜索方式，常基于递归来实现。</li>
</ul>
<h2 id="941-q-a">9.4.1 &nbsp; Q &amp; A<a class="headerlink" href="#941-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">路径的定义是顶点序列还是边序列？</p>
<p>维基百科上不同语言版本的定义不一致：英文版是“路径是一个边序列”，而中文版是“路径是一个顶点序列”。以下是英文版原文：In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.

6
chapter_greedy/greedy_algorithm/index.html
View File

@ -3698,7 +3698,7 @@
<p>例如零钱兑换问题，我们虽然能够容易地举出反例，对贪心选择性质进行证伪，但证实的难度较大。如果问：<strong>满足什么条件的硬币组合可以使用贪心算法求解</strong>？我们往往只能凭借直觉或举例子来给出一个模棱两可的答案，而难以给出严谨的数学证明。</p>
<div class="admonition quote">
<p class="admonition-title">Quote</p>
<p>有一篇论文专门讨论了该问题。作者给出了一个 <span class="arithmatex">\(O(n^3)\)</span> 时间复杂度的算法，用于判断一个硬币组合是否可以使用贪心算法找出任何金额的最优解。</p>
<p>有一篇论文给出了一个 <span class="arithmatex">\(O(n^3)\)</span> 时间复杂度的算法，用于判断一个硬币组合是否可以使用贪心算法找出任何金额的最优解。</p>
<p>Pearson, David. A polynomial-time algorithm for the change-making problem. Operations Research Letters 33.3 (2005): 231-234.</p>
</div>
<h2 id="1513">15.1.3 &nbsp; 贪心解题步骤<a class="headerlink" href="#1513" title="Permanent link">&para;</a></h2>
@ -3717,14 +3717,14 @@
<p>然而，正确性证明也很可能不是一件易事。如若没有头绪，我们通常会选择面向测试用例进行 Debug ，一步步修改与验证贪心策略。</p>
<h2 id="1514">15.1.4 &nbsp; 贪心典型例题<a class="headerlink" href="#1514" title="Permanent link">&para;</a></h2>
<p>贪心算法常常应用在满足贪心选择性质和最优子结构的优化问题中，以下列举了一些典型的贪心算法问题。</p>
<ol>
<ul>
<li><strong>硬币找零问题</strong>：在某些硬币组合下，贪心算法总是可以得到最优解。</li>
<li><strong>区间调度问题</strong>：假设你有一些任务，每个任务在一段时间内进行，你的目标是完成尽可能多的任务。如果每次都选择结束时间最早的任务，那么贪心算法就可以得到最优解。</li>
<li><strong>分数背包问题</strong>：给定一组物品和一个载重量，你的目标是选择一组物品，使得总重量不超过载重量，且总价值最大。如果每次都选择性价比最高（价值 / 重量）的物品，那么贪心算法在一些情况下可以得到最优解。</li>
<li><strong>股票买卖问题</strong>：给定一组股票的历史价格，你可以进行多次买卖，但如果你已经持有股票，那么在卖出之前不能再买，目标是获取最大利润。</li>
<li><strong>霍夫曼编码</strong>：霍夫曼编码是一种用于无损数据压缩的贪心算法。通过构建霍夫曼树，每次选择出现频率最小的两个节点合并，最后得到的霍夫曼树的带权路径长度（即编码长度）最小。</li>
<li><strong>Dijkstra 算法</strong>：它是一种解决给定源顶点到其余各顶点的最短路径问题的贪心算法。</li>
</ol>
</ul>

4
chapter_greedy/max_product_cutting_problem/index.html
View File

@ -3705,8 +3705,8 @@ n = 3 a + b
<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>
<li><strong>切分方案不包含 <span class="arithmatex">\(1\)</span></strong> :假设最优切分方案中存在一个因子 <span class="arithmatex">\(1\)</span> ，那么它一定可以合并入另外一个因子中，以获取更大乘积。这与假设矛盾。</li>
<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>
<li><strong>切分方案不包含 <span class="arithmatex">\(1\)</span></strong> ：假设最优切分方案中存在一个因子 <span class="arithmatex">\(1\)</span> ，那么它一定可以合并入另外一个因子中，以获取更大乘积。这与假设矛盾。</li>
<li><strong>切分方案最多包含两个 <span class="arithmatex">\(2\)</span></strong> ：假设最优切分方案中包含三个 <span class="arithmatex">\(2\)</span> ，那么一定可以替换为两个 <span class="arithmatex">\(3\)</span> ，乘积更大。这与假设矛盾。</li>
</ol>

185
chapter_hashing/hash_collision/index.html
View File

@ -3497,7 +3497,7 @@
<h1 id="62">6.2 &nbsp; 哈希冲突<a class="headerlink" href="#62" title="Permanent link">&para;</a></h1>
<p>上节提到，<strong>通常情况下哈希函数的输入空间远大于输出空间</strong>，因此理论上哈希冲突是不可避免的。比如，输入空间为全体整数，输出空间为数组容量大小，则必然有多个整数映射至同一数组索引。</p>
<p>哈希冲突会导致查询结果错误，严重影响哈希表的可用性。为解决该问题，我们可以每当遇到哈希冲突时就进行哈希表扩容，直至冲突消失为止。此方法简单粗暴且有效，但效率太低，因为哈希表扩容需要进行大量的数据搬运与哈希值计算。为了提升效率，我们可以采用以下思路。</p>
<p>哈希冲突会导致查询结果错误，严重影响哈希表的可用性。为解决该问题，我们可以每当遇到哈希冲突时就进行哈希表扩容，直至冲突消失为止。此方法简单粗暴且有效，但效率太低，因为哈希表扩容需要进行大量的数据搬运与哈希值计算。为了提升效率，我们可以采用以下策略。</p>
<ol>
<li>改良哈希表数据结构，<strong>使得哈希表可以在存在哈希冲突时正常工作</strong>。</li>
<li>仅在必要时，即当哈希冲突比较严重时，才执行扩容操作。</li>
@ -3654,94 +3654,104 @@
<a id="__codelineno-1-13" name="__codelineno-1-13" href="#__codelineno-1-13"></a><span class="w"> </span><span class="n">buckets</span><span class="p">.</span><span class="n">resize</span><span class="p">(</span><span class="n">capacity</span><span class="p">);</span>
<a id="__codelineno-1-14" name="__codelineno-1-14" href="#__codelineno-1-14"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-15" name="__codelineno-1-15" href="#__codelineno-1-15"></a>
<a id="__codelineno-1-16" name="__codelineno-1-16" href="#__codelineno-1-16"></a><span class="w"> </span><span class="cm">/* 哈希函数 */</span>
<a id="__codelineno-1-17" name="__codelineno-1-17" href="#__codelineno-1-17"></a><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">hashFunc</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-18" name="__codelineno-1-18" href="#__codelineno-1-18"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="n">capacity</span><span class="p">;</span>
<a id="__codelineno-1-19" name="__codelineno-1-19" href="#__codelineno-1-19"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-20" name="__codelineno-1-20" href="#__codelineno-1-20"></a>
<a id="__codelineno-1-21" name="__codelineno-1-21" href="#__codelineno-1-21"></a><span class="w"> </span><span class="cm">/* 负载因子 */</span>
<a id="__codelineno-1-22" name="__codelineno-1-22" href="#__codelineno-1-22"></a><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">loadFactor</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-23" name="__codelineno-1-23" href="#__codelineno-1-23"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">(</span><span class="kt">double</span><span class="p">)</span><span class="n">size</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="p">(</span><span class="kt">double</span><span class="p">)</span><span class="n">capacity</span><span class="p">;</span>
<a id="__codelineno-1-16" name="__codelineno-1-16" href="#__codelineno-1-16"></a><span class="w"> </span><span class="cm">/* 析构方法 */</span>
<a id="__codelineno-1-17" name="__codelineno-1-17" href="#__codelineno-1-17"></a><span class="w"> </span><span class="o">~</span><span class="n">HashMapChaining</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-18" name="__codelineno-1-18" href="#__codelineno-1-18"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="k">auto</span><span class="w"> </span><span class="o">&amp;</span><span class="n">bucket</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">buckets</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-19" name="__codelineno-1-19" href="#__codelineno-1-19"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">bucket</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-20" name="__codelineno-1-20" href="#__codelineno-1-20"></a><span class="w"> </span><span class="c1">// 释放内存</span>
<a id="__codelineno-1-21" name="__codelineno-1-21" href="#__codelineno-1-21"></a><span class="w"> </span><span class="k">delete</span><span class="w"> </span><span class="n">pair</span><span class="p">;</span>
<a id="__codelineno-1-22" name="__codelineno-1-22" href="#__codelineno-1-22"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-23" name="__codelineno-1-23" href="#__codelineno-1-23"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-24" name="__codelineno-1-24" href="#__codelineno-1-24"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-25" name="__codelineno-1-25" href="#__codelineno-1-25"></a>
<a id="__codelineno-1-26" name="__codelineno-1-26" href="#__codelineno-1-26"></a><span class="w"> </span><span class="cm">/* 查询操作 */</span>
<a id="__codelineno-1-27" name="__codelineno-1-27" href="#__codelineno-1-27"></a><span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="n">get</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-28" name="__codelineno-1-28" href="#__codelineno-1-28"></a><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hashFunc</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
<a id="__codelineno-1-29" name="__codelineno-1-29" href="#__codelineno-1-29"></a><span class="w"> </span><span class="c1">// 遍历桶，若找到 key 则返回对应 val</span>
<a id="__codelineno-1-30" name="__codelineno-1-30" href="#__codelineno-1-30"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">])</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-31" name="__codelineno-1-31" href="#__codelineno-1-31"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-32" name="__codelineno-1-32" href="#__codelineno-1-32"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">val</span><span class="p">;</span>
<a id="__codelineno-1-33" name="__codelineno-1-33" href="#__codelineno-1-33"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-34" name="__codelineno-1-34" href="#__codelineno-1-34"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-35" name="__codelineno-1-35" href="#__codelineno-1-35"></a><span class="w"> </span><span class="c1">// 若未找到 key 则返回 nullptr</span>
<a id="__codelineno-1-36" name="__codelineno-1-36" href="#__codelineno-1-36"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="k">nullptr</span><span class="p">;</span>
<a id="__codelineno-1-37" name="__codelineno-1-37" href="#__codelineno-1-37"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-38" name="__codelineno-1-38" href="#__codelineno-1-38"></a>
<a id="__codelineno-1-39" name="__codelineno-1-39" href="#__codelineno-1-39"></a><span class="w"> </span><span class="cm">/* 添加操作 */</span>
<a id="__codelineno-1-40" name="__codelineno-1-40" href="#__codelineno-1-40"></a><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="n">val</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-41" name="__codelineno-1-41" href="#__codelineno-1-41"></a><span class="w"> </span><span class="c1">// 当负载因子超过阈值时，执行扩容</span>
<a id="__codelineno-1-42" name="__codelineno-1-42" href="#__codelineno-1-42"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">loadFactor</span><span class="p">()</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">loadThres</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-43" name="__codelineno-1-43" href="#__codelineno-1-43"></a><span class="w"> </span><span class="n">extend</span><span class="p">();</span>
<a id="__codelineno-1-26" name="__codelineno-1-26" href="#__codelineno-1-26"></a><span class="w"> </span><span class="cm">/* 哈希函数 */</span>
<a id="__codelineno-1-27" name="__codelineno-1-27" href="#__codelineno-1-27"></a><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">hashFunc</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-28" name="__codelineno-1-28" href="#__codelineno-1-28"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="n">capacity</span><span class="p">;</span>
<a id="__codelineno-1-29" name="__codelineno-1-29" href="#__codelineno-1-29"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-30" name="__codelineno-1-30" href="#__codelineno-1-30"></a>
<a id="__codelineno-1-31" name="__codelineno-1-31" href="#__codelineno-1-31"></a><span class="w"> </span><span class="cm">/* 负载因子 */</span>
<a id="__codelineno-1-32" name="__codelineno-1-32" href="#__codelineno-1-32"></a><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">loadFactor</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-33" name="__codelineno-1-33" href="#__codelineno-1-33"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">(</span><span class="kt">double</span><span class="p">)</span><span class="n">size</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="p">(</span><span class="kt">double</span><span class="p">)</span><span class="n">capacity</span><span class="p">;</span>
<a id="__codelineno-1-34" name="__codelineno-1-34" href="#__codelineno-1-34"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-35" name="__codelineno-1-35" href="#__codelineno-1-35"></a>
<a id="__codelineno-1-36" name="__codelineno-1-36" href="#__codelineno-1-36"></a><span class="w"> </span><span class="cm">/* 查询操作 */</span>
<a id="__codelineno-1-37" name="__codelineno-1-37" href="#__codelineno-1-37"></a><span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="n">get</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-38" name="__codelineno-1-38" href="#__codelineno-1-38"></a><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hashFunc</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
<a id="__codelineno-1-39" name="__codelineno-1-39" href="#__codelineno-1-39"></a><span class="w"> </span><span class="c1">// 遍历桶，若找到 key 则返回对应 val</span>
<a id="__codelineno-1-40" name="__codelineno-1-40" href="#__codelineno-1-40"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">])</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-41" name="__codelineno-1-41" href="#__codelineno-1-41"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-42" name="__codelineno-1-42" href="#__codelineno-1-42"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">val</span><span class="p">;</span>
<a id="__codelineno-1-43" name="__codelineno-1-43" href="#__codelineno-1-43"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-44" name="__codelineno-1-44" href="#__codelineno-1-44"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-45" name="__codelineno-1-45" href="#__codelineno-1-45"></a><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hashFunc</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
<a id="__codelineno-1-46" name="__codelineno-1-46" href="#__codelineno-1-46"></a><span class="w"> </span><span class="c1">// 遍历桶，若遇到指定 key ，则更新对应 val 并返回</span>
<a id="__codelineno-1-47" name="__codelineno-1-47" href="#__codelineno-1-47"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">])</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-48" name="__codelineno-1-48" href="#__codelineno-1-48"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-49" name="__codelineno-1-49" href="#__codelineno-1-49"></a><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">val</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">val</span><span class="p">;</span>
<a id="__codelineno-1-50" name="__codelineno-1-50" href="#__codelineno-1-50"></a><span class="w"> </span><span class="k">return</span><span class="p">;</span>
<a id="__codelineno-1-51" name="__codelineno-1-51" href="#__codelineno-1-51"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-52" name="__codelineno-1-52" href="#__codelineno-1-52"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-53" name="__codelineno-1-53" href="#__codelineno-1-53"></a><span class="w"> </span><span class="c1">// 若无该 key ，则将键值对添加至尾部</span>
<a id="__codelineno-1-54" name="__codelineno-1-54" href="#__codelineno-1-54"></a><span class="w"> </span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">].</span><span class="n">push_back</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="n">Pair</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">val</span><span class="p">));</span>
<a id="__codelineno-1-55" name="__codelineno-1-55" href="#__codelineno-1-55"></a><span class="w"> </span><span class="n">size</span><span class="o">++</span><span class="p">;</span>
<a id="__codelineno-1-56" name="__codelineno-1-56" href="#__codelineno-1-56"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-57" name="__codelineno-1-57" href="#__codelineno-1-57"></a>
<a id="__codelineno-1-58" name="__codelineno-1-58" href="#__codelineno-1-58"></a><span class="w"> </span><span class="cm">/* 删除操作 */</span>
<a id="__codelineno-1-59" name="__codelineno-1-59" href="#__codelineno-1-59"></a><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">remove</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-60" name="__codelineno-1-60" href="#__codelineno-1-60"></a><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hashFunc</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
<a id="__codelineno-1-61" name="__codelineno-1-61" href="#__codelineno-1-61"></a><span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="o">&amp;</span><span class="n">bucket</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
<a id="__codelineno-1-62" name="__codelineno-1-62" href="#__codelineno-1-62"></a><span class="w"> </span><span class="c1">// 遍历桶，从中删除键值对</span>
<a id="__codelineno-1-63" name="__codelineno-1-63" href="#__codelineno-1-63"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">bucket</span><span class="p">.</span><span class="n">size</span><span class="p">();</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-64" name="__codelineno-1-64" href="#__codelineno-1-64"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">bucket</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-&gt;</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-65" name="__codelineno-1-65" href="#__codelineno-1-65"></a><span class="w"> </span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">tmp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bucket</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
<a id="__codelineno-1-66" name="__codelineno-1-66" href="#__codelineno-1-66"></a><span class="w"> </span><span class="n">bucket</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">bucket</span><span class="p">.</span><span class="n">begin</span><span class="p">()</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">i</span><span class="p">);</span><span class="w"> </span><span class="c1">// 从中删除键值对</span>
<a id="__codelineno-1-67" name="__codelineno-1-67" href="#__codelineno-1-67"></a><span class="w"> </span><span class="k">delete</span><span class="w"> </span><span class="n">tmp</span><span class="p">;</span><span class="w"> </span><span class="c1">// 释放内存</span>
<a id="__codelineno-1-68" name="__codelineno-1-68" href="#__codelineno-1-68"></a><span class="w"> </span><span class="n">size</span><span class="o">--</span><span class="p">;</span>
<a id="__codelineno-1-69" name="__codelineno-1-69" href="#__codelineno-1-69"></a><span class="w"> </span><span class="k">return</span><span class="p">;</span>
<a id="__codelineno-1-70" name="__codelineno-1-70" href="#__codelineno-1-70"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-71" name="__codelineno-1-71" href="#__codelineno-1-71"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-72" name="__codelineno-1-72" href="#__codelineno-1-72"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-73" name="__codelineno-1-73" href="#__codelineno-1-73"></a>
<a id="__codelineno-1-74" name="__codelineno-1-74" href="#__codelineno-1-74"></a><span class="w"> </span><span class="cm">/* 扩容哈希表 */</span>
<a id="__codelineno-1-75" name="__codelineno-1-75" href="#__codelineno-1-75"></a><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">extend</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-76" name="__codelineno-1-76" href="#__codelineno-1-76"></a><span class="w"> </span><span class="c1">// 暂存原哈希表</span>
<a id="__codelineno-1-77" name="__codelineno-1-77" href="#__codelineno-1-77"></a><span class="w"> </span><span class="n">vector</span><span class="o">&lt;</span><span class="n">vector</span><span class="o">&lt;</span><span class="n">Pair</span><span class="w"> </span><span class="o">*&gt;&gt;</span><span class="w"> </span><span class="n">bucketsTmp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buckets</span><span class="p">;</span>
<a id="__codelineno-1-78" name="__codelineno-1-78" href="#__codelineno-1-78"></a><span class="w"> </span><span class="c1">// 初始化扩容后的新哈希表</span>
<a id="__codelineno-1-79" name="__codelineno-1-79" href="#__codelineno-1-79"></a><span class="w"> </span><span class="n">capacity</span><span class="w"> </span><span class="o">*=</span><span class="w"> </span><span class="n">extendRatio</span><span class="p">;</span>
<a id="__codelineno-1-80" name="__codelineno-1-80" href="#__codelineno-1-80"></a><span class="w"> </span><span class="n">buckets</span><span class="p">.</span><span class="n">clear</span><span class="p">();</span>
<a id="__codelineno-1-81" name="__codelineno-1-81" href="#__codelineno-1-81"></a><span class="w"> </span><span class="n">buckets</span><span class="p">.</span><span class="n">resize</span><span class="p">(</span><span class="n">capacity</span><span class="p">);</span>
<a id="__codelineno-1-82" name="__codelineno-1-82" href="#__codelineno-1-82"></a><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<a id="__codelineno-1-83" name="__codelineno-1-83" href="#__codelineno-1-83"></a><span class="w"> </span><span class="c1">// 将键值对从原哈希表搬运至新哈希表</span>
<a id="__codelineno-1-84" name="__codelineno-1-84" href="#__codelineno-1-84"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="k">auto</span><span class="w"> </span><span class="o">&amp;</span><span class="n">bucket</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">bucketsTmp</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-85" name="__codelineno-1-85" href="#__codelineno-1-85"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">bucket</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-86" name="__codelineno-1-86" href="#__codelineno-1-86"></a><span class="w"> </span><span class="n">put</span><span class="p">(</span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">val</span><span class="p">);</span>
<a id="__codelineno-1-87" name="__codelineno-1-87" href="#__codelineno-1-87"></a><span class="w"> </span><span class="c1">// 释放内存</span>
<a id="__codelineno-1-88" name="__codelineno-1-88" href="#__codelineno-1-88"></a><span class="w"> </span><span class="k">delete</span><span class="w"> </span><span class="n">pair</span><span class="p">;</span>
<a id="__codelineno-1-89" name="__codelineno-1-89" href="#__codelineno-1-89"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-90" name="__codelineno-1-90" href="#__codelineno-1-90"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-91" name="__codelineno-1-91" href="#__codelineno-1-91"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-92" name="__codelineno-1-92" href="#__codelineno-1-92"></a>
<a id="__codelineno-1-93" name="__codelineno-1-93" href="#__codelineno-1-93"></a><span class="w"> </span><span class="cm">/* 打印哈希表 */</span>
<a id="__codelineno-1-94" name="__codelineno-1-94" href="#__codelineno-1-94"></a><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">print</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-95" name="__codelineno-1-95" href="#__codelineno-1-95"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="k">auto</span><span class="w"> </span><span class="o">&amp;</span><span class="n">bucket</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">buckets</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-96" name="__codelineno-1-96" href="#__codelineno-1-96"></a><span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;[&quot;</span><span class="p">;</span>
<a id="__codelineno-1-97" name="__codelineno-1-97" href="#__codelineno-1-97"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">bucket</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-98" name="__codelineno-1-98" href="#__codelineno-1-98"></a><span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">key</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot; -&gt; &quot;</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">val</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;, &quot;</span><span class="p">;</span>
<a id="__codelineno-1-45" name="__codelineno-1-45" href="#__codelineno-1-45"></a><span class="w"> </span><span class="c1">// 若未找到 key 则返回 nullptr</span>
<a id="__codelineno-1-46" name="__codelineno-1-46" href="#__codelineno-1-46"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="k">nullptr</span><span class="p">;</span>
<a id="__codelineno-1-47" name="__codelineno-1-47" href="#__codelineno-1-47"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-48" name="__codelineno-1-48" href="#__codelineno-1-48"></a>
<a id="__codelineno-1-49" name="__codelineno-1-49" href="#__codelineno-1-49"></a><span class="w"> </span><span class="cm">/* 添加操作 */</span>
<a id="__codelineno-1-50" name="__codelineno-1-50" href="#__codelineno-1-50"></a><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="n">val</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-51" name="__codelineno-1-51" href="#__codelineno-1-51"></a><span class="w"> </span><span class="c1">// 当负载因子超过阈值时，执行扩容</span>
<a id="__codelineno-1-52" name="__codelineno-1-52" href="#__codelineno-1-52"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">loadFactor</span><span class="p">()</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">loadThres</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-53" name="__codelineno-1-53" href="#__codelineno-1-53"></a><span class="w"> </span><span class="n">extend</span><span class="p">();</span>
<a id="__codelineno-1-54" name="__codelineno-1-54" href="#__codelineno-1-54"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-55" name="__codelineno-1-55" href="#__codelineno-1-55"></a><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hashFunc</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
<a id="__codelineno-1-56" name="__codelineno-1-56" href="#__codelineno-1-56"></a><span class="w"> </span><span class="c1">// 遍历桶，若遇到指定 key ，则更新对应 val 并返回</span>
<a id="__codelineno-1-57" name="__codelineno-1-57" href="#__codelineno-1-57"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">])</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-58" name="__codelineno-1-58" href="#__codelineno-1-58"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-59" name="__codelineno-1-59" href="#__codelineno-1-59"></a><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">val</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">val</span><span class="p">;</span>
<a id="__codelineno-1-60" name="__codelineno-1-60" href="#__codelineno-1-60"></a><span class="w"> </span><span class="k">return</span><span class="p">;</span>
<a id="__codelineno-1-61" name="__codelineno-1-61" href="#__codelineno-1-61"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-62" name="__codelineno-1-62" href="#__codelineno-1-62"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-63" name="__codelineno-1-63" href="#__codelineno-1-63"></a><span class="w"> </span><span class="c1">// 若无该 key ，则将键值对添加至尾部</span>
<a id="__codelineno-1-64" name="__codelineno-1-64" href="#__codelineno-1-64"></a><span class="w"> </span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">].</span><span class="n">push_back</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="n">Pair</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">val</span><span class="p">));</span>
<a id="__codelineno-1-65" name="__codelineno-1-65" href="#__codelineno-1-65"></a><span class="w"> </span><span class="n">size</span><span class="o">++</span><span class="p">;</span>
<a id="__codelineno-1-66" name="__codelineno-1-66" href="#__codelineno-1-66"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-67" name="__codelineno-1-67" href="#__codelineno-1-67"></a>
<a id="__codelineno-1-68" name="__codelineno-1-68" href="#__codelineno-1-68"></a><span class="w"> </span><span class="cm">/* 删除操作 */</span>
<a id="__codelineno-1-69" name="__codelineno-1-69" href="#__codelineno-1-69"></a><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">remove</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-70" name="__codelineno-1-70" href="#__codelineno-1-70"></a><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hashFunc</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
<a id="__codelineno-1-71" name="__codelineno-1-71" href="#__codelineno-1-71"></a><span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="o">&amp;</span><span class="n">bucket</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
<a id="__codelineno-1-72" name="__codelineno-1-72" href="#__codelineno-1-72"></a><span class="w"> </span><span class="c1">// 遍历桶，从中删除键值对</span>
<a id="__codelineno-1-73" name="__codelineno-1-73" href="#__codelineno-1-73"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">bucket</span><span class="p">.</span><span class="n">size</span><span class="p">();</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-74" name="__codelineno-1-74" href="#__codelineno-1-74"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">bucket</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-&gt;</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-75" name="__codelineno-1-75" href="#__codelineno-1-75"></a><span class="w"> </span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">tmp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bucket</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
<a id="__codelineno-1-76" name="__codelineno-1-76" href="#__codelineno-1-76"></a><span class="w"> </span><span class="n">bucket</span><span class="p">.</span><span class="n">erase</span><span class="p">(</span><span class="n">bucket</span><span class="p">.</span><span class="n">begin</span><span class="p">()</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">i</span><span class="p">);</span><span class="w"> </span><span class="c1">// 从中删除键值对</span>
<a id="__codelineno-1-77" name="__codelineno-1-77" href="#__codelineno-1-77"></a><span class="w"> </span><span class="k">delete</span><span class="w"> </span><span class="n">tmp</span><span class="p">;</span><span class="w"> </span><span class="c1">// 释放内存</span>
<a id="__codelineno-1-78" name="__codelineno-1-78" href="#__codelineno-1-78"></a><span class="w"> </span><span class="n">size</span><span class="o">--</span><span class="p">;</span>
<a id="__codelineno-1-79" name="__codelineno-1-79" href="#__codelineno-1-79"></a><span class="w"> </span><span class="k">return</span><span class="p">;</span>
<a id="__codelineno-1-80" name="__codelineno-1-80" href="#__codelineno-1-80"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-81" name="__codelineno-1-81" href="#__codelineno-1-81"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-82" name="__codelineno-1-82" href="#__codelineno-1-82"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-83" name="__codelineno-1-83" href="#__codelineno-1-83"></a>
<a id="__codelineno-1-84" name="__codelineno-1-84" href="#__codelineno-1-84"></a><span class="w"> </span><span class="cm">/* 扩容哈希表 */</span>
<a id="__codelineno-1-85" name="__codelineno-1-85" href="#__codelineno-1-85"></a><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">extend</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-86" name="__codelineno-1-86" href="#__codelineno-1-86"></a><span class="w"> </span><span class="c1">// 暂存原哈希表</span>
<a id="__codelineno-1-87" name="__codelineno-1-87" href="#__codelineno-1-87"></a><span class="w"> </span><span class="n">vector</span><span class="o">&lt;</span><span class="n">vector</span><span class="o">&lt;</span><span class="n">Pair</span><span class="w"> </span><span class="o">*&gt;&gt;</span><span class="w"> </span><span class="n">bucketsTmp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buckets</span><span class="p">;</span>
<a id="__codelineno-1-88" name="__codelineno-1-88" href="#__codelineno-1-88"></a><span class="w"> </span><span class="c1">// 初始化扩容后的新哈希表</span>
<a id="__codelineno-1-89" name="__codelineno-1-89" href="#__codelineno-1-89"></a><span class="w"> </span><span class="n">capacity</span><span class="w"> </span><span class="o">*=</span><span class="w"> </span><span class="n">extendRatio</span><span class="p">;</span>
<a id="__codelineno-1-90" name="__codelineno-1-90" href="#__codelineno-1-90"></a><span class="w"> </span><span class="n">buckets</span><span class="p">.</span><span class="n">clear</span><span class="p">();</span>
<a id="__codelineno-1-91" name="__codelineno-1-91" href="#__codelineno-1-91"></a><span class="w"> </span><span class="n">buckets</span><span class="p">.</span><span class="n">resize</span><span class="p">(</span><span class="n">capacity</span><span class="p">);</span>
<a id="__codelineno-1-92" name="__codelineno-1-92" href="#__codelineno-1-92"></a><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<a id="__codelineno-1-93" name="__codelineno-1-93" href="#__codelineno-1-93"></a><span class="w"> </span><span class="c1">// 将键值对从原哈希表搬运至新哈希表</span>
<a id="__codelineno-1-94" name="__codelineno-1-94" href="#__codelineno-1-94"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="k">auto</span><span class="w"> </span><span class="o">&amp;</span><span class="n">bucket</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">bucketsTmp</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-95" name="__codelineno-1-95" href="#__codelineno-1-95"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">bucket</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-96" name="__codelineno-1-96" href="#__codelineno-1-96"></a><span class="w"> </span><span class="n">put</span><span class="p">(</span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">val</span><span class="p">);</span>
<a id="__codelineno-1-97" name="__codelineno-1-97" href="#__codelineno-1-97"></a><span class="w"> </span><span class="c1">// 释放内存</span>
<a id="__codelineno-1-98" name="__codelineno-1-98" href="#__codelineno-1-98"></a><span class="w"> </span><span class="k">delete</span><span class="w"> </span><span class="n">pair</span><span class="p">;</span>
<a id="__codelineno-1-99" name="__codelineno-1-99" href="#__codelineno-1-99"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-100" name="__codelineno-1-100" href="#__codelineno-1-100"></a><span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;]</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">;</span>
<a id="__codelineno-1-101" name="__codelineno-1-101" href="#__codelineno-1-101"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-102" name="__codelineno-1-102" href="#__codelineno-1-102"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-103" name="__codelineno-1-103" href="#__codelineno-1-103"></a><span class="p">};</span>
<a id="__codelineno-1-100" name="__codelineno-1-100" href="#__codelineno-1-100"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-101" name="__codelineno-1-101" href="#__codelineno-1-101"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-102" name="__codelineno-1-102" href="#__codelineno-1-102"></a>
<a id="__codelineno-1-103" name="__codelineno-1-103" href="#__codelineno-1-103"></a><span class="w"> </span><span class="cm">/* 打印哈希表 */</span>
<a id="__codelineno-1-104" name="__codelineno-1-104" href="#__codelineno-1-104"></a><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">print</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-105" name="__codelineno-1-105" href="#__codelineno-1-105"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="k">auto</span><span class="w"> </span><span class="o">&amp;</span><span class="n">bucket</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">buckets</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-106" name="__codelineno-1-106" href="#__codelineno-1-106"></a><span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;[&quot;</span><span class="p">;</span>
<a id="__codelineno-1-107" name="__codelineno-1-107" href="#__codelineno-1-107"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="w"> </span><span class="o">*</span><span class="n">pair</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">bucket</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<a id="__codelineno-1-108" name="__codelineno-1-108" href="#__codelineno-1-108"></a><span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">key</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot; -&gt; &quot;</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">pair</span><span class="o">-&gt;</span><span class="n">val</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;, &quot;</span><span class="p">;</span>
<a id="__codelineno-1-109" name="__codelineno-1-109" href="#__codelineno-1-109"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-110" name="__codelineno-1-110" href="#__codelineno-1-110"></a><span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;]</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">;</span>
<a id="__codelineno-1-111" name="__codelineno-1-111" href="#__codelineno-1-111"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-112" name="__codelineno-1-112" href="#__codelineno-1-112"></a><span class="w"> </span><span class="p">}</span>
<a id="__codelineno-1-113" name="__codelineno-1-113" href="#__codelineno-1-113"></a><span class="p">};</span>
</code></pre></div>
</div>
<div class="tabbed-block">
@ -4615,10 +4625,7 @@
</div>
</div>
</div>
<div class="admonition tip">
<p class="admonition-title">Tip</p>
<p>当链表很长时，查询效率 <span class="arithmatex">\(O(n)\)</span> 很差，<strong>此时可以将链表转换为“AVL 树”或“红黑树”</strong>，从而将查询操作的时间复杂度优化至 <span class="arithmatex">\(O(\log n)\)</span> 。</p>
</div>
<p>值得注意的是，当链表很长时，查询效率 <span class="arithmatex">\(O(n)\)</span> 很差。<strong>此时可以将链表转换为“AVL 树”或“红黑树”</strong>，从而将查询操作的时间复杂度优化至 <span class="arithmatex">\(O(\log n)\)</span> 。</p>
<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">1. &nbsp; 线性探测<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>

25
chapter_hashing/summary/index.html
View File

@ -1320,8 +1320,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#641-q-a" class="md-nav__link">
6.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#641-q-a" class="md-nav__link">
6.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,6 +3442,7 @@
<h1 id="64">6.4 &nbsp; 小结<a class="headerlink" href="#64" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>输入 <code>key</code> ，哈希表能够在 <span class="arithmatex">\(O(1)\)</span> 时间内查询到 <code>value</code> ，效率非常高。</li>
<li>常见的哈希表操作包括查询、添加键值对、删除键值对和遍历哈希表等。</li>
@ -3443,7 +3458,7 @@
<li>常见的哈希算法包括 MD5、SHA-1、SHA-2 和 SHA3 等。MD5 常用于校验文件完整性，SHA-2 常用于安全应用与协议。</li>
<li>编程语言通常会为数据类型提供内置哈希算法，用于计算哈希表中的桶索引。通常情况下，只有不可变对象是可哈希的。</li>
</ul>
<h2 id="641-q-a">6.4.1 &nbsp; Q &amp; A<a class="headerlink" href="#641-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">哈希表的时间复杂度为什么不是 <span class="arithmatex">\(O(n)\)</span> ？</p>
<p>当哈希冲突比较严重时，哈希表的时间复杂度会退化至 <span class="arithmatex">\(O(n)\)</span> 。当哈希函数设计的比较好、容量设置比较合理、冲突比较平均时，时间复杂度是 <span class="arithmatex">\(O(1)\)</span> 。我们使用编程语言内置的哈希表时，通常认为时间复杂度是 <span class="arithmatex">\(O(1)\)</span> 。</p>

2
chapter_heap/heap/index.html
View File

@ -4501,7 +4501,7 @@
</div>
</div>
<h3 id="4">4. &nbsp; 堆顶元素出堆<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
<p>堆顶元素是二叉树的根节点，即列表首元素。如果我们直接从列表中删除首元素，那么二叉树中所有节点的索引都会发生变化，这将使得后续使用堆化修复变得困难。为了尽量减少元素索引的变动，我们采取以下操作步骤。</p>
<p>堆顶元素是二叉树的根节点，即列表首元素。如果我们直接从列表中删除首元素，那么二叉树中所有节点的索引都会发生变化，这将使得后续使用堆化修复变得困难。为了尽量减少元素索引的变动，我们采用以下操作步骤。</p>
<ol>
<li>交换堆顶元素与堆底元素（即交换根节点与最右叶节点）。</li>
<li>交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）。</li>

25
chapter_heap/summary/index.html
View File

@ -1658,8 +1658,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#841-q-a" class="md-nav__link">
8.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#841-q-a" class="md-nav__link">
8.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,6 +3442,7 @@
<h1 id="84">8.4 &nbsp; 小结<a class="headerlink" href="#84" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>堆是一棵完全二叉树，根据成立条件可分为大顶堆和小顶堆。大（小）顶堆的堆顶元素是最大（小）的。</li>
<li>优先队列的定义是具有出队优先级的队列，通常使用堆来实现。</li>
@ -3437,7 +3452,7 @@
<li>输入 <span class="arithmatex">\(n\)</span> 个元素并建堆的时间复杂度可以优化至 <span class="arithmatex">\(O(n)\)</span> ，非常高效。</li>
<li>Top-K 是一个经典算法问题，可以使用堆数据结构高效解决，时间复杂度为 <span class="arithmatex">\(O(n \log k)\)</span> 。</li>
</ul>
<h2 id="841-q-a">8.4.1 &nbsp; Q &amp; A<a class="headerlink" href="#841-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">数据结构的“堆”与内存管理的“堆”是同一个概念吗？</p>
<p>两者不是同一个概念，只是碰巧都叫堆。计算机系统内存中的堆是动态内存分配的一部分，程序在运行时可以使用它来存储数据。程序可以请求一定量的堆内存，用于存储如对象和数组等复杂结构。当这些数据不再需要时，程序需要释放这些内存，以防止内存泄露。相较于栈内存，堆内存的管理和使用需要更谨慎，不恰当的使用可能会导致内存泄露和野指针等问题。</p>

2
chapter_heap/top_k/index.html
View File

@ -3469,7 +3469,7 @@
<div class="admonition tip">
<p class="admonition-title">Tip</p>
<p>当 <span class="arithmatex">\(k = n\)</span> 时，我们可以得到从大到小的序列，等价于“选择排序”算法。</p>
<p>当 <span class="arithmatex">\(k = n\)</span> 时，我们可以得到完整的有序序列，此时等价于“选择排序”算法。</p>
</div>
<h2 id="832">8.3.2 &nbsp; 方法二：排序<a class="headerlink" href="#832" title="Permanent link">&para;</a></h2>
<p>如图 8-7 所示，我们可以先对数组 <code>nums</code> 进行排序，再返回最右边的 <span class="arithmatex">\(k\)</span> 个元素，时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> 。</p>

2
chapter_introduction/what_is_dsa/index.html
View File

@ -3470,7 +3470,7 @@
<li>数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。</li>
<li>提供简洁的数据表示和逻辑信息，以便使得算法高效运行。</li>
</ul>
<p><strong>数据结构设计是一个充满权衡的过程</strong>。如果想要在某方面取得提升，往往需要在另一方面作出妥协。</p>
<p><strong>数据结构设计是一个充满权衡的过程</strong>。如果想要在某方面取得提升，往往需要在另一方面作出妥协。下面举两个例子。</p>
<ul>
<li>链表相较于数组，在数据添加和删除操作上更加便捷，但牺牲了数据访问速度。</li>
<li>图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。</li>

2
chapter_preface/about_the_book/index.html
View File

@ -3487,7 +3487,7 @@
<li>感谢我的女朋友泡泡作为本书的首位读者，从算法小白的角度提出许多宝贵建议，使得本书更适合新手阅读。</li>
<li>感谢腾宝、琦宝、飞宝为本书起了一个富有创意的名字，唤起大家写下第一行代码 "Hello World!" 的美好回忆。</li>
<li>感谢苏潼为本书设计了精美的封面和 LOGO，并在我的强迫症下多次耐心修改。</li>
<li>感谢 @squidfunk 提供的写作排版建议，以及杰出的开源项目 <a href="https://github.com/squidfunk/mkdocs-material/tree/master">Material-for-MkDocs</a> 。</li>
<li>感谢 @squidfunk 提供的写作排版建议，以及他开发的开源文档主题 <a href="https://github.com/squidfunk/mkdocs-material/tree/master">Material-for-MkDocs</a> 。</li>
</ul>
<p>在写作过程中，我阅读了许多关于数据结构与算法的教材和文章。这些作品为本书提供了优秀的范本，确保了本书内容的准确性与品质。在此感谢所有老师和前辈们的杰出贡献！</p>
<p>本书倡导手脑并用的学习方式，在这一点上深受<a href="https://github.com/d2l-ai/d2l-zh">《动手学深度学习》</a>的启发。在此向各位读者强烈推荐这本优秀著作。</p>

6
chapter_searching/binary_search_insertion/index.html
View File

@ -3639,11 +3639,11 @@
<p align="center"> 图 10-5 &nbsp; 线性查找重复元素的插入点 </p>
<p>此方法虽然可用，但其包含线性查找，因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span> 。当数组中存在很多重复的 <code>target</code> 时，该方法效率很低。</p>
<p>现考虑拓展二分查找代码。如图 10-6 所示，整体流程保持不变，每轮先计算中点索引 <span class="arithmatex">\(m\)</span> ，再判断 <code>target</code> 和 <code>nums[m]</code> 大小关系。</p>
<ol>
<p>现考虑拓展二分查找代码。如图 10-6 所示，整体流程保持不变，每轮先计算中点索引 <span class="arithmatex">\(m\)</span> ，再判断 <code>target</code> 和 <code>nums[m]</code> 大小关系，分为以下几种情况。</p>
<ul>
<li>当 <code>nums[m] &lt; target</code> 或 <code>nums[m] &gt; target</code> 时，说明还没有找到 <code>target</code> ，因此采用普通二分查找的缩小区间操作，<strong>从而使指针 <span class="arithmatex">\(i\)</span> 和 <span class="arithmatex">\(j\)</span> 向 <code>target</code> 靠近</strong>。</li>
<li>当 <code>nums[m] == target</code> 时，说明小于 <code>target</code> 的元素在区间 <span class="arithmatex">\([i, m - 1]\)</span> 中，因此采用 <span class="arithmatex">\(j = m - 1\)</span> 来缩小区间，<strong>从而使指针 <span class="arithmatex">\(j\)</span> 向小于 <code>target</code> 的元素靠近</strong>。</li>
</ol>
</ul>
<p>循环完成后，<span class="arithmatex">\(i\)</span> 指向最左边的 <code>target</code> ，<span class="arithmatex">\(j\)</span> 指向首个小于 <code>target</code> 的元素，<strong>因此索引 <span class="arithmatex">\(i\)</span> 就是插入点</strong>。</p>
<div class="tabbed-set tabbed-alternate" data-tabs="2:8"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">&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><label for="__tabbed_2_7">&lt;7&gt;</label><label for="__tabbed_2_8">&lt;8&gt;</label></div>
<div class="tabbed-content">

2
chapter_searching/summary/index.html
View File

@ -3382,7 +3382,7 @@
<li>哈希查找、树查找和二分查找属于高效搜索方法，可在特定数据结构中快速定位目标元素。此类算法效率高，时间复杂度可达 <span class="arithmatex">\(O(\log n)\)</span> 甚至 <span class="arithmatex">\(O(1)\)</span> ，但通常需要借助额外数据结构。</li>
<li>实际中，我们需要对数据体量、搜索性能要求、数据查询和更新频率等因素进行具体分析，从而选择合适的搜索方法。</li>
<li>线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无须范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。</li>
<li>用哈希查找替换线性查找是一种常用的优化运行时间的策略，可将时间复杂度从 <span class="arithmatex">\(O(n)\)</span> 降低至 <span class="arithmatex">\(O(1)\)</span> 。 </li>
<li>用哈希查找替换线性查找是一种常用的优化运行时间的策略，可将时间复杂度从 <span class="arithmatex">\(O(n)\)</span> 降低至 <span class="arithmatex">\(O(1)\)</span> 。</li>
</ul>

5
chapter_sorting/bucket_sort/index.html
View File

@ -3820,11 +3820,8 @@
</div>
</div>
</div>
<div class="admonition question">
<p class="admonition-title">桶排序的适用场景是什么？</p>
<p>桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。</p>
</div>
<h2 id="1182">11.8.2 &nbsp; 算法特性<a class="headerlink" href="#1182" title="Permanent link">&para;</a></h2>
<p>桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。</p>
<ul>
<li><strong>时间复杂度 <span class="arithmatex">\(O(n + k)\)</span></strong> ：假设元素在各个桶内平均分布，那么每个桶内的元素数量为 <span class="arithmatex">\(\frac{n}{k}\)</span> 。假设排序单个桶使用 <span class="arithmatex">\(O(\frac{n}{k} \log\frac{n}{k})\)</span> 时间，则排序所有桶使用 <span class="arithmatex">\(O(n \log\frac{n}{k})\)</span> 时间。<strong>当桶数量 <span class="arithmatex">\(k\)</span> 比较大时，时间复杂度则趋向于 <span class="arithmatex">\(O(n)\)</span></strong> 。合并结果时需要遍历所有桶和元素，花费 <span class="arithmatex">\(O(n + k)\)</span> 时间。</li>
<li><strong>自适应排序</strong>：在最坏情况下，所有数据被分配到一个桶中，且排序该桶使用 <span class="arithmatex">\(O(n^2)\)</span> 时间。</li>

2
chapter_sorting/merge_sort/index.html
View File

@ -3465,7 +3465,7 @@
<p align="center"> 图 11-10 &nbsp; 归并排序的划分与合并阶段 </p>
<h2 id="1161">11.6.1 &nbsp; 算法流程<a class="headerlink" href="#1161" title="Permanent link">&para;</a></h2>
<p>如图 11-11 所示，“划分阶段”从顶至底递归地将数组从中点切为两个子数组。</p>
<p>如图 11-11 所示，“划分阶段”从顶至底递归地将数组从中点切分为两个子数组。</p>
<ol>
<li>计算数组中点 <code>mid</code> ，递归划分左子数组（区间 <code>[left, mid]</code> ）和右子数组（区间 <code>[mid + 1, right]</code> ）。</li>
<li>递归执行步骤 <code>1.</code> ，直至子数组区间长度为 1 时，终止递归划分。</li>

25
chapter_sorting/summary/index.html
View File

@ -2313,8 +2313,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#11111-q-a" class="md-nav__link">
11.11.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#11111-q-a" class="md-nav__link">
11.11.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,6 +3442,7 @@
<h1 id="1111">11.11 &nbsp; 小结<a class="headerlink" href="#1111" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>冒泡排序通过交换相邻元素来实现排序。通过添加一个标志位来实现提前返回，我们可以将冒泡排序的最佳时间复杂度优化到 <span class="arithmatex">\(O(n)\)</span> 。</li>
<li>插入排序每轮将未排序区间内的元素插入到已排序区间的正确位置，从而完成排序。虽然插入排序的时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> ，但由于单元操作相对较少，它在小数据量的排序任务中非常受欢迎。</li>
@ -3442,7 +3457,7 @@
<p><img alt="排序算法对比" src="../summary.assets/sorting_algorithms_comparison.png" /></p>
<p align="center"> 图 11-19 &nbsp; 排序算法对比 </p>
<h2 id="11111-q-a">11.11.1 &nbsp; Q &amp; A<a class="headerlink" href="#11111-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">排序算法稳定性在什么情况下是必须的？</p>
<p>在现实中，我们有可能是在对象的某个属性上进行排序。例如，学生有姓名和身高两个属性，我们希望实现一个多级排序/</p>

25
chapter_stack_and_queue/summary/index.html
View File

@ -1173,8 +1173,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#541-q-a" class="md-nav__link">
5.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#541-q-a" class="md-nav__link">
5.4.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,6 +3442,7 @@
<h1 id="54">5.4 &nbsp; 小结<a class="headerlink" href="#54" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>栈是一种遵循先入后出原则的数据结构，可通过数组或链表来实现。</li>
<li>从时间效率角度看，栈的数组实现具有较高的平均效率，但在扩容过程中，单次入栈操作的时间复杂度会降低至 <span class="arithmatex">\(O(n)\)</span> 。相比之下，基于链表实现的栈具有更为稳定的效率表现。</li>
@ -3435,7 +3450,7 @@
<li>队列是一种遵循先入先出原则的数据结构，同样可以通过数组或链表来实现。在时间效率和空间效率的对比上，队列的结论与前述栈的结论相似。</li>
<li>双向队列是一种具有更高自由度的队列，它允许在两端进行元素的添加和删除操作。</li>
</ul>
<h2 id="541-q-a">5.4.1 &nbsp; Q &amp; A<a class="headerlink" href="#541-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">浏览器的前进后退是否是双向链表实现？</p>
<p>浏览器的前进后退功能本质上是“栈”的体现。当用户访问一个新页面时，该页面会被添加到栈顶；当用户点击后退按钮时，该页面会从栈顶弹出。使用双向队列可以方便实现一些额外操作，这个在双向队列章节有提到。</p>

5
chapter_tree/avl_tree/index.html
View File

@ -5904,11 +5904,8 @@
<ul>
<li>组织和存储大型数据，适用于高频查找、低频增删的场景。</li>
<li>用于构建数据库中的索引系统。</li>
<li>红黑树在许多应用中比 AVL 树更受欢迎。这是因为红黑树的平衡条件相对宽松，在红黑树中插入与删除节点所需的旋转操作相对较少，其节点增删操作的平均效率更高。</li>
</ul>
<div class="admonition question">
<p class="admonition-title">为什么红黑树比 AVL 树更受欢迎？</p>
<p>红黑树的平衡条件相对宽松，因此在红黑树中插入与删除节点所需的旋转操作相对较少，在节点增删操作上的平均效率高于 AVL 树。</p>
</div>

6
chapter_tree/binary_search_tree/index.html
View File

@ -4206,11 +4206,9 @@
</div>
<p>与查找节点相同，插入节点使用 <span class="arithmatex">\(O(\log n)\)</span> 时间。</p>
<h3 id="3">3. &nbsp; 删除节点<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
<p>先在二叉树中查找到目标节点，再将其从二叉树中删除。</p>
<p>与插入节点类似，我们需要保证在删除操作完成后，二叉搜索树的“左子树 &lt; 根节点 &lt; 右子树”的性质仍然满足。</p>
<ol>
<li>在二叉树中执行查找操作，获取待删除节点。</li>
<li>根据待删除节点的子节点数量（三种情况），执行对应的删除节点操作。</li>
</ol>
<p>因此，我们需要根据目标节点的子节点数量，共分为 0、1 和 2 这三种情况，执行对应的删除节点操作。</p>
<p>如图 7-19 所示，当待删除节点的度为 <span class="arithmatex">\(0\)</span> 时，表示该节点是叶节点，可以直接删除。</p>
<p><img alt="在二叉搜索树中删除节点（度为 0 ）" src="../binary_search_tree.assets/bst_remove_case1.png" /></p>
<p align="center"> 图 7-19 &nbsp; 在二叉搜索树中删除节点（度为 0 ） </p>

2
chapter_tree/binary_tree/index.html
View File

@ -3739,7 +3739,7 @@
<p align="center"> 图 7-2 &nbsp; 二叉树的常用术语 </p>
<div class="admonition tip">
<p class="admonition-title">高度与深度的定义</p>
<p class="admonition-title">Tip</p>
<p>请注意，我们通常将“高度”和“深度”定义为“走过边的数量”，但有些题目或教材可能会将其定义为“走过节点的数量”。在这种情况下，高度和深度都需要加 1 。</p>
</div>
<h2 id="712">7.1.2 &nbsp; 二叉树基本操作<a class="headerlink" href="#712" title="Permanent link">&para;</a></h2>

100
chapter_tree/binary_tree_traversal/index.html
View File

@ -1435,6 +1435,26 @@
7.2.1 &nbsp; 层序遍历
</a>
<nav class="md-nav" aria-label="7.2.1   层序遍历">
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#1" class="md-nav__link">
1. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#2" class="md-nav__link">
2. &nbsp; 复杂度分析
</a>
</li>
</ul>
</nav>
</li>
<li class="md-nav__item">
@ -1442,6 +1462,26 @@
7.2.2 &nbsp; 前序、中序、后序遍历
</a>
<nav class="md-nav" aria-label="7.2.2   前序、中序、后序遍历">
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#1_1" class="md-nav__link">
1. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#2_1" class="md-nav__link">
2. &nbsp; 复杂度分析
</a>
</li>
</ul>
</nav>
</li>
</ul>
@ -3409,6 +3449,26 @@
7.2.1 &nbsp; 层序遍历
</a>
<nav class="md-nav" aria-label="7.2.1   层序遍历">
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#1" class="md-nav__link">
1. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#2" class="md-nav__link">
2. &nbsp; 复杂度分析
</a>
</li>
</ul>
</nav>
</li>
<li class="md-nav__item">
@ -3416,6 +3476,26 @@
7.2.2 &nbsp; 前序、中序、后序遍历
</a>
<nav class="md-nav" aria-label="7.2.2   前序、中序、后序遍历">
<ul class="md-nav__list">
<li class="md-nav__item">
<a href="#1_1" class="md-nav__link">
1. &nbsp; 代码实现
</a>
</li>
<li class="md-nav__item">
<a href="#2_1" class="md-nav__link">
2. &nbsp; 复杂度分析
</a>
</li>
</ul>
</nav>
</li>
</ul>
@ -3450,6 +3530,7 @@
<p><img alt="二叉树的层序遍历" src="../binary_tree_traversal.assets/binary_tree_bfs.png" /></p>
<p align="center"> 图 7-9 &nbsp; 二叉树的层序遍历 </p>
<h3 id="1">1. &nbsp; 代码实现<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<p>广度优先遍历通常借助“队列”来实现。队列遵循“先进先出”的规则，而广度优先遍历则遵循“逐层推进”的规则，两者背后的思想是一致的。</p>
<div class="tabbed-set tabbed-alternate" data-tabs="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">
@ -3733,14 +3814,19 @@
</div>
</div>
</div>
<p><strong>时间复杂度</strong>：所有节点被访问一次，使用 <span class="arithmatex">\(O(n)\)</span> 时间，其中 <span class="arithmatex">\(n\)</span> 为节点数量。</p>
<p><strong>空间复杂度</strong>：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在 <span class="arithmatex">\((n + 1) / 2\)</span> 个节点，占用 <span class="arithmatex">\(O(n)\)</span> 空间。</p>
<h3 id="2">2. &nbsp; 复杂度分析<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
<ul>
<li><strong>时间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> ：所有节点被访问一次，使用 <span class="arithmatex">\(O(n)\)</span> 时间，其中 <span class="arithmatex">\(n\)</span> 为节点数量。</li>
<li><strong>空间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> ：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在 <span class="arithmatex">\((n + 1) / 2\)</span> 个节点，占用 <span class="arithmatex">\(O(n)\)</span> 空间。</li>
</ul>
<h2 id="722">7.2.2 &nbsp; 前序、中序、后序遍历<a class="headerlink" href="#722" title="Permanent link">&para;</a></h2>
<p>相应地，前序、中序和后序遍历都属于「深度优先遍历 depth-first traversal」，它体现了一种“先走到尽头，再回溯继续”的遍历方式。</p>
<p>图 7-10 展示了对二叉树进行深度优先遍历的工作原理。<strong>深度优先遍历就像是绕着整个二叉树的外围“走”一圈</strong>，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。</p>
<p><img alt="二叉搜索树的前、中、后序遍历" src="../binary_tree_traversal.assets/binary_tree_dfs.png" /></p>
<p align="center"> 图 7-10 &nbsp; 二叉搜索树的前、中、后序遍历 </p>
<h3 id="1_1">1. &nbsp; 代码实现<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
<p>深度优先搜索通常基于递归实现：</p>
<div class="tabbed-set tabbed-alternate" data-tabs="2:12"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><input id="__tabbed_2_12" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JS</label><label for="__tabbed_2_6">TS</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label><label for="__tabbed_2_12">Rust</label></div>
<div class="tabbed-content">
<div class="tabbed-block">
@ -4132,11 +4218,9 @@
</div>
</div>
</div>
<p><strong>时间复杂度</strong>：所有节点被访问一次，使用 <span class="arithmatex">\(O(n)\)</span> 时间，其中 <span class="arithmatex">\(n\)</span> 为节点数量。</p>
<p><strong>空间复杂度</strong>：在最差情况下，即树退化为链表时，递归深度达到 <span class="arithmatex">\(n\)</span> ，系统占用 <span class="arithmatex">\(O(n)\)</span> 栈帧空间。</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>我们也可以不使用递归，仅基于迭代实现前、中、后序遍历，有兴趣的同学可以自行实现。</p>
<p>深度优先搜索也可以基于迭代实现，有兴趣的同学可以自行研究。</p>
</div>
<p>图 7-11 展示了前序遍历二叉树的递归过程，其可分为“递”和“归”两个逆向的部分。</p>
<ol>
@ -4182,6 +4266,12 @@
</div>
<p align="center"> 图 7-11 &nbsp; 前序遍历的递归过程 </p>
<h3 id="2_1">2. &nbsp; 复杂度分析<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
<ul>
<li><strong>时间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> ：所有节点被访问一次，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
<li><strong>空间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> ：在最差情况下，即树退化为链表时，递归深度达到 <span class="arithmatex">\(n\)</span> ，系统占用 <span class="arithmatex">\(O(n)\)</span> 栈帧空间。</li>
</ul>

25
chapter_tree/summary/index.html
View File

@ -1511,8 +1511,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#761-q-a" class="md-nav__link">
7.6.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3398,8 +3405,15 @@
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
<li class="md-nav__item">
<a href="#761-q-a" class="md-nav__link">
7.6.1 &nbsp; Q &amp; A
<a href="#1" class="md-nav__link">
1. &nbsp; 重点回顾
</a>
</li>
<li class="md-nav__item">
<a href="#2-q-a" class="md-nav__link">
2. &nbsp; Q &amp; A
</a>
</li>
@ -3428,6 +3442,7 @@
<h1 id="76">7.6 &nbsp; 小结<a class="headerlink" href="#76" title="Permanent link">&para;</a></h1>
<h3 id="1">1. &nbsp; 重点回顾<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
<ul>
<li>二叉树是一种非线性数据结构，体现“一分为二”的分治逻辑。每个二叉树节点包含一个值以及两个指针，分别指向其左子节点和右子节点。</li>
<li>对于二叉树中的某个节点，其左（右）子节点及其以下形成的树被称为该节点的左（右）子树。</li>
@ -3441,7 +3456,7 @@
<li>AVL 树，也称为平衡二叉搜索树，它通过旋转操作，确保在不断插入和删除节点后，树仍然保持平衡。</li>
<li>AVL 树的旋转操作包括右旋、左旋、先右旋再左旋、先左旋再右旋。在插入或删除节点后，AVL 树会从底向顶执行旋转操作，使树重新恢复平衡。</li>
</ul>
<h2 id="761-q-a">7.6.1 &nbsp; Q &amp; A<a class="headerlink" href="#761-q-a" title="Permanent link">&para;</a></h2>
<h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
<div class="admonition question">
<p class="admonition-title">对于只有一个节点的二叉树，树的高度和根节点的深度都是 <span class="arithmatex">\(0\)</span> 吗？</p>
<p>是的，因为高度和深度通常定义为“走过边的数量”。</p>

2
search/search_index.json
View File

File diff suppressed because one or more lines are too long

204
sitemap.xml
View File

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

BIN
sitemap.xml.gz
View File

Binary file not shown.