xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-25 14:56:28 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

deploy

Browse source
This commit is contained in:
krahets 2023-08-19 19:21:30 +08:00
parent 5884de5246
commit c2642f951c
25 changed files with 163 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
chapter_array_and_linkedlist/linked_list/index.html
View file

@ -4478,6 +4478,8 @@
</div>
<h2 id="422-vs">4.2.2. &nbsp; 数组 VS 链表<a class="headerlink" href="#422-vs" title="Permanent link">&para;</a></h2>
<p>下表总结对比了数组和链表的各项特点与操作效率。由于它们采用两种相反的存储策略，因此各种性质和操作效率也呈现对立的特点。</p>
<p align="center"> 表：数组与链表的效率对比 </p>
<div class="center-table">
<table>
<thead>

9
chapter_array_and_linkedlist/summary/index.html
View file

@ -3452,6 +3452,15 @@
<p>假如把列表元素换成链表节点 <code>n = [n1, n2, n3, n4, n5]</code> ，通常情况下这五个节点对象也是被分散存储在内存各处的。然而，给定一个列表索引，我们仍然可以在 <span class="arithmatex">\(O(1)\)</span> 时间内获取到节点内存地址，从而访问到对应的节点。这是因为数组中存储的是节点的引用，而非节点本身。</p>
<p>与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无需连续的。</p>
</div>
<div class="admonition question">
<p class="admonition-title">C++ STL 里面的 std::list 已经实现了双向链表，但好像一些算法的书上都不怎么直接用这个，是不是有什么局限性呢?</p>
<p>一方面，我们往往更青睐使用数组实现算法，而只有在必要时才使用链表。这是因为：</p>
<ol>
<li>空间开销：由于每个元素需要两个额外的指针（一个用于前一个元素，一个用于后一个元素），所以 <code>std::list</code> 通常比 <code>std::vector</code> 更占用空间。</li>
<li>缓存不友好：由于数据不是连续存放的，<code>std::list</code> 对缓存的利用率较低。一般情况下，<code>std::vector</code> 的性能会更好。</li>
</ol>
<p>另一方面，必要使用链表的情况主要是二叉树和图。栈和队列往往会使用编程语言提供的 <code>stack</code> 和 <code>queue</code> ，而非链表。</p>
</div>

2
chapter_backtracking/backtracking_algorithm/index.html
View file

@ -5010,6 +5010,7 @@
<p>相比基于前序遍历的代码实现，基于回溯算法框架的代码实现虽然显得啰嗦，但通用性更好。实际上，<strong>许多回溯问题都可以在该框架下解决</strong>。我们只需根据具体问题来定义 <code>state</code> 和 <code>choices</code> ，并实现框架中的各个方法即可。</p>
<h2 id="1314">13.1.4. &nbsp; 常用术语<a class="headerlink" href="#1314" title="Permanent link">&para;</a></h2>
<p>为了更清晰地分析算法问题，我们总结一下回溯算法中常用术语的含义，并对照例题三给出对应示例。</p>
<div class="center-table">
<table>
<thead>
<tr>
@ -5051,6 +5052,7 @@
</tr>
</tbody>
</table>
</div>
<div class="admonition tip">
<p class="admonition-title">Tip</p>
<p>问题、解、状态等概念是通用的，在分治、回溯、动态规划、贪心等算法中都有涉及。</p>

2
chapter_backtracking/permutations_problem/index.html
View file

@ -3508,6 +3508,8 @@
<h1 id="132">13.2. &nbsp; 全排列问题<a class="headerlink" href="#132" title="Permanent link">&para;</a></h1>
<p>全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合（如一个数组或字符串）的情况下，找出这个集合中元素的所有可能的排列。</p>
<p>下表列举了几个示例数据，包括输入数组和对应的所有排列。</p>
<p align="center"> 表：数组与链表的效率对比 </p>
<div class="center-table">
<table>
<thead>

2
chapter_computational_complexity/time_complexity/index.html
View file

@ -4368,6 +4368,8 @@ T(n) &amp; = n^2 + n &amp; \text{偷懒统计 (o.O)}
<h3 id="_2">第二步：判断渐近上界<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
<p><strong>时间复杂度由多项式 <span class="arithmatex">\(T(n)\)</span> 中最高阶的项来决定</strong>。这是因为在 <span class="arithmatex">\(n\)</span> 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。</p>
<p>以下表格展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 <span class="arithmatex">\(n\)</span> 趋于无穷大时，这些常数变得无足轻重。</p>
<p align="center"> 表：多项式时间复杂度示例 </p>
<div class="center-table">
<table>
<thead>

2
chapter_data_structure/basic_data_types/index.html
View file

@ -3361,6 +3361,8 @@
<li>整数类型 <code>int</code> 占用 <span class="arithmatex">\(4\)</span> bytes = <span class="arithmatex">\(32\)</span> bits ，可以表示 <span class="arithmatex">\(2^{32}\)</span> 个数字。</li>
</ul>
<p>下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无需硬背，大致理解即可，需要时可以通过查表来回忆。</p>
<p align="center"> 表：基本数据类型的占用空间和取值范围 </p>
<div class="center-table">
<table>
<thead>

2
chapter_data_structure/number_encoding/index.html
View file

@ -3517,6 +3517,8 @@ b_{31} b_{30} b_{29} \ldots b_2 b_1 b_0
<p>现在我们可以回答最初的问题：<strong><code>float</code> 的表示方式包含指数位，导致其取值范围远大于 <code>int</code></strong> 。根据以上计算，<code>float</code> 可表示的最大正数为 <span class="arithmatex">\(2^{254 - 127} \times (2 - 2^{-23}) \approx 3.4 \times 10^{38}\)</span> ，切换符号位便可得到最小负数。</p>
<p><strong>尽管浮点数 <code>float</code> 扩展了取值范围，但其副作用是牺牲了精度</strong>。整数类型 <code>int</code> 将全部 32 位用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 <code>float</code> 的数值越大，相邻两个数字之间的差值就会趋向越大。</p>
<p>进一步地，指数位 <span class="arithmatex">\(E = 0\)</span> 和 <span class="arithmatex">\(E = 255\)</span> 具有特殊含义，<strong>用于表示零、无穷大、<span class="arithmatex">\(\mathrm{NaN}\)</span> 等</strong>。</p>
<p align="center"> 表：指数位含义 </p>
<div class="center-table">
<table>
<thead>

2
chapter_divide_and_conquer/build_binary_tree_problem/index.html
View file

@ -3486,6 +3486,8 @@
<li>将当前树在 <code>inorder</code> 中的索引区间记为 <span class="arithmatex">\([l, r]\)</span> 。</li>
</ul>
<p>如下表所示，通过以上变量即可表示根节点在 <code>preorder</code> 中的索引，以及子树在 <code>inorder</code> 中的索引区间。</p>
<p align="center"> 表：根节点和子树在前序和中序遍历中的索引 </p>
<div class="center-table">
<table>
<thead>

2
chapter_graph/graph/index.html
View file

@ -3543,6 +3543,8 @@ G &amp; = \{ V, E \} \newline
<p>观察上图可发现，<strong>邻接表结构与哈希表中的「链地址法」非常相似，因此我们也可以采用类似方法来优化效率</strong>。例如，当链表较长时，可以将链表转化为 AVL 树或红黑树，从而将时间效率从 <span class="arithmatex">\(O(n)\)</span> 优化至 <span class="arithmatex">\(O(\log n)\)</span> ，还可以通过中序遍历获取有序序列；此外，还可以将链表转换为哈希表，将时间复杂度降低至 <span class="arithmatex">\(O(1)\)</span> 。</p>
<h2 id="914">9.1.4. &nbsp; 图常见应用<a class="headerlink" href="#914" title="Permanent link">&para;</a></h2>
<p>实际应用中，许多系统都可以用图来建模，相应的待求解问题也可以约化为图计算问题。</p>
<p align="center"> 表：现实生活中常见的图 </p>
<div class="center-table">
<table>
<thead>

2
chapter_graph/graph_operations/index.html
View file

@ -5500,6 +5500,8 @@
</div>
<h2 id="923">9.2.3. &nbsp; 效率对比<a class="headerlink" href="#923" title="Permanent link">&para;</a></h2>
<p>设图中共有 <span class="arithmatex">\(n\)</span> 个顶点和 <span class="arithmatex">\(m\)</span> 条边，下表为邻接矩阵和邻接表的时间和空间效率对比。</p>
<p align="center"> 表：邻接矩阵与邻接表对比 </p>
<div class="center-table">
<table>
<thead>

2
chapter_hashing/hash_algorithm/index.html
View file

@ -3926,6 +3926,7 @@
<li>SHA-2 系列中的 SHA-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常被用在各类安全应用与协议中。</li>
<li>SHA-3 相较 SHA-2 的实现开销更低、计算效率更高，但目前使用覆盖度不如 SHA-2 系列。</li>
</ul>
<div class="center-table">
<table>
<thead>
<tr>
@ -3974,6 +3975,7 @@
</tr>
</tbody>
</table>
</div>
<h2 id="634">6.3.4. &nbsp; 数据结构的哈希值<a class="headerlink" href="#634" title="Permanent link">&para;</a></h2>
<p>我们知道，哈希表的 <code>key</code> 可以是整数、小数或字符串等数据类型。编程语言通常会为这些数据类型提供内置的哈希算法，用于计算哈希表中的桶索引。以 Python 为例，我们可以调用 <code>hash()</code> 函数来计算各种数据类型的哈希值，包括：</p>
<ul>

2
chapter_hashing/hash_map/index.html
View file

@ -3437,6 +3437,8 @@
<li><strong>查询元素</strong>：由于数组（链表）是乱序的，因此需要遍历其中的所有元素，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
<li><strong>删除元素</strong>：需要先查询到元素，再从数组中删除，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
</ul>
<p align="center"> 表：元素查询效率对比 </p>
<div class="center-table">
<table>
<thead>

2
chapter_heap/heap/index.html
View file

@ -3512,6 +3512,8 @@
<p>需要指出的是，许多编程语言提供的是「优先队列 Priority Queue」，这是一种抽象数据结构，定义为具有优先级排序的队列。</p>
<p>实际上，<strong>堆通常用作实现优先队列，大顶堆相当于元素按从大到小顺序出队的优先队列</strong>。从使用角度来看，我们可以将「优先队列」和「堆」看作等价的数据结构。因此，本书对两者不做特别区分，统一使用「堆」来命名。</p>
<p>堆的常用操作见下表，方法名需要根据编程语言来确定。</p>
<p align="center"> 表：堆的操作效率 </p>
<div class="center-table">
<table>
<thead>

4
chapter_introduction/what_is_dsa/index.html
View file

@ -3460,12 +3460,14 @@
<p align="center"> 图：拼装积木 </p>
<p>两者的详细对应关系如下表所示。</p>
<p align="center"> 表：将数据结构与算法类比为积木 </p>
<div class="center-table">
<table>
<thead>
<tr>
<th>数据结构与算法</th>
<th>LEGO 乐高</th>
<th>积木</th>
</tr>
</thead>
<tbody>

2
chapter_searching/searching_algorithm_revisited/index.html
View file

@ -3460,6 +3460,8 @@
<p align="center"> 图：多种搜索策略 </p>
<p>上述几种方法的操作效率与特性如下表所示。</p>
<p align="center"> 表：查找算法效率对比 </p>
<div class="center-table">
<table>
<thead>

2
chapter_stack_and_queue/deque/index.html
View file

@ -3472,6 +3472,8 @@
<h2 id="531">5.3.1. &nbsp; 双向队列常用操作<a class="headerlink" href="#531" title="Permanent link">&para;</a></h2>
<p>双向队列的常用操作如下表所示，具体的方法名称需要根据所使用的编程语言来确定。</p>
<p align="center"> 表：双向队列操作效率 </p>
<div class="center-table">
<table>
<thead>

2
chapter_stack_and_queue/queue/index.html
View file

@ -3473,6 +3473,8 @@
<h2 id="521">5.2.1. &nbsp; 队列常用操作<a class="headerlink" href="#521" title="Permanent link">&para;</a></h2>
<p>队列的常见操作如下表所示。需要注意的是，不同编程语言的方法名称可能会有所不同。我们在此采用与栈相同的方法命名。</p>
<p align="center"> 表：队列操作效率 </p>
<div class="center-table">
<table>
<thead>

2
chapter_stack_and_queue/stack/index.html
View file

@ -3542,6 +3542,8 @@
<h2 id="511">5.1.1. &nbsp; 栈常用操作<a class="headerlink" href="#511" title="Permanent link">&para;</a></h2>
<p>栈的常用操作如下表所示，具体的方法名需要根据所使用的编程语言来确定。在此，我们以常见的 <code>push()</code> , <code>pop()</code> , <code>peek()</code> 命名为例。</p>
<p align="center"> 表：栈的操作效率 </p>
<div class="center-table">
<table>
<thead>

10
chapter_tree/avl_tree/index.html
View file

@ -4575,6 +4575,8 @@
<p align="center"> 图：AVL 树的四种旋转情况 </p>
<p>在代码中，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图中的哪种情况。</p>
<p align="center"> 表：四种旋转情况的选择条件 </p>
<div class="center-table">
<table>
<thead>
@ -4586,22 +4588,22 @@
</thead>
<tbody>
<tr>
<td><span class="arithmatex">\(&gt;1\)</span> （即左偏树）</td>
<td><span class="arithmatex">\(&gt; 1\)</span> （即左偏树）</td>
<td><span class="arithmatex">\(\geq 0\)</span></td>
<td>右旋</td>
</tr>
<tr>
<td><span class="arithmatex">\(&gt;1\)</span> （即左偏树）</td>
<td><span class="arithmatex">\(&gt; 1\)</span> （即左偏树）</td>
<td><span class="arithmatex">\(&lt;0\)</span></td>
<td>先左旋后右旋</td>
</tr>
<tr>
<td><span class="arithmatex">\(&lt;-1\)</span> （即右偏树）</td>
<td><span class="arithmatex">\(&lt; -1\)</span> （即右偏树）</td>
<td><span class="arithmatex">\(\leq 0\)</span></td>
<td>左旋</td>
</tr>
<tr>
<td><span class="arithmatex">\(&lt;-1\)</span> （即右偏树）</td>
<td><span class="arithmatex">\(&lt; -1\)</span> （即右偏树）</td>
<td><span class="arithmatex">\(&gt;0\)</span></td>
<td>先右旋后左旋</td>
</tr>

2
chapter_tree/binary_search_tree/index.html
View file

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

8
chapter_tree/binary_tree/index.html
View file

@ -3987,6 +3987,8 @@
<p align="center"> 图：二叉树的最佳与最差结构 </p>
<p>如下表所示，在最佳和最差结构下，二叉树的叶节点数量、节点总数、高度等达到极大或极小值。</p>
<p align="center"> 表：二叉树的最佳与最差情况 </p>
<div class="center-table">
<table>
<thead>
@ -4003,17 +4005,17 @@
<td><span class="arithmatex">\(1\)</span></td>
</tr>
<tr>
<td>树的高度为 <span class="arithmatex">\(h\)</span> 时的叶节点数量</td>
<td>高度 <span class="arithmatex">\(h\)</span> 树的叶节点数量</td>
<td><span class="arithmatex">\(2^h\)</span></td>
<td><span class="arithmatex">\(1\)</span></td>
</tr>
<tr>
<td>树的高度为 <span class="arithmatex">\(h\)</span> 时的节点总数</td>
<td>高度 <span class="arithmatex">\(h\)</span> 树的节点总数</td>
<td><span class="arithmatex">\(2^{h+1} - 1\)</span></td>
<td><span class="arithmatex">\(h + 1\)</span></td>
</tr>
<tr>
<td>树的节点总数为 <span class="arithmatex">\(n\)</span> 时的高度</td>
<td>节点总数 <span class="arithmatex">\(n\)</span> 树的高度</td>
<td><span class="arithmatex">\(\log_2 (n+1) - 1\)</span></td>
<td><span class="arithmatex">\(n - 1\)</span></td>
</tr>

4
chapter_tree/summary/index.html
View file

@ -3445,6 +3445,10 @@
</ul>
<p>因此如果要对比值，我们通常会用 <code>equals()</code> 。然而，通过 <code>String a = "hi"; String b = "hi";</code> 初始化的字符串都存储在字符串常量池中，它们指向同一个对象，因此也可以用 <code>a == b</code> 来比较两个字符串的内容。</p>
</div>
<div class="admonition question">
<p class="admonition-title">广度优先遍历到最底层之前，队列中的节点数量是 <span class="arithmatex">\(2^h\)</span> 吗？</p>
<p>是的，例如高度 <span class="arithmatex">\(h = 2\)</span> 的满二叉树，其节点总数 <span class="arithmatex">\(n = 7\)</span> ，则底层节点数量 <span class="arithmatex">\(4 = 2^h = (n + 1) / 2\)</span> 。</p>
</div>

2
search/search_index.json
View file

File diff suppressed because one or more lines are too long

202
sitemap.xml
View file

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

BIN
sitemap.xml.gz
View file

Binary file not shown.