mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-26 03:06:29 +08:00
deploy
This commit is contained in:
krahets
parent
fd34c845bc
commit
974fea7de4
48 changed files with 299 additions and 299 deletions
|
|
@ -3396,22 +3396,22 @@
|
|||
<h2 id="1621">16.2.1. 内容微调<a class="headerlink" href="#1621" title="Permanent link">¶</a></h2>
|
||||
<p>在每个页面的右上角有一个「编辑」图标，您可以按照以下步骤修改文本或代码：</p>
|
||||
<ol>
|
||||
<li>点击编辑按钮，如果遇到“需要 Fork 此仓库”的提示，请同意该操作；</li>
|
||||
<li>修改 Markdown 源文件内容，并确保内容正确，同时尽量保持排版格式的统一；</li>
|
||||
<li>点击编辑按钮，如果遇到“需要 Fork 此仓库”的提示，请同意该操作。</li>
|
||||
<li>修改 Markdown 源文件内容，并确保内容正确，同时尽量保持排版格式的统一。</li>
|
||||
<li>在页面底部填写修改说明，然后点击“Propose file change”按钮；页面跳转后，点击“Create pull request”按钮即可发起拉取请求。</li>
|
||||
</ol>
|
||||
<p><img alt="页面编辑按键" src="../contribution.assets/edit_markdown.png" /></p>
|
||||
<p align="center"> Fig. 页面编辑按键 </p>
|
||||
|
||||
<p>由于图片无法直接修改，因此需要通过新建 <a href="https://github.com/krahets/hello-algo/issues">Issue</a> 或评论留言来描述图片问题，我们会尽快重新绘制并替换图片。</p>
|
||||
<p>由于图片无法直接修改，因此需要通过新建 <a href="https://github.com/krahets/hello-algo/issues">Issue</a> 或评论留言来描述问题，我们会尽快重新绘制并替换图片。</p>
|
||||
<h2 id="1622">16.2.2. 内容创作<a class="headerlink" href="#1622" title="Permanent link">¶</a></h2>
|
||||
<p>如果您有兴趣参与此开源项目，包括将代码翻译成其他编程语言、扩展文章内容等，那么需要实施 Pull Request 工作流程：</p>
|
||||
<ol>
|
||||
<li>登录 GitHub ，将<a href="https://github.com/krahets/hello-algo">本仓库</a> Fork 到个人账号下；</li>
|
||||
<li>进入您的 Fork 仓库网页，使用 git clone 命令将仓库克隆至本地；</li>
|
||||
<li>在本地进行内容创作，并通过运行测试以验证代码的正确性；</li>
|
||||
<li>将本地所做更改 Commit ，然后 Push 至远程仓库；</li>
|
||||
<li>刷新仓库网页，点击“Create pull request”按钮即可发起拉取请求；</li>
|
||||
<li>登录 GitHub ，将<a href="https://github.com/krahets/hello-algo">本仓库</a> Fork 到个人账号下。</li>
|
||||
<li>进入您的 Fork 仓库网页，使用 git clone 命令将仓库克隆至本地。</li>
|
||||
<li>在本地进行内容创作，并通过运行测试以验证代码的正确性。</li>
|
||||
<li>将本地所做更改 Commit ，然后 Push 至远程仓库。</li>
|
||||
<li>刷新仓库网页，点击“Create pull request”按钮即可发起拉取请求。</li>
|
||||
</ol>
|
||||
<h2 id="1623-docker">16.2.3. Docker 部署<a class="headerlink" href="#1623-docker" title="Permanent link">¶</a></h2>
|
||||
<p>我们可以通过 Docker 来部署本项目。执行以下脚本，稍等片刻后，即可使用浏览器打开 <code>http://localhost:8000</code> 来访问本项目。</p>
|
||||
|
|
|
|||
|
|
@ -3505,17 +3505,17 @@
|
|||
</ol>
|
||||
<h2 id="1617-c">16.1.7. C# 环境<a class="headerlink" href="#1617-c" title="Permanent link">¶</a></h2>
|
||||
<ol>
|
||||
<li>下载并安装 <a href="https://dotnet.microsoft.com/en-us/download">.Net 6.0</a> ；</li>
|
||||
<li>下载并安装 <a href="https://dotnet.microsoft.com/en-us/download">.Net 6.0</a> 。</li>
|
||||
<li>在 VSCode 的插件市场中搜索 <code>c#</code> ，安装 c# 。</li>
|
||||
</ol>
|
||||
<h2 id="1618-swift">16.1.8. Swift 环境<a class="headerlink" href="#1618-swift" title="Permanent link">¶</a></h2>
|
||||
<ol>
|
||||
<li>下载并安装 <a href="https://www.swift.org/download/">Swift</a>；</li>
|
||||
<li>下载并安装 <a href="https://www.swift.org/download/">Swift</a>。</li>
|
||||
<li>在 VSCode 的插件市场中搜索 <code>swift</code> ，安装 <a href="https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang">Swift for Visual Studio Code</a>。</li>
|
||||
</ol>
|
||||
<h2 id="1619-rust">16.1.9. Rust 环境<a class="headerlink" href="#1619-rust" title="Permanent link">¶</a></h2>
|
||||
<ol>
|
||||
<li>下载并安装 <a href="https://www.rust-lang.org/tools/install">Rust</a>；</li>
|
||||
<li>下载并安装 <a href="https://www.rust-lang.org/tools/install">Rust</a>。</li>
|
||||
<li>在 VSCode 的插件市场中搜索 <code>rust</code> ，安装 <a href="https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer">rust-analyzer</a>。</li>
|
||||
</ol>
|
||||
|
||||
|
|
|
|||
|
|
@ -3424,9 +3424,9 @@
|
|||
<p class="admonition-title">数组存储在栈上和存储在堆上，对时间效率和空间效率是否有影响？</p>
|
||||
<p>栈内存分配由编译器自动完成，而堆内存由程序员在代码中分配（注意，这里的栈和堆和数据结构中的栈和堆不是同一概念）。</p>
|
||||
<ol>
|
||||
<li>栈不灵活，分配的内存大小不可更改；堆相对灵活，可以动态分配内存；</li>
|
||||
<li>栈是一块比较小的内存，容易出现内存不足；堆内存很大，但是由于是动态分配，容易碎片化，管理堆内存的难度更大、成本更高；</li>
|
||||
<li>访问栈比访问堆更快，因为栈内存较小、对缓存友好，堆帧分散在很大的空间内，会出现更多的缓存未命中；</li>
|
||||
<li>栈不灵活，分配的内存大小不可更改；堆相对灵活，可以动态分配内存。</li>
|
||||
<li>栈是一块比较小的内存，容易出现内存不足；堆内存很大，但是由于是动态分配，容易碎片化，管理堆内存的难度更大、成本更高。</li>
|
||||
<li>访问栈比访问堆更快，因为栈内存较小、对缓存友好，堆帧分散在很大的空间内，会出现更多的缓存未命中。</li>
|
||||
</ol>
|
||||
</div>
|
||||
<div class="admonition question">
|
||||
|
|
|
|||
|
|
@ -4757,9 +4757,9 @@
|
|||
</ul>
|
||||
<p>请注意，对于许多组合优化问题，回溯都不是最优解决方案，例如：</p>
|
||||
<ul>
|
||||
<li>0-1 背包问题通常使用动态规划解决，以达到更高的时间效率；</li>
|
||||
<li>旅行商是一个著名的 NP-Hard 问题，常用解法有遗传算法和蚁群算法等；</li>
|
||||
<li>最大团问题是图论中的一个经典问题，可用贪心等启发式算法来解决；</li>
|
||||
<li>0-1 背包问题通常使用动态规划解决，以达到更高的时间效率。</li>
|
||||
<li>旅行商是一个著名的 NP-Hard 问题，常用解法有遗传算法和蚁群算法等。</li>
|
||||
<li>最大团问题是图论中的一个经典问题，可用贪心等启发式算法来解决。</li>
|
||||
</ul>
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -3733,8 +3733,8 @@
|
|||
</ol>
|
||||
<p>分支越靠右，需要排除的分支也越多，例如：</p>
|
||||
<ol>
|
||||
<li>前两轮选择 <span class="arithmatex">\(3\)</span> , <span class="arithmatex">\(5\)</span> ，生成子集 <span class="arithmatex">\([3, 5, \cdots]\)</span> ；</li>
|
||||
<li>前两轮选择 <span class="arithmatex">\(4\)</span> , <span class="arithmatex">\(5\)</span> ，生成子集 <span class="arithmatex">\([4, 5, \cdots]\)</span> ；</li>
|
||||
<li>前两轮选择 <span class="arithmatex">\(3\)</span> , <span class="arithmatex">\(5\)</span> ，生成子集 <span class="arithmatex">\([3, 5, \cdots]\)</span> 。</li>
|
||||
<li>前两轮选择 <span class="arithmatex">\(4\)</span> , <span class="arithmatex">\(5\)</span> ，生成子集 <span class="arithmatex">\([4, 5, \cdots]\)</span> 。</li>
|
||||
<li>若第一轮选择 <span class="arithmatex">\(5\)</span> ，<strong>则第二轮应该跳过 <span class="arithmatex">\(3\)</span> 和 <span class="arithmatex">\(4\)</span></strong> ，因为子集 <span class="arithmatex">\([5, 3, \cdots]\)</span> 和子集 <span class="arithmatex">\([5, 4, \cdots]\)</span> 和 <code>1.</code> , <code>2.</code> 中生成的子集完全重复。</li>
|
||||
</ol>
|
||||
<p><img alt="不同选择顺序导致的重复子集" src="../subset_sum_problem.assets/subset_sum_i_pruning.png" /></p>
|
||||
|
|
|
|||
|
|
@ -3449,9 +3449,9 @@
|
|||
<p>由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「复杂度分析 Complexity Analysis」或「渐近复杂度分析 Asymptotic Complexity Analysis」。</p>
|
||||
<p><strong>复杂度分析评估的是算法运行效率随着输入数据量增多时的增长趋势</strong>。这个定义有些拗口，我们可以将其分为三个重点来理解：</p>
|
||||
<ul>
|
||||
<li>“算法运行效率”可分为“运行时间”和“占用空间”，因此我们可以将复杂度分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」；</li>
|
||||
<li>“随着输入数据量增多时”表示复杂度与输入数据量有关，反映了算法运行效率与输入数据量之间的关系；</li>
|
||||
<li>“增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间；</li>
|
||||
<li>“算法运行效率”可分为“运行时间”和“占用空间”，因此我们可以将复杂度分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。</li>
|
||||
<li>“随着输入数据量增多时”表示复杂度与输入数据量有关，反映了算法运行效率与输入数据量之间的关系。</li>
|
||||
<li>“增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。</li>
|
||||
</ul>
|
||||
<p><strong>复杂度分析克服了实际测试方法的弊端</strong>。首先，它独立于测试环境，因此分析结果适用于所有运行平台。其次，它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。</p>
|
||||
<p>如果你对复杂度分析的概念仍感到困惑，无需担心，我们会在后续章节详细介绍。</p>
|
||||
|
|
|
|||
|
|
@ -3488,9 +3488,9 @@
|
|||
<h2 id="231">2.3.1. 算法相关空间<a class="headerlink" href="#231" title="Permanent link">¶</a></h2>
|
||||
<p>算法运行过程中使用的内存空间主要包括以下几种：</p>
|
||||
<ul>
|
||||
<li>「输入空间」用于存储算法的输入数据；</li>
|
||||
<li>「暂存空间」用于存储算法运行过程中的变量、对象、函数上下文等数据；</li>
|
||||
<li>「输出空间」用于存储算法的输出数据；</li>
|
||||
<li>「输入空间」用于存储算法的输入数据。</li>
|
||||
<li>「暂存空间」用于存储算法运行过程中的变量、对象、函数上下文等数据。</li>
|
||||
<li>「输出空间」用于存储算法的输出数据。</li>
|
||||
</ul>
|
||||
<p>通常情况下，空间复杂度统计范围是「暂存空间」+「输出空间」。</p>
|
||||
<p>暂存空间可以进一步划分为三个部分：</p>
|
||||
|
|
@ -3747,8 +3747,8 @@
|
|||
<p>空间复杂度的推算方法与时间复杂度大致相同，只是将统计对象从“计算操作数量”转为“使用空间大小”。与时间复杂度不同的是，<strong>我们通常只关注「最差空间复杂度」</strong>，这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。</p>
|
||||
<p><strong>最差空间复杂度中的“最差”有两层含义</strong>，分别是输入数据的最差分布和算法运行过程中的最差时间点。</p>
|
||||
<ul>
|
||||
<li><strong>以最差输入数据为准</strong>。当 <span class="arithmatex">\(n < 10\)</span> 时，空间复杂度为 <span class="arithmatex">\(O(1)\)</span> ；但当 <span class="arithmatex">\(n > 10\)</span> 时，初始化的数组 <code>nums</code> 占用 <span class="arithmatex">\(O(n)\)</span> 空间；因此最差空间复杂度为 <span class="arithmatex">\(O(n)\)</span> ；</li>
|
||||
<li><strong>以算法运行过程中的峰值内存为准</strong>。例如，程序在执行最后一行之前，占用 <span class="arithmatex">\(O(1)\)</span> 空间；当初始化数组 <code>nums</code> 时，程序占用 <span class="arithmatex">\(O(n)\)</span> 空间；因此最差空间复杂度为 <span class="arithmatex">\(O(n)\)</span> ；</li>
|
||||
<li><strong>以最差输入数据为准</strong>。当 <span class="arithmatex">\(n < 10\)</span> 时，空间复杂度为 <span class="arithmatex">\(O(1)\)</span> ；但当 <span class="arithmatex">\(n > 10\)</span> 时，初始化的数组 <code>nums</code> 占用 <span class="arithmatex">\(O(n)\)</span> 空间；因此最差空间复杂度为 <span class="arithmatex">\(O(n)\)</span> 。</li>
|
||||
<li><strong>以算法运行过程中的峰值内存为准</strong>。例如，程序在执行最后一行之前，占用 <span class="arithmatex">\(O(1)\)</span> 空间；当初始化数组 <code>nums</code> 时，程序占用 <span class="arithmatex">\(O(n)\)</span> 空间；因此最差空间复杂度为 <span class="arithmatex">\(O(n)\)</span> 。</li>
|
||||
</ul>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:11"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
|
|||
|
|
@ -5974,8 +5974,8 @@ n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1
|
|||
<h2 id="226">2.2.6. 最差、最佳、平均时间复杂度<a class="headerlink" href="#226" title="Permanent link">¶</a></h2>
|
||||
<p><strong>某些算法的时间复杂度不是固定的，而是与输入数据的分布有关</strong>。例如，假设输入一个长度为 <span class="arithmatex">\(n\)</span> 的数组 <code>nums</code> ，其中 <code>nums</code> 由从 <span class="arithmatex">\(1\)</span> 至 <span class="arithmatex">\(n\)</span> 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 <span class="arithmatex">\(1\)</span> 的索引。我们可以得出以下结论：</p>
|
||||
<ul>
|
||||
<li>当 <code>nums = [?, ?, ..., 1]</code> ，即当末尾元素是 <span class="arithmatex">\(1\)</span> 时，需要完整遍历数组，此时达到 <strong>最差时间复杂度 <span class="arithmatex">\(O(n)\)</span></strong>；</li>
|
||||
<li>当 <code>nums = [1, ?, ?, ...]</code> ，即当首个数字为 <span class="arithmatex">\(1\)</span> 时，无论数组多长都不需要继续遍历，此时达到 <strong>最佳时间复杂度 <span class="arithmatex">\(\Omega(1)\)</span></strong>；</li>
|
||||
<li>当 <code>nums = [?, ?, ..., 1]</code> ，即当末尾元素是 <span class="arithmatex">\(1\)</span> 时，需要完整遍历数组，此时达到 <strong>最差时间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> 。</li>
|
||||
<li>当 <code>nums = [1, ?, ?, ...]</code> ，即当首个数字为 <span class="arithmatex">\(1\)</span> 时，无论数组多长都不需要继续遍历，此时达到 <strong>最佳时间复杂度 <span class="arithmatex">\(\Omega(1)\)</span></strong> 。</li>
|
||||
</ul>
|
||||
<p>“函数渐近上界”使用大 <span class="arithmatex">\(O\)</span> 记号表示，代表「最差时间复杂度」。相应地，“函数渐近下界”用 <span class="arithmatex">\(\Omega\)</span> 记号来表示，代表「最佳时间复杂度」。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="16:11"><input checked="checked" id="__tabbed_16_1" name="__tabbed_16" type="radio" /><input id="__tabbed_16_2" name="__tabbed_16" type="radio" /><input id="__tabbed_16_3" name="__tabbed_16" type="radio" /><input id="__tabbed_16_4" name="__tabbed_16" type="radio" /><input id="__tabbed_16_5" name="__tabbed_16" type="radio" /><input id="__tabbed_16_6" name="__tabbed_16" type="radio" /><input id="__tabbed_16_7" name="__tabbed_16" type="radio" /><input id="__tabbed_16_8" name="__tabbed_16" type="radio" /><input id="__tabbed_16_9" name="__tabbed_16" type="radio" /><input id="__tabbed_16_10" name="__tabbed_16" type="radio" /><input id="__tabbed_16_11" name="__tabbed_16" type="radio" /><div class="tabbed-labels"><label for="__tabbed_16_1">Java</label><label for="__tabbed_16_2">C++</label><label for="__tabbed_16_3">Python</label><label for="__tabbed_16_4">Go</label><label for="__tabbed_16_5">JavaScript</label><label for="__tabbed_16_6">TypeScript</label><label for="__tabbed_16_7">C</label><label for="__tabbed_16_8">C#</label><label for="__tabbed_16_9">Swift</label><label for="__tabbed_16_10">Zig</label><label for="__tabbed_16_11">Dart</label></div>
|
||||
|
|
|
|||
|
|
@ -3311,15 +3311,15 @@
|
|||
<p>谈及计算机中的数据，我们会想到文本、图片、视频、语音、3D 模型等各种形式。尽管这些数据的组织形式各异，但它们都由各种基本数据类型构成。</p>
|
||||
<p><strong>基本数据类型是 CPU 可以直接进行运算的类型，在算法中直接被使用</strong>。它包括：</p>
|
||||
<ul>
|
||||
<li>整数类型 <code>byte</code> , <code>short</code> , <code>int</code> , <code>long</code> ；</li>
|
||||
<li>浮点数类型 <code>float</code> , <code>double</code> ，用于表示小数；</li>
|
||||
<li>字符类型 <code>char</code> ，用于表示各种语言的字母、标点符号、甚至表情符号等；</li>
|
||||
<li>布尔类型 <code>bool</code> ，用于表示“是”与“否”判断；</li>
|
||||
<li>整数类型 <code>byte</code> , <code>short</code> , <code>int</code> , <code>long</code> 。</li>
|
||||
<li>浮点数类型 <code>float</code> , <code>double</code> ，用于表示小数。</li>
|
||||
<li>字符类型 <code>char</code> ，用于表示各种语言的字母、标点符号、甚至表情符号等。</li>
|
||||
<li>布尔类型 <code>bool</code> ，用于表示“是”与“否”判断。</li>
|
||||
</ul>
|
||||
<p><strong>所有基本数据类型都以二进制的形式存储在计算机中</strong>。在计算机中，我们将 <span class="arithmatex">\(1\)</span> 个二进制位称为 <span class="arithmatex">\(1\)</span> 比特，并规定 <span class="arithmatex">\(1\)</span> 字节（byte）由 <span class="arithmatex">\(8\)</span> 比特（bits）组成。基本数据类型的取值范围取决于其占用的空间大小，例如：</p>
|
||||
<ul>
|
||||
<li>整数类型 <code>byte</code> 占用 <span class="arithmatex">\(1\)</span> byte = <span class="arithmatex">\(8\)</span> bits ，可以表示 <span class="arithmatex">\(2^{8}\)</span> 个不同的数字；</li>
|
||||
<li>整数类型 <code>int</code> 占用 <span class="arithmatex">\(4\)</span> bytes = <span class="arithmatex">\(32\)</span> bits ，可以表示 <span class="arithmatex">\(2^{32}\)</span> 个数字；</li>
|
||||
<li>整数类型 <code>byte</code> 占用 <span class="arithmatex">\(1\)</span> byte = <span class="arithmatex">\(8\)</span> bits ，可以表示 <span class="arithmatex">\(2^{8}\)</span> 个不同的数字。</li>
|
||||
<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>
|
||||
<div class="center-table">
|
||||
|
|
|
|||
|
|
@ -3379,17 +3379,17 @@
|
|||
<p><strong>「逻辑结构」揭示了数据元素之间的逻辑关系</strong>。在数组和链表中，数据按照顺序依次排列，体现了数据之间的线性关系；而在树中，数据从顶部向下按层次排列，表现出祖先与后代之间的派生关系；图则由节点和边构成，反映了复杂的网络关系。</p>
|
||||
<p>逻辑结构通常分为“线性”和“非线性”两类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列。</p>
|
||||
<ul>
|
||||
<li><strong>线性数据结构</strong>：数组、链表、栈、队列、哈希表；</li>
|
||||
<li><strong>非线性数据结构</strong>：树、堆、图、哈希表；</li>
|
||||
<li><strong>线性数据结构</strong>：数组、链表、栈、队列、哈希表。</li>
|
||||
<li><strong>非线性数据结构</strong>：树、堆、图、哈希表。</li>
|
||||
</ul>
|
||||
<p><img alt="线性与非线性数据结构" src="../classification_of_data_structure.assets/classification_logic_structure.png" /></p>
|
||||
<p align="center"> Fig. 线性与非线性数据结构 </p>
|
||||
|
||||
<p>非线性数据结构可以进一步被划分为树形结构和网状结构。</p>
|
||||
<ul>
|
||||
<li><strong>线性结构</strong>：数组、链表、队列、栈、哈希表，元素存在一对一的顺序关系；</li>
|
||||
<li><strong>树形结构</strong>：树、堆、哈希表，元素存在一对多的关系；</li>
|
||||
<li><strong>网状结构</strong>：图，元素存在多对多的关系；</li>
|
||||
<li><strong>线性结构</strong>：数组、链表、队列、栈、哈希表，元素存在一对一的顺序关系。</li>
|
||||
<li><strong>树形结构</strong>：树、堆、哈希表，元素存在一对多的关系。</li>
|
||||
<li><strong>网状结构</strong>：图，元素存在多对多的关系。</li>
|
||||
</ul>
|
||||
<h2 id="312">3.1.2. 物理结构：连续与离散<a class="headerlink" href="#312" title="Permanent link">¶</a></h2>
|
||||
<p>在计算机中，内存和硬盘是两种主要的存储硬件设备。硬盘主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。内存用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。</p>
|
||||
|
|
@ -3405,8 +3405,8 @@
|
|||
|
||||
<p><strong>所有数据结构都是基于数组、链表或二者的组合实现的</strong>。例如，栈和队列既可以使用数组实现，也可以使用链表实现；而哈希表的实现可能同时包含数组和链表。</p>
|
||||
<ul>
|
||||
<li><strong>基于数组可实现</strong>：栈、队列、哈希表、树、堆、图、矩阵、张量（维度 <span class="arithmatex">\(\geq 3\)</span> 的数组）等；</li>
|
||||
<li><strong>基于链表可实现</strong>：栈、队列、哈希表、树、堆、图等；</li>
|
||||
<li><strong>基于数组可实现</strong>：栈、队列、哈希表、树、堆、图、矩阵、张量（维度 <span class="arithmatex">\(\geq 3\)</span> 的数组）等。</li>
|
||||
<li><strong>基于链表可实现</strong>：栈、队列、哈希表、树、堆、图等。</li>
|
||||
</ul>
|
||||
<p>基于数组实现的数据结构也被称为“静态数据结构”，这意味着此类数据结构在初始化后长度不可变。相对应地，基于链表实现的数据结构被称为“动态数据结构”，这类数据结构在初始化后，仍可以在程序运行过程中对其长度进行调整。</p>
|
||||
<div class="admonition tip">
|
||||
|
|
|
|||
|
|
@ -3445,9 +3445,9 @@
|
|||
<p>细心的你可能会发现：<code>int</code> 和 <code>float</code> 长度相同，都是 4 bytes，但为什么 <code>float</code> 的取值范围远大于 <code>int</code> ？这非常反直觉，因为按理说 <code>float</code> 需要表示小数，取值范围应该变小才对。</p>
|
||||
<p>实际上，这是因为浮点数 <code>float</code> 采用了不同的表示方式。根据 IEEE 754 标准，32-bit 长度的 <code>float</code> 由以下部分构成：</p>
|
||||
<ul>
|
||||
<li>符号位 <span class="arithmatex">\(\mathrm{S}\)</span> ：占 1 bit ；</li>
|
||||
<li>指数位 <span class="arithmatex">\(\mathrm{E}\)</span> ：占 8 bits ；</li>
|
||||
<li>分数位 <span class="arithmatex">\(\mathrm{N}\)</span> ：占 24 bits ，其中 23 位显式存储；</li>
|
||||
<li>符号位 <span class="arithmatex">\(\mathrm{S}\)</span> ：占 1 bit 。</li>
|
||||
<li>指数位 <span class="arithmatex">\(\mathrm{E}\)</span> ：占 8 bits 。</li>
|
||||
<li>分数位 <span class="arithmatex">\(\mathrm{N}\)</span> ：占 24 bits ，其中 23 位显式存储。</li>
|
||||
</ul>
|
||||
<p>设 32-bit 二进制数的第 <span class="arithmatex">\(i\)</span> 位为 <span class="arithmatex">\(b_i\)</span> ，则 <code>float</code> 值的计算方法定义为：</p>
|
||||
<div class="arithmatex">\[
|
||||
|
|
@ -3508,8 +3508,8 @@
|
|||
</div>
|
||||
<p>特别地，次正规数显著提升了浮点数的精度，这是因为：</p>
|
||||
<ul>
|
||||
<li>最小正正规数为 <span class="arithmatex">\(2^{-126} \approx 1.18 \times 10^{-38}\)</span> ；</li>
|
||||
<li>最小正次正规数为 <span class="arithmatex">\(2^{-126} \times 2^{-23} \approx 1.4 \times 10^{-45}\)</span> ；</li>
|
||||
<li>最小正正规数为 <span class="arithmatex">\(2^{-126} \approx 1.18 \times 10^{-38}\)</span> 。</li>
|
||||
<li>最小正次正规数为 <span class="arithmatex">\(2^{-126} \times 2^{-23} \approx 1.4 \times 10^{-45}\)</span> 。</li>
|
||||
</ul>
|
||||
<p>双精度 <code>double</code> 也采用类似 <code>float</code> 的表示方法，此处不再详述。</p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3394,8 +3394,8 @@
|
|||
<p>从分治角度，我们将搜索区间 <span class="arithmatex">\([i, j]\)</span> 对应的子问题记为 <span class="arithmatex">\(f(i, j)\)</span> 。</p>
|
||||
<p>从原问题 <span class="arithmatex">\(f(0, n-1)\)</span> 为起始点，二分查找的分治步骤为：</p>
|
||||
<ol>
|
||||
<li>计算搜索区间 <span class="arithmatex">\([i, j]\)</span> 的中点 <span class="arithmatex">\(m\)</span> ，根据它排除一半搜索区间；</li>
|
||||
<li>递归求解规模减小一半的子问题，可能为 <span class="arithmatex">\(f(i, m-1)\)</span> 或 <span class="arithmatex">\(f(m+1, j)\)</span> ；</li>
|
||||
<li>计算搜索区间 <span class="arithmatex">\([i, j]\)</span> 的中点 <span class="arithmatex">\(m\)</span> ，根据它排除一半搜索区间。</li>
|
||||
<li>递归求解规模减小一半的子问题，可能为 <span class="arithmatex">\(f(i, m-1)\)</span> 或 <span class="arithmatex">\(f(m+1, j)\)</span> 。</li>
|
||||
<li>循环第 <code>1.</code> , <code>2.</code> 步，直至找到 <code>target</code> 或区间为空时返回。</li>
|
||||
</ol>
|
||||
<p>下图展示了在数组中二分查找元素 <span class="arithmatex">\(6\)</span> 的分治过程。</p>
|
||||
|
|
|
|||
|
|
@ -3428,14 +3428,14 @@
|
|||
<p>根据以上分析，这道题是可以使用分治来求解的，但问题是：<strong>如何通过前序遍历 <code>preorder</code> 和中序遍历 <code>inorder</code> 来划分左子树和右子树呢</strong>？</p>
|
||||
<p>根据定义，<code>preorder</code> 和 <code>inorder</code> 都可以被划分为三个部分：</p>
|
||||
<ul>
|
||||
<li>前序遍历：<code>[ 根节点 | 左子树 | 右子树 ]</code> ，例如上图 <code>[ 3 | 9 | 2 1 7 ]</code> ；</li>
|
||||
<li>中序遍历：<code>[ 左子树 | 根节点 ｜ 右子树 ]</code> ，例如上图 <code>[ 9 | 3 | 1 2 7 ]</code> ；</li>
|
||||
<li>前序遍历：<code>[ 根节点 | 左子树 | 右子树 ]</code> ，例如上图 <code>[ 3 | 9 | 2 1 7 ]</code> 。</li>
|
||||
<li>中序遍历：<code>[ 左子树 | 根节点 ｜ 右子树 ]</code> ，例如上图 <code>[ 9 | 3 | 1 2 7 ]</code> 。</li>
|
||||
</ul>
|
||||
<p>以上图数据为例，我们可以通过以下步骤得到上述的划分结果：</p>
|
||||
<ol>
|
||||
<li>前序遍历的首元素 3 是根节点的值；</li>
|
||||
<li>查找根节点 3 在 <code>inorder</code> 中的索引，利用该索引可将 <code>inorder</code> 划分为 <code>[ 9 | 3 ｜ 1 2 7 ]</code> ；</li>
|
||||
<li>根据 <code>inorder</code> 划分结果，易得左子树和右子树的节点数量分别为 1 和 3 ，从而可将 <code>preorder</code> 划分为 <code>[ 3 | 9 | 2 1 7 ]</code> ；</li>
|
||||
<li>前序遍历的首元素 3 是根节点的值。</li>
|
||||
<li>查找根节点 3 在 <code>inorder</code> 中的索引，利用该索引可将 <code>inorder</code> 划分为 <code>[ 9 | 3 ｜ 1 2 7 ]</code> 。</li>
|
||||
<li>根据 <code>inorder</code> 划分结果，易得左子树和右子树的节点数量分别为 1 和 3 ，从而可将 <code>preorder</code> 划分为 <code>[ 3 | 9 | 2 1 7 ]</code> 。</li>
|
||||
</ol>
|
||||
<p><img alt="在前序和中序遍历中划分子树" src="../build_binary_tree_problem.assets/build_tree_preorder_inorder_division.png" /></p>
|
||||
<p align="center"> Fig. 在前序和中序遍历中划分子树 </p>
|
||||
|
|
@ -3443,9 +3443,9 @@
|
|||
<h3 id="_3">基于变量描述子树区间<a class="headerlink" href="#_3" title="Permanent link">¶</a></h3>
|
||||
<p>根据以上划分方法，<strong>我们已经得到根节点、左子树、右子树在 <code>preorder</code> 和 <code>inorder</code> 中的索引区间</strong>。而为了描述这些索引区间，我们需要借助几个指针变量：</p>
|
||||
<ul>
|
||||
<li>将当前树的根节点在 <code>preorder</code> 中的索引记为 <span class="arithmatex">\(i\)</span> ；</li>
|
||||
<li>将当前树的根节点在 <code>inorder</code> 中的索引记为 <span class="arithmatex">\(m\)</span> ；</li>
|
||||
<li>将当前树在 <code>inorder</code> 中的索引区间记为 <span class="arithmatex">\([l, r]\)</span> ；</li>
|
||||
<li>将当前树的根节点在 <code>preorder</code> 中的索引记为 <span class="arithmatex">\(i\)</span> 。</li>
|
||||
<li>将当前树的根节点在 <code>inorder</code> 中的索引记为 <span class="arithmatex">\(m\)</span> 。</li>
|
||||
<li>将当前树在 <code>inorder</code> 中的索引区间记为 <span class="arithmatex">\([l, r]\)</span> 。</li>
|
||||
</ul>
|
||||
<p>如下表所示，通过以上变量即可表示根节点在 <code>preorder</code> 中的索引，以及子树在 <code>inorder</code> 中的索引区间。</p>
|
||||
<div class="center-table">
|
||||
|
|
|
|||
|
|
@ -3438,8 +3438,8 @@
|
|||
<h1 id="121">12.1. 分治算法<a class="headerlink" href="#121" title="Permanent link">¶</a></h1>
|
||||
<p>「分治 Divide and Conquer」，全称分而治之，是一种非常重要且常见的算法策略。分治通常基于递归实现，包括“分”和“治”两步：</p>
|
||||
<ol>
|
||||
<li><strong>分（划分阶段）</strong>：递归地将原问题分解为两个或多个子问题，直至到达最小子问题时终止；</li>
|
||||
<li><strong>治（合并阶段）</strong>：从已知解的最小子问题开始，从底至顶地将子问题的解进行合并，从而构建出原问题的解；</li>
|
||||
<li><strong>分（划分阶段）</strong>：递归地将原问题分解为两个或多个子问题，直至到达最小子问题时终止。</li>
|
||||
<li><strong>治（合并阶段）</strong>：从已知解的最小子问题开始，从底至顶地将子问题的解进行合并，从而构建出原问题的解。</li>
|
||||
</ol>
|
||||
<p>已介绍过的「归并排序」是分治策略的典型应用之一，它的分治策略为：</p>
|
||||
<ol>
|
||||
|
|
@ -3458,9 +3458,9 @@
|
|||
</ol>
|
||||
<p>显然归并排序，满足以上三条判断依据：</p>
|
||||
<ol>
|
||||
<li>递归地将数组（原问题）划分为两个子数组（子问题）；</li>
|
||||
<li>每个子数组都可以独立地进行排序（子问题可以独立进行求解）；</li>
|
||||
<li>两个有序子数组（子问题的解）可以被合并为一个有序数组（原问题的解）；</li>
|
||||
<li>递归地将数组（原问题）划分为两个子数组（子问题）。</li>
|
||||
<li>每个子数组都可以独立地进行排序（子问题可以独立进行求解）。</li>
|
||||
<li>两个有序子数组（子问题的解）可以被合并为一个有序数组（原问题的解）。</li>
|
||||
</ol>
|
||||
<h2 id="1212">12.1.2. 通过分治提升效率<a class="headerlink" href="#1212" title="Permanent link">¶</a></h2>
|
||||
<p>分治不仅可以有效地解决算法问题，<strong>往往还可以带来算法效率的提升</strong>。在排序算法中，快速排序、归并排序、堆排序相较于选择、冒泡、插入排序更快，就是因为它们应用了分治策略。</p>
|
||||
|
|
|
|||
|
|
@ -3401,9 +3401,9 @@
|
|||
<p class="admonition-title">Question</p>
|
||||
<p>给定三根柱子，记为 <code>A</code> , <code>B</code> , <code>C</code> 。起始状态下，柱子 <code>A</code> 上套着 <span class="arithmatex">\(n\)</span> 个圆盘，它们从上到下按照从小到大的顺序排列。我们的任务是要把这 <span class="arithmatex">\(n\)</span> 个圆盘移到柱子 <code>C</code> 上，并保持它们的原有顺序不变。在移动圆盘的过程中，需要遵守以下规则：</p>
|
||||
<ol>
|
||||
<li>圆盘只能从一个柱子顶部拿出，从另一个柱子顶部放入；</li>
|
||||
<li>每次只能移动一个圆盘；</li>
|
||||
<li>小圆盘必须时刻位于大圆盘之上；</li>
|
||||
<li>圆盘只能从一个柱子顶部拿出，从另一个柱子顶部放入。</li>
|
||||
<li>每次只能移动一个圆盘。</li>
|
||||
<li>小圆盘必须时刻位于大圆盘之上。</li>
|
||||
</ol>
|
||||
</div>
|
||||
<p><img alt="汉诺塔问题示例" src="../hanota_problem.assets/hanota_example.png" /></p>
|
||||
|
|
@ -3424,9 +3424,9 @@
|
|||
</div>
|
||||
<p>对于问题 <span class="arithmatex">\(f(2)\)</span> ，即当有两个圆盘时，<strong>由于要时刻满足小圆盘在大圆盘之上，因此需要借助 <code>B</code> 来完成移动</strong>，包括三步：</p>
|
||||
<ol>
|
||||
<li>先将上面的小圆盘从 <code>A</code> 移至 <code>B</code> ；</li>
|
||||
<li>再将大圆盘从 <code>A</code> 移至 <code>C</code> ；</li>
|
||||
<li>最后将小圆盘从 <code>B</code> 移至 <code>C</code> ；</li>
|
||||
<li>先将上面的小圆盘从 <code>A</code> 移至 <code>B</code> 。</li>
|
||||
<li>再将大圆盘从 <code>A</code> 移至 <code>C</code> 。</li>
|
||||
<li>最后将小圆盘从 <code>B</code> 移至 <code>C</code> 。</li>
|
||||
</ol>
|
||||
<p>解决问题 <span class="arithmatex">\(f(2)\)</span> 的过程可总结为：<strong>将两个圆盘借助 <code>B</code> 从 <code>A</code> 移至 <code>C</code></strong> 。其中，<code>C</code> 称为目标柱、<code>B</code> 称为缓冲柱。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:4"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label></div>
|
||||
|
|
@ -3448,9 +3448,9 @@
|
|||
<h3 id="_2">子问题分解<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>对于问题 <span class="arithmatex">\(f(3)\)</span> ，即当有三个圆盘时，情况变得稍微复杂了一些。由于已知 <span class="arithmatex">\(f(1)\)</span> 和 <span class="arithmatex">\(f(2)\)</span> 的解，因此可从分治角度思考，<strong>将 <code>A</code> 顶部的两个圆盘看做一个整体</strong>，执行以下步骤：</p>
|
||||
<ol>
|
||||
<li>令 <code>B</code> 为目标柱、<code>C</code> 为缓冲柱，将两个圆盘从 <code>A</code> 移动至 <code>B</code> ；</li>
|
||||
<li>将 <code>A</code> 中剩余的一个圆盘从 <code>A</code> 直接移动至 <code>C</code> ；</li>
|
||||
<li>令 <code>C</code> 为目标柱、<code>A</code> 为缓冲柱，将两个圆盘从 <code>B</code> 移动至 <code>C</code> ；</li>
|
||||
<li>令 <code>B</code> 为目标柱、<code>C</code> 为缓冲柱，将两个圆盘从 <code>A</code> 移动至 <code>B</code> 。</li>
|
||||
<li>将 <code>A</code> 中剩余的一个圆盘从 <code>A</code> 直接移动至 <code>C</code> 。</li>
|
||||
<li>令 <code>C</code> 为目标柱、<code>A</code> 为缓冲柱，将两个圆盘从 <code>B</code> 移动至 <code>C</code> 。</li>
|
||||
</ol>
|
||||
<p>这样三个圆盘就被顺利地从 <code>A</code> 移动至 <code>C</code> 了。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:4"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1"><1></label><label for="__tabbed_3_2"><2></label><label for="__tabbed_3_3"><3></label><label for="__tabbed_3_4"><4></label></div>
|
||||
|
|
@ -3472,9 +3472,9 @@
|
|||
<p>本质上看，<strong>我们将问题 <span class="arithmatex">\(f(3)\)</span> 划分为两个子问题 <span class="arithmatex">\(f(2)\)</span> 和子问题 <span class="arithmatex">\(f(1)\)</span></strong> 。按顺序解决这三个子问题之后，原问题随之得到解决。这说明子问题是独立的，且解是可以合并的。</p>
|
||||
<p>至此，我们可总结出汉诺塔问题的分治策略：将原问题 <span class="arithmatex">\(f(n)\)</span> 划分为两个子问题 <span class="arithmatex">\(f(n-1)\)</span> 和一个子问题 <span class="arithmatex">\(f(1)\)</span> 。子问题的解决顺序为：</p>
|
||||
<ol>
|
||||
<li>将 <span class="arithmatex">\(n-1\)</span> 个圆盘借助 <code>C</code> 从 <code>A</code> 移至 <code>B</code> ；</li>
|
||||
<li>将剩余 <span class="arithmatex">\(1\)</span> 个圆盘从 <code>A</code> 直接移至 <code>C</code> ；</li>
|
||||
<li>将 <span class="arithmatex">\(n-1\)</span> 个圆盘借助 <code>A</code> 从 <code>B</code> 移至 <code>C</code> ；</li>
|
||||
<li>将 <span class="arithmatex">\(n-1\)</span> 个圆盘借助 <code>C</code> 从 <code>A</code> 移至 <code>B</code> 。</li>
|
||||
<li>将剩余 <span class="arithmatex">\(1\)</span> 个圆盘从 <code>A</code> 直接移至 <code>C</code> 。</li>
|
||||
<li>将 <span class="arithmatex">\(n-1\)</span> 个圆盘借助 <code>A</code> 从 <code>B</code> 移至 <code>C</code> 。</li>
|
||||
</ol>
|
||||
<p>对于这两个子问题 <span class="arithmatex">\(f(n-1)\)</span> ，<strong>可以通过相同的方式进行递归划分</strong>，直至达到最小子问题 <span class="arithmatex">\(f(1)\)</span> 。而 <span class="arithmatex">\(f(1)\)</span> 的解是已知的，只需一次移动操作即可。</p>
|
||||
<p><img alt="汉诺塔问题的分治策略" src="../hanota_problem.assets/hanota_divide_and_conquer.png" /></p>
|
||||
|
|
|
|||
|
|
@ -3713,8 +3713,8 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
|||
<p>不难发现，此问题已不满足无后效性，状态转移方程 <span class="arithmatex">\(dp[i] = dp[i-1] + dp[i-2]\)</span> 也失效了，因为 <span class="arithmatex">\(dp[i-1]\)</span> 代表本轮跳 <span class="arithmatex">\(1\)</span> 阶，但其中包含了许多“上一轮跳 <span class="arithmatex">\(1\)</span> 阶上来的”方案，而为了满足约束，我们就不能将 <span class="arithmatex">\(dp[i-1]\)</span> 直接计入 <span class="arithmatex">\(dp[i]\)</span> 中。</p>
|
||||
<p>为此，我们需要扩展状态定义：<strong>状态 <span class="arithmatex">\([i, j]\)</span> 表示处在第 <span class="arithmatex">\(i\)</span> 阶、并且上一轮跳了 <span class="arithmatex">\(j\)</span> 阶</strong>，其中 <span class="arithmatex">\(j \in \{1, 2\}\)</span> 。此状态定义有效地区分了上一轮跳了 <span class="arithmatex">\(1\)</span> 阶还是 <span class="arithmatex">\(2\)</span> 阶，我们可以据此来决定下一步该怎么跳：</p>
|
||||
<ul>
|
||||
<li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(1\)</span> ，即上一轮跳了 <span class="arithmatex">\(1\)</span> 阶时，这一轮只能选择跳 <span class="arithmatex">\(2\)</span> 阶；</li>
|
||||
<li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(2\)</span> ，即上一轮跳了 <span class="arithmatex">\(2\)</span> 阶时，这一轮可选择跳 <span class="arithmatex">\(1\)</span> 阶或跳 <span class="arithmatex">\(2\)</span> 阶；</li>
|
||||
<li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(1\)</span> ，即上一轮跳了 <span class="arithmatex">\(1\)</span> 阶时，这一轮只能选择跳 <span class="arithmatex">\(2\)</span> 阶。</li>
|
||||
<li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(2\)</span> ，即上一轮跳了 <span class="arithmatex">\(2\)</span> 阶时，这一轮可选择跳 <span class="arithmatex">\(1\)</span> 阶或跳 <span class="arithmatex">\(2\)</span> 阶。</li>
|
||||
</ul>
|
||||
<p>在该定义下，<span class="arithmatex">\(dp[i, j]\)</span> 表示状态 <span class="arithmatex">\([i, j]\)</span> 对应的方案数。在该定义下的状态转移方程为：</p>
|
||||
<div class="arithmatex">\[
|
||||
|
|
|
|||
|
|
@ -3522,10 +3522,10 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
|||
<h3 id="_1">方法一：暴力搜索<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>从状态 <span class="arithmatex">\([i, j]\)</span> 开始搜索，不断分解为更小的状态 <span class="arithmatex">\([i-1, j]\)</span> 和 <span class="arithmatex">\([i, j-1]\)</span> ，包括以下递归要素：</p>
|
||||
<ul>
|
||||
<li><strong>递归参数</strong>：状态 <span class="arithmatex">\([i, j]\)</span> ；</li>
|
||||
<li><strong>返回值</strong>：从 <span class="arithmatex">\([0, 0]\)</span> 到 <span class="arithmatex">\([i, j]\)</span> 的最小路径和 <span class="arithmatex">\(dp[i, j]\)</span> ；</li>
|
||||
<li><strong>终止条件</strong>：当 <span class="arithmatex">\(i = 0\)</span> 且 <span class="arithmatex">\(j = 0\)</span> 时，返回代价 <span class="arithmatex">\(grid[0, 0]\)</span> ；</li>
|
||||
<li><strong>剪枝</strong>：当 <span class="arithmatex">\(i < 0\)</span> 时或 <span class="arithmatex">\(j < 0\)</span> 时索引越界，此时返回代价 <span class="arithmatex">\(+\infty\)</span> ，代表不可行；</li>
|
||||
<li><strong>递归参数</strong>：状态 <span class="arithmatex">\([i, j]\)</span> 。</li>
|
||||
<li><strong>返回值</strong>：从 <span class="arithmatex">\([0, 0]\)</span> 到 <span class="arithmatex">\([i, j]\)</span> 的最小路径和 <span class="arithmatex">\(dp[i, j]\)</span> 。</li>
|
||||
<li><strong>终止条件</strong>：当 <span class="arithmatex">\(i = 0\)</span> 且 <span class="arithmatex">\(j = 0\)</span> 时，返回代价 <span class="arithmatex">\(grid[0, 0]\)</span> 。</li>
|
||||
<li><strong>剪枝</strong>：当 <span class="arithmatex">\(i < 0\)</span> 时或 <span class="arithmatex">\(j < 0\)</span> 时索引越界，此时返回代价 <span class="arithmatex">\(+\infty\)</span> ，代表不可行。</li>
|
||||
</ul>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
|
|||
|
|
@ -3402,8 +3402,8 @@
|
|||
<p>每一轮的决策是对字符串 <span class="arithmatex">\(s\)</span> 进行一次编辑操作。</p>
|
||||
<p>我们希望在编辑操作的过程中，问题的规模逐渐缩小，这样才能构建子问题。设字符串 <span class="arithmatex">\(s\)</span> 和 <span class="arithmatex">\(t\)</span> 的长度分别为 <span class="arithmatex">\(n\)</span> 和 <span class="arithmatex">\(m\)</span> ，我们先考虑两字符串尾部的字符 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> ：</p>
|
||||
<ul>
|
||||
<li>若 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> 相同，我们可以跳过它们，直接考虑 <span class="arithmatex">\(s[n-2]\)</span> 和 <span class="arithmatex">\(t[m-2]\)</span> ;</li>
|
||||
<li>若 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> 不同，我们需要对 <span class="arithmatex">\(s\)</span> 进行一次编辑（插入、删除、替换），使得两字符串尾部的字符相同，从而可以跳过它们，考虑规模更小的问题；</li>
|
||||
<li>若 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> 相同，我们可以跳过它们，直接考虑 <span class="arithmatex">\(s[n-2]\)</span> 和 <span class="arithmatex">\(t[m-2]\)</span> 。</li>
|
||||
<li>若 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> 不同，我们需要对 <span class="arithmatex">\(s\)</span> 进行一次编辑（插入、删除、替换），使得两字符串尾部的字符相同，从而可以跳过它们，考虑规模更小的问题。</li>
|
||||
</ul>
|
||||
<p>也就是说，我们在字符串 <span class="arithmatex">\(s\)</span> 中进行的每一轮决策（编辑操作），都会使得 <span class="arithmatex">\(s\)</span> 和 <span class="arithmatex">\(t\)</span> 中剩余的待匹配字符发生变化。因此，状态为当前在 <span class="arithmatex">\(s\)</span> , <span class="arithmatex">\(t\)</span> 中考虑的第 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 个字符，记为 <span class="arithmatex">\([i, j]\)</span> 。</p>
|
||||
<p>状态 <span class="arithmatex">\([i, j]\)</span> 对应的子问题：<strong>将 <span class="arithmatex">\(s\)</span> 的前 <span class="arithmatex">\(i\)</span> 个字符更改为 <span class="arithmatex">\(t\)</span> 的前 <span class="arithmatex">\(j\)</span> 个字符所需的最少编辑步数</strong>。</p>
|
||||
|
|
@ -3411,9 +3411,9 @@
|
|||
<p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
|
||||
<p>考虑子问题 <span class="arithmatex">\(dp[i, j]\)</span> ，其对应的两个字符串的尾部字符为 <span class="arithmatex">\(s[i-1]\)</span> 和 <span class="arithmatex">\(t[j-1]\)</span> ，可根据不同编辑操作分为三种情况：</p>
|
||||
<ol>
|
||||
<li>在 <span class="arithmatex">\(s[i-1]\)</span> 之后添加 <span class="arithmatex">\(t[j-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i, j-1]\)</span> ；</li>
|
||||
<li>删除 <span class="arithmatex">\(s[i-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i-1, j]\)</span> ；</li>
|
||||
<li>将 <span class="arithmatex">\(s[i-1]\)</span> 替换为 <span class="arithmatex">\(t[j-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i-1, j-1]\)</span> ；</li>
|
||||
<li>在 <span class="arithmatex">\(s[i-1]\)</span> 之后添加 <span class="arithmatex">\(t[j-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i, j-1]\)</span> 。</li>
|
||||
<li>删除 <span class="arithmatex">\(s[i-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i-1, j]\)</span> 。</li>
|
||||
<li>将 <span class="arithmatex">\(s[i-1]\)</span> 替换为 <span class="arithmatex">\(t[j-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i-1, j-1]\)</span> 。</li>
|
||||
</ol>
|
||||
<p><img alt="编辑距离的状态转移" src="../edit_distance_problem.assets/edit_distance_state_transfer.png" /></p>
|
||||
<p align="center"> Fig. 编辑距离的状态转移 </p>
|
||||
|
|
|
|||
|
|
@ -3825,8 +3825,8 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
<h2 id="1412">14.1.2. 方法二：记忆化搜索<a class="headerlink" href="#1412" title="Permanent link">¶</a></h2>
|
||||
<p>为了提升算法效率，<strong>我们希望所有的重叠子问题都只被计算一次</strong>。为此，我们声明一个数组 <code>mem</code> 来记录每个子问题的解，并在搜索过程中这样做：</p>
|
||||
<ol>
|
||||
<li>当首次计算 <span class="arithmatex">\(dp[i]\)</span> 时，我们将其记录至 <code>mem[i]</code> ，以便之后使用；</li>
|
||||
<li>当再次需要计算 <span class="arithmatex">\(dp[i]\)</span> 时，我们便可直接从 <code>mem[i]</code> 中获取结果，从而将重叠子问题剪枝；</li>
|
||||
<li>当首次计算 <span class="arithmatex">\(dp[i]\)</span> 时，我们将其记录至 <code>mem[i]</code> ，以便之后使用。</li>
|
||||
<li>当再次需要计算 <span class="arithmatex">\(dp[i]\)</span> 时，我们便可直接从 <code>mem[i]</code> 中获取结果，从而将重叠子问题剪枝。</li>
|
||||
</ol>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:11"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Java</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Python</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">JavaScript</label><label for="__tabbed_3_6">TypeScript</label><label for="__tabbed_3_7">C</label><label for="__tabbed_3_8">C#</label><label for="__tabbed_3_9">Swift</label><label for="__tabbed_3_10">Zig</label><label for="__tabbed_3_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
@ -4191,9 +4191,9 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
<p>与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如，爬楼梯问题的状态定义为当前所在楼梯阶数 <span class="arithmatex">\(i\)</span> 。</p>
|
||||
<p>总结以上，动态规划的常用术语包括：</p>
|
||||
<ul>
|
||||
<li>将数组 <code>dp</code> 称为「<span class="arithmatex">\(dp\)</span> 表」，<span class="arithmatex">\(dp[i]\)</span> 表示状态 <span class="arithmatex">\(i\)</span> 对应子问题的解；</li>
|
||||
<li>将最小子问题对应的状态（即第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 阶楼梯）称为「初始状态」；</li>
|
||||
<li>将递推公式 <span class="arithmatex">\(dp[i] = dp[i-1] + dp[i-2]\)</span> 称为「状态转移方程」；</li>
|
||||
<li>将数组 <code>dp</code> 称为「<span class="arithmatex">\(dp\)</span> 表」，<span class="arithmatex">\(dp[i]\)</span> 表示状态 <span class="arithmatex">\(i\)</span> 对应子问题的解。</li>
|
||||
<li>将最小子问题对应的状态（即第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 阶楼梯）称为「初始状态」。</li>
|
||||
<li>将递推公式 <span class="arithmatex">\(dp[i] = dp[i-1] + dp[i-2]\)</span> 称为「状态转移方程」。</li>
|
||||
</ul>
|
||||
<p><img alt="爬楼梯的动态规划过程" src="../intro_to_dynamic_programming.assets/climbing_stairs_dp.png" /></p>
|
||||
<p align="center"> Fig. 爬楼梯的动态规划过程 </p>
|
||||
|
|
|
|||
|
|
@ -3429,8 +3429,8 @@
|
|||
<p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
|
||||
<p>当我们做出物品 <span class="arithmatex">\(i\)</span> 的决策后，剩余的是前 <span class="arithmatex">\(i-1\)</span> 个物品的决策。因此，状态转移分为两种情况：</p>
|
||||
<ul>
|
||||
<li><strong>不放入物品 <span class="arithmatex">\(i\)</span></strong> ：背包容量不变，状态转移至 <span class="arithmatex">\([i-1, c]\)</span> ；</li>
|
||||
<li><strong>放入物品 <span class="arithmatex">\(i\)</span></strong> ：背包容量减小 <span class="arithmatex">\(wgt[i-1]\)</span> ，价值增加 <span class="arithmatex">\(val[i-1]\)</span> ，状态转移至 <span class="arithmatex">\([i-1, c-wgt[i-1]]\)</span> ；</li>
|
||||
<li><strong>不放入物品 <span class="arithmatex">\(i\)</span></strong> ：背包容量不变，状态转移至 <span class="arithmatex">\([i-1, c]\)</span> 。</li>
|
||||
<li><strong>放入物品 <span class="arithmatex">\(i\)</span></strong> ：背包容量减小 <span class="arithmatex">\(wgt[i-1]\)</span> ，价值增加 <span class="arithmatex">\(val[i-1]\)</span> ，状态转移至 <span class="arithmatex">\([i-1, c-wgt[i-1]]\)</span> 。</li>
|
||||
</ul>
|
||||
<p>上述的状态转移向我们揭示了本题的最优子结构：<strong>最大价值 <span class="arithmatex">\(dp[i, c]\)</span> 等于不放入物品 <span class="arithmatex">\(i\)</span> 和放入物品 <span class="arithmatex">\(i\)</span> 两种方案中的价值更大的那一个</strong>。由此可推出状态转移方程：</p>
|
||||
<div class="arithmatex">\[
|
||||
|
|
@ -3444,10 +3444,10 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
<h3 id="_1">方法一：暴力搜索<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>搜索代码包含以下要素：</p>
|
||||
<ul>
|
||||
<li><strong>递归参数</strong>：状态 <span class="arithmatex">\([i, c]\)</span> ；</li>
|
||||
<li><strong>返回值</strong>：子问题的解 <span class="arithmatex">\(dp[i, c]\)</span> ；</li>
|
||||
<li><strong>终止条件</strong>：当物品编号越界 <span class="arithmatex">\(i = 0\)</span> 或背包剩余容量为 <span class="arithmatex">\(0\)</span> 时，终止递归并返回价值 <span class="arithmatex">\(0\)</span> ；</li>
|
||||
<li><strong>剪枝</strong>：若当前物品重量超出背包剩余容量，则只能不放入背包；</li>
|
||||
<li><strong>递归参数</strong>：状态 <span class="arithmatex">\([i, c]\)</span> 。</li>
|
||||
<li><strong>返回值</strong>：子问题的解 <span class="arithmatex">\(dp[i, c]\)</span> 。</li>
|
||||
<li><strong>终止条件</strong>：当物品编号越界 <span class="arithmatex">\(i = 0\)</span> 或背包剩余容量为 <span class="arithmatex">\(0\)</span> 时，终止递归并返回价值 <span class="arithmatex">\(0\)</span> 。</li>
|
||||
<li><strong>剪枝</strong>：若当前物品重量超出背包剩余容量，则只能不放入背包。</li>
|
||||
</ul>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
|
|||
|
|
@ -3527,13 +3527,13 @@
|
|||
|
||||
<p>完全背包和 0-1 背包问题非常相似，<strong>区别仅在于不限制物品的选择次数</strong>。</p>
|
||||
<ul>
|
||||
<li>在 0-1 背包中，每个物品只有一个，因此将物品 <span class="arithmatex">\(i\)</span> 放入背包后，只能从前 <span class="arithmatex">\(i-1\)</span> 个物品中选择；</li>
|
||||
<li>在完全背包中，每个物品有无数个，因此将物品 <span class="arithmatex">\(i\)</span> 放入背包后，<strong>仍可以从前 <span class="arithmatex">\(i\)</span> 个物品中选择</strong>；</li>
|
||||
<li>在 0-1 背包中，每个物品只有一个，因此将物品 <span class="arithmatex">\(i\)</span> 放入背包后，只能从前 <span class="arithmatex">\(i-1\)</span> 个物品中选择。</li>
|
||||
<li>在完全背包中，每个物品有无数个，因此将物品 <span class="arithmatex">\(i\)</span> 放入背包后，<strong>仍可以从前 <span class="arithmatex">\(i\)</span> 个物品中选择</strong>。</li>
|
||||
</ul>
|
||||
<p>这就导致了状态转移的变化，对于状态 <span class="arithmatex">\([i, c]\)</span> 有：</p>
|
||||
<ul>
|
||||
<li><strong>不放入物品 <span class="arithmatex">\(i\)</span></strong> ：与 0-1 背包相同，转移至 <span class="arithmatex">\([i-1, c]\)</span> ；</li>
|
||||
<li><strong>放入物品 <span class="arithmatex">\(i\)</span></strong> ：与 0-1 背包不同，转移至 <span class="arithmatex">\([i, c-wgt[i-1]]\)</span> ；</li>
|
||||
<li><strong>不放入物品 <span class="arithmatex">\(i\)</span></strong> ：与 0-1 背包相同，转移至 <span class="arithmatex">\([i-1, c]\)</span> 。</li>
|
||||
<li><strong>放入物品 <span class="arithmatex">\(i\)</span></strong> ：与 0-1 背包不同，转移至 <span class="arithmatex">\([i, c-wgt[i-1]]\)</span> 。</li>
|
||||
</ul>
|
||||
<p>从而状态转移方程变为：</p>
|
||||
<div class="arithmatex">\[
|
||||
|
|
@ -3922,9 +3922,9 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
|
|||
|
||||
<p><strong>零钱兑换可以看作是完全背包的一种特殊情况</strong>，两者具有以下联系与不同点：</p>
|
||||
<ul>
|
||||
<li>两道题可以相互转换，“物品”对应于“硬币”、“物品重量”对应于“硬币面值”、“背包容量”对应于“目标金额”；</li>
|
||||
<li>优化目标相反，背包问题是要最大化物品价值，零钱兑换问题是要最小化硬币数量；</li>
|
||||
<li>背包问题是求“不超过”背包容量下的解，零钱兑换是求“恰好”凑到目标金额的解；</li>
|
||||
<li>两道题可以相互转换，“物品”对应于“硬币”、“物品重量”对应于“硬币面值”、“背包容量”对应于“目标金额”。</li>
|
||||
<li>优化目标相反，背包问题是要最大化物品价值，零钱兑换问题是要最小化硬币数量。</li>
|
||||
<li>背包问题是求“不超过”背包容量下的解，零钱兑换是求“恰好”凑到目标金额的解。</li>
|
||||
</ul>
|
||||
<p><strong>第一步：思考每轮的决策，定义状态，从而得到 <span class="arithmatex">\(dp\)</span> 表</strong></p>
|
||||
<p>状态 <span class="arithmatex">\([i, a]\)</span> 对应的子问题为：<strong>前 <span class="arithmatex">\(i\)</span> 个硬币能够凑出金额 <span class="arithmatex">\(a\)</span> 的最少硬币个数</strong>，记为 <span class="arithmatex">\(dp[i, a]\)</span> 。</p>
|
||||
|
|
@ -3932,8 +3932,8 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
|
|||
<p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
|
||||
<p>与完全背包的状态转移方程基本相同，不同点在于：</p>
|
||||
<ul>
|
||||
<li>本题要求最小值，因此需将运算符 <span class="arithmatex">\(\max()\)</span> 更改为 <span class="arithmatex">\(\min()\)</span> ；</li>
|
||||
<li>优化主体是硬币数量而非商品价值，因此在选中硬币时执行 <span class="arithmatex">\(+1\)</span> 即可；</li>
|
||||
<li>本题要求最小值，因此需将运算符 <span class="arithmatex">\(\max()\)</span> 更改为 <span class="arithmatex">\(\min()\)</span> 。</li>
|
||||
<li>优化主体是硬币数量而非商品价值，因此在选中硬币时执行 <span class="arithmatex">\(+1\)</span> 即可。</li>
|
||||
</ul>
|
||||
<div class="arithmatex">\[
|
||||
dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
|
||||
|
|
|
|||
|
|
@ -3457,16 +3457,16 @@ G & = \{ V, E \} \newline
|
|||
<h2 id="911">9.1.1. 图常见类型<a class="headerlink" href="#911" title="Permanent link">¶</a></h2>
|
||||
<p>根据边是否具有方向，可分为「无向图 Undirected Graph」和「有向图 Directed Graph」。</p>
|
||||
<ul>
|
||||
<li>在无向图中，边表示两顶点之间的“双向”连接关系，例如微信或 QQ 中的“好友关系”；</li>
|
||||
<li>在有向图中，边具有方向性，即 <span class="arithmatex">\(A \rightarrow B\)</span> 和 <span class="arithmatex">\(A \leftarrow B\)</span> 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系；</li>
|
||||
<li>在无向图中，边表示两顶点之间的“双向”连接关系，例如微信或 QQ 中的“好友关系”。</li>
|
||||
<li>在有向图中，边具有方向性，即 <span class="arithmatex">\(A \rightarrow B\)</span> 和 <span class="arithmatex">\(A \leftarrow B\)</span> 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系。</li>
|
||||
</ul>
|
||||
<p><img alt="有向图与无向图" src="../graph.assets/directed_graph.png" /></p>
|
||||
<p align="center"> Fig. 有向图与无向图 </p>
|
||||
|
||||
<p>根据所有顶点是否连通，可分为「连通图 Connected Graph」和「非连通图 Disconnected Graph」。</p>
|
||||
<ul>
|
||||
<li>对于连通图，从某个顶点出发，可以到达其余任意顶点；</li>
|
||||
<li>对于非连通图，从某个顶点出发，至少有一个顶点无法到达；</li>
|
||||
<li>对于连通图，从某个顶点出发，可以到达其余任意顶点。</li>
|
||||
<li>对于非连通图，从某个顶点出发，至少有一个顶点无法到达。</li>
|
||||
</ul>
|
||||
<p><img alt="连通图与非连通图" src="../graph.assets/connected_graph.png" /></p>
|
||||
<p align="center"> Fig. 连通图与非连通图 </p>
|
||||
|
|
|
|||
|
|
@ -3468,9 +3468,9 @@
|
|||
<h3 id="_1">算法实现<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>BFS 通常借助「队列」来实现。队列具有“先入先出”的性质，这与 BFS 的“由近及远”的思想异曲同工。</p>
|
||||
<ol>
|
||||
<li>将遍历起始顶点 <code>startVet</code> 加入队列，并开启循环；</li>
|
||||
<li>在循环的每轮迭代中，弹出队首顶点并记录访问，然后将该顶点的所有邻接顶点加入到队列尾部；</li>
|
||||
<li>循环步骤 <code>2.</code> ，直到所有顶点被访问完成后结束；</li>
|
||||
<li>将遍历起始顶点 <code>startVet</code> 加入队列，并开启循环。</li>
|
||||
<li>在循环的每轮迭代中，弹出队首顶点并记录访问，然后将该顶点的所有邻接顶点加入到队列尾部。</li>
|
||||
<li>循环步骤 <code>2.</code> ，直到所有顶点被访问完成后结束。</li>
|
||||
</ol>
|
||||
<p>为了防止重复遍历顶点，我们需要借助一个哈希表 <code>visited</code> 来记录哪些节点已被访问。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
|
|
@ -4133,8 +4133,8 @@
|
|||
</div>
|
||||
<p>深度优先遍历的算法流程如下图所示，其中：</p>
|
||||
<ul>
|
||||
<li><strong>直虚线代表向下递推</strong>，表示开启了一个新的递归方法来访问新顶点；</li>
|
||||
<li><strong>曲虚线代表向上回溯</strong>，表示此递归方法已经返回，回溯到了开启此递归方法的位置；</li>
|
||||
<li><strong>直虚线代表向下递推</strong>，表示开启了一个新的递归方法来访问新顶点。</li>
|
||||
<li><strong>曲虚线代表向上回溯</strong>，表示此递归方法已经返回，回溯到了开启此递归方法的位置。</li>
|
||||
</ul>
|
||||
<p>为了加深理解，建议将图示与代码结合起来，在脑中（或者用笔画下来）模拟整个 DFS 过程，包括每个递归方法何时开启、何时返回。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:11"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1"><1></label><label for="__tabbed_4_2"><2></label><label for="__tabbed_4_3"><3></label><label for="__tabbed_4_4"><4></label><label for="__tabbed_4_5"><5></label><label for="__tabbed_4_6"><6></label><label for="__tabbed_4_7"><7></label><label for="__tabbed_4_8"><8></label><label for="__tabbed_4_9"><9></label><label for="__tabbed_4_10"><10></label><label for="__tabbed_4_11"><11></label></div>
|
||||
|
|
|
|||
|
|
@ -3407,8 +3407,8 @@
|
|||
<p>本题和 0-1 背包整体上非常相似，状态包含当前物品 <span class="arithmatex">\(i\)</span> 和容量 <span class="arithmatex">\(c\)</span> ，目标是求不超过背包容量下的最大价值。</p>
|
||||
<p>不同点在于，本题允许只选择物品的一部分，<strong>这意味着可以对物品任意地进行切分，并按照重量比例来计算物品价值</strong>，因此有：</p>
|
||||
<ol>
|
||||
<li>对于物品 <span class="arithmatex">\(i\)</span> ，它在单位重量下的价值为 <span class="arithmatex">\(val[i-1] / wgt[i-1]\)</span> ，简称为单位价值；</li>
|
||||
<li>假设放入一部分物品 <span class="arithmatex">\(i\)</span> ，重量为 <span class="arithmatex">\(w\)</span> ，则背包增加的价值为 <span class="arithmatex">\(w \times val[i-1] / wgt[i-1]\)</span> ；</li>
|
||||
<li>对于物品 <span class="arithmatex">\(i\)</span> ，它在单位重量下的价值为 <span class="arithmatex">\(val[i-1] / wgt[i-1]\)</span> ，简称为单位价值。</li>
|
||||
<li>假设放入一部分物品 <span class="arithmatex">\(i\)</span> ，重量为 <span class="arithmatex">\(w\)</span> ，则背包增加的价值为 <span class="arithmatex">\(w \times val[i-1] / wgt[i-1]\)</span> 。</li>
|
||||
</ol>
|
||||
<p><img alt="物品在单位重量下的价值" src="../fractional_knapsack_problem.assets/fractional_knapsack_unit_value.png" /></p>
|
||||
<p align="center"> Fig. 物品在单位重量下的价值 </p>
|
||||
|
|
|
|||
|
|
@ -3418,8 +3418,8 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
|
|||
|
||||
<p>我们发现，<strong>如果此时将长板 <span class="arithmatex">\(j\)</span> 向短板 <span class="arithmatex">\(i\)</span> 靠近，则容量一定变小</strong>。这是因为在移动长板 <span class="arithmatex">\(j\)</span> 后：</p>
|
||||
<ul>
|
||||
<li>宽度 <span class="arithmatex">\(j-i\)</span> 肯定变小；</li>
|
||||
<li>高度由短板决定，因此高度只可能不变（ <span class="arithmatex">\(i\)</span> 仍为短板）或变小（移动后的 <span class="arithmatex">\(j\)</span> 成为短板）；</li>
|
||||
<li>宽度 <span class="arithmatex">\(j-i\)</span> 肯定变小。</li>
|
||||
<li>高度由短板决定，因此高度只可能不变（ <span class="arithmatex">\(i\)</span> 仍为短板）或变小（移动后的 <span class="arithmatex">\(j\)</span> 成为短板）。</li>
|
||||
</ul>
|
||||
<p><img alt="向内移动长板后的状态" src="../max_capacity_problem.assets/max_capacity_moving_long_board.png" /></p>
|
||||
<p align="center"> Fig. 向内移动长板后的状态 </p>
|
||||
|
|
|
|||
|
|
@ -3588,7 +3588,7 @@ n = 3 a + b
|
|||
|
||||
<p><strong>时间复杂度取决于编程语言的幂运算的实现方法</strong>。以 Python 为例，常用的幂计算函数有三种：</p>
|
||||
<ul>
|
||||
<li>运算符 <code>**</code> 和函数 <code>pow()</code> 的时间复杂度均为 <span class="arithmatex">\(O(\log a)\)</span> ；</li>
|
||||
<li>运算符 <code>**</code> 和函数 <code>pow()</code> 的时间复杂度均为 <span class="arithmatex">\(O(\log a)\)</span> 。</li>
|
||||
<li>函数 <code>math.pow()</code> 内部调用 C 语言库的 <code>pow()</code> 函数，其执行浮点取幂，时间复杂度为 <span class="arithmatex">\(O(1)\)</span> 。</li>
|
||||
</ul>
|
||||
<p>变量 <span class="arithmatex">\(a\)</span> , <span class="arithmatex">\(b\)</span> 使用常数大小的额外空间，<strong>因此空间复杂度为 <span class="arithmatex">\(O(1)\)</span></strong> 。</p>
|
||||
|
|
|
|||
|
|
@ -3395,9 +3395,9 @@
|
|||
|
||||
<p>除哈希表外，我们还可以使用数组或链表实现查询功能。若将学生数据看作数组（链表）元素，则有：</p>
|
||||
<ul>
|
||||
<li><strong>添加元素</strong>：仅需将元素添加至数组（链表）的尾部即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间；</li>
|
||||
<li><strong>查询元素</strong>：由于数组（链表）是乱序的，因此需要遍历其中的所有元素，使用 <span class="arithmatex">\(O(n)\)</span> 时间；</li>
|
||||
<li><strong>删除元素</strong>：需要先查询到元素，再从数组中删除，使用 <span class="arithmatex">\(O(n)\)</span> 时间；</li>
|
||||
<li><strong>添加元素</strong>：仅需将元素添加至数组（链表）的尾部即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间。</li>
|
||||
<li><strong>查询元素</strong>：由于数组（链表）是乱序的，因此需要遍历其中的所有元素，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
|
||||
<li><strong>删除元素</strong>：需要先查询到元素，再从数组中删除，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
|
||||
</ul>
|
||||
<div class="center-table">
|
||||
<table>
|
||||
|
|
@ -3799,8 +3799,8 @@
|
|||
<p>那么，如何基于 <code>key</code> 来定位对应的桶呢？这是通过「哈希函数 Hash Function」实现的。哈希函数的作用是将一个较大的输入空间映射到一个较小的输出空间。在哈希表中，输入空间是所有 <code>key</code> ，输出空间是所有桶（数组索引）。换句话说，输入一个 <code>key</code> ，<strong>我们可以通过哈希函数得到该 <code>key</code> 对应的键值对在数组中的存储位置</strong>。</p>
|
||||
<p>输入一个 <code>key</code> ，哈希函数的计算过程分为两步：</p>
|
||||
<ol>
|
||||
<li>通过某种哈希算法 <code>hash()</code> 计算得到哈希值；</li>
|
||||
<li>将哈希值对桶数量（数组长度）<code>capacity</code> 取模，从而获取该 <code>key</code> 对应的数组索引 <code>index</code> ；</li>
|
||||
<li>通过某种哈希算法 <code>hash()</code> 计算得到哈希值。</li>
|
||||
<li>将哈希值对桶数量（数组长度）<code>capacity</code> 取模，从而获取该 <code>key</code> 对应的数组索引 <code>index</code> 。</li>
|
||||
</ol>
|
||||
<div class="highlight"><pre><span></span><code><a id="__codelineno-22-1" name="__codelineno-22-1" href="#__codelineno-22-1"></a><span class="nv">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span>hash<span class="o">(</span>key<span class="o">)</span><span class="w"> </span>%<span class="w"> </span>capacity
|
||||
</code></pre></div>
|
||||
|
|
|
|||
|
|
@ -3539,8 +3539,8 @@
|
|||
<h2 id="823">8.2.3. 复杂度分析<a class="headerlink" href="#823" title="Permanent link">¶</a></h2>
|
||||
<p>为什么第二种建堆方法的时间复杂度是 <span class="arithmatex">\(O(n)\)</span> ？我们来展开推算一下。</p>
|
||||
<ul>
|
||||
<li>完全二叉树中，设节点总数为 <span class="arithmatex">\(n\)</span> ，则叶节点数量为 <span class="arithmatex">\((n + 1) / 2\)</span> ，其中 <span class="arithmatex">\(/\)</span> 为向下整除。因此，在排除叶节点后，需要堆化的节点数量为 <span class="arithmatex">\((n - 1)/2\)</span> ，复杂度为 <span class="arithmatex">\(O(n)\)</span> ；</li>
|
||||
<li>在从顶至底堆化的过程中，每个节点最多堆化到叶节点，因此最大迭代次数为二叉树高度 <span class="arithmatex">\(O(\log n)\)</span> ；</li>
|
||||
<li>完全二叉树中，设节点总数为 <span class="arithmatex">\(n\)</span> ，则叶节点数量为 <span class="arithmatex">\((n + 1) / 2\)</span> ，其中 <span class="arithmatex">\(/\)</span> 为向下整除。因此，在排除叶节点后，需要堆化的节点数量为 <span class="arithmatex">\((n - 1)/2\)</span> ，复杂度为 <span class="arithmatex">\(O(n)\)</span> 。</li>
|
||||
<li>在从顶至底堆化的过程中，每个节点最多堆化到叶节点，因此最大迭代次数为二叉树高度 <span class="arithmatex">\(O(\log n)\)</span> 。</li>
|
||||
</ul>
|
||||
<p>将上述两者相乘，可得到建堆过程的时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> 。<strong>然而，这个估算结果并不准确，因为我们没有考虑到二叉树底层节点数量远多于顶层节点的特性</strong>。</p>
|
||||
<p>接下来我们来进行更为详细的计算。为了减小计算难度，我们假设树是一个“完美二叉树”，该假设不会影响计算结果的正确性。设二叉树（即堆）节点数量为 <span class="arithmatex">\(n\)</span> ，树高度为 <span class="arithmatex">\(h\)</span> 。上文提到，<strong>节点堆化最大迭代次数等于该节点到叶节点的距离，而该距离正是“节点高度”</strong>。</p>
|
||||
|
|
|
|||
|
|
@ -3458,8 +3458,8 @@
|
|||
<h1 id="81">8.1. 堆<a class="headerlink" href="#81" title="Permanent link">¶</a></h1>
|
||||
<p>「堆 Heap」是一种满足特定条件的完全二叉树，可分为两种类型：</p>
|
||||
<ul>
|
||||
<li>「大顶堆 Max Heap」，任意节点的值 <span class="arithmatex">\(\geq\)</span> 其子节点的值；</li>
|
||||
<li>「小顶堆 Min Heap」，任意节点的值 <span class="arithmatex">\(\leq\)</span> 其子节点的值；</li>
|
||||
<li>「大顶堆 Max Heap」，任意节点的值 <span class="arithmatex">\(\geq\)</span> 其子节点的值。</li>
|
||||
<li>「小顶堆 Min Heap」，任意节点的值 <span class="arithmatex">\(\leq\)</span> 其子节点的值。</li>
|
||||
</ul>
|
||||
<p><img alt="小顶堆与大顶堆" src="../heap.assets/min_heap_and_max_heap.png" /></p>
|
||||
<p align="center"> Fig. 小顶堆与大顶堆 </p>
|
||||
|
|
@ -4359,9 +4359,9 @@
|
|||
<h3 id="_4">堆顶元素出堆<a class="headerlink" href="#_4" title="Permanent link">¶</a></h3>
|
||||
<p>堆顶元素是二叉树的根节点，即列表首元素。如果我们直接从列表中删除首元素，那么二叉树中所有节点的索引都会发生变化，这将使得后续使用堆化修复变得困难。为了尽量减少元素索引的变动，我们采取以下操作步骤：</p>
|
||||
<ol>
|
||||
<li>交换堆顶元素与堆底元素（即交换根节点与最右叶节点）；</li>
|
||||
<li>交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）；</li>
|
||||
<li>从根节点开始，<strong>从顶至底执行堆化</strong>；</li>
|
||||
<li>交换堆顶元素与堆底元素（即交换根节点与最右叶节点）。</li>
|
||||
<li>交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）。</li>
|
||||
<li>从根节点开始，<strong>从顶至底执行堆化</strong>。</li>
|
||||
</ol>
|
||||
<p>顾名思义，<strong>从顶至底堆化的操作方向与从底至顶堆化相反</strong>，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无需交换的节点时结束。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="6:10"><input checked="checked" id="__tabbed_6_1" name="__tabbed_6" type="radio" /><input id="__tabbed_6_2" name="__tabbed_6" type="radio" /><input id="__tabbed_6_3" name="__tabbed_6" type="radio" /><input id="__tabbed_6_4" name="__tabbed_6" type="radio" /><input id="__tabbed_6_5" name="__tabbed_6" type="radio" /><input id="__tabbed_6_6" name="__tabbed_6" type="radio" /><input id="__tabbed_6_7" name="__tabbed_6" type="radio" /><input id="__tabbed_6_8" name="__tabbed_6" type="radio" /><input id="__tabbed_6_9" name="__tabbed_6" type="radio" /><input id="__tabbed_6_10" name="__tabbed_6" type="radio" /><div class="tabbed-labels"><label for="__tabbed_6_1"><1></label><label for="__tabbed_6_2"><2></label><label for="__tabbed_6_3"><3></label><label for="__tabbed_6_4"><4></label><label for="__tabbed_6_5"><5></label><label for="__tabbed_6_6"><6></label><label for="__tabbed_6_7"><7></label><label for="__tabbed_6_8"><8></label><label for="__tabbed_6_9"><9></label><label for="__tabbed_6_10"><10></label></div>
|
||||
|
|
|
|||
|
|
@ -3412,10 +3412,10 @@
|
|||
<h2 id="833">8.3.3. 方法三：堆<a class="headerlink" href="#833" title="Permanent link">¶</a></h2>
|
||||
<p>我们可以基于堆更加高效地解决 Top-K 问题，流程如下：</p>
|
||||
<ol>
|
||||
<li>初始化一个小顶堆，其堆顶元素最小；</li>
|
||||
<li>先将数组的前 <span class="arithmatex">\(k\)</span> 个元素依次入堆；</li>
|
||||
<li>从第 <span class="arithmatex">\(k + 1\)</span> 个元素开始，若当前元素大于堆顶元素，则将堆顶元素出堆，并将当前元素入堆；</li>
|
||||
<li>遍历完成后，堆中保存的就是最大的 <span class="arithmatex">\(k\)</span> 个元素；</li>
|
||||
<li>初始化一个小顶堆，其堆顶元素最小。</li>
|
||||
<li>先将数组的前 <span class="arithmatex">\(k\)</span> 个元素依次入堆。</li>
|
||||
<li>从第 <span class="arithmatex">\(k + 1\)</span> 个元素开始，若当前元素大于堆顶元素，则将堆顶元素出堆，并将当前元素入堆。</li>
|
||||
<li>遍历完成后，堆中保存的就是最大的 <span class="arithmatex">\(k\)</span> 个元素。</li>
|
||||
</ol>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:9"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
|
|||
|
|
@ -3390,9 +3390,9 @@
|
|||
<h1 id="01">0.1. 关于本书<a class="headerlink" href="#01" title="Permanent link">¶</a></h1>
|
||||
<p>本项目旨在创建一本开源免费、新手友好的数据结构与算法入门教程。</p>
|
||||
<ul>
|
||||
<li>全书采用动画图解，结构化地讲解数据结构与算法知识，内容清晰易懂、学习曲线平滑；</li>
|
||||
<li>算法源代码皆可一键运行，支持 Java, C++, Python, Go, JS, TS, C#, Swift, Zig 等语言；</li>
|
||||
<li>鼓励读者在章节讨论区互帮互助、共同进步，提问与评论通常可在两日内得到回复；</li>
|
||||
<li>全书采用动画图解，结构化地讲解数据结构与算法知识，内容清晰易懂、学习曲线平滑。</li>
|
||||
<li>算法源代码皆可一键运行，支持 Java, C++, Python, Go, JS, TS, C#, Swift, Zig 等语言。</li>
|
||||
<li>鼓励读者在章节讨论区互帮互助、共同进步，提问与评论通常可在两日内得到回复。</li>
|
||||
</ul>
|
||||
<h2 id="011">0.1.1. 读者对象<a class="headerlink" href="#011" title="Permanent link">¶</a></h2>
|
||||
<p>若您是算法初学者，从未接触过算法，或者已经有一些刷题经验，对数据结构与算法有模糊的认识，在会与不会之间反复横跳，那么这本书正是为您量身定制！</p>
|
||||
|
|
|
|||
|
|
@ -3384,9 +3384,9 @@
|
|||
<ol>
|
||||
<li>计算中点索引 <span class="arithmatex">\(m = \lfloor {(i + j) / 2} \rfloor\)</span> ，其中 <span class="arithmatex">\(\lfloor \space \rfloor\)</span> 表示向下取整操作。</li>
|
||||
<li>判断 <code>nums[m]</code> 和 <code>target</code> 的大小关系，分为三种情况：<ol>
|
||||
<li>当 <code>nums[m] < target</code> 时，说明 <code>target</code> 在区间 <span class="arithmatex">\([m + 1, j]\)</span> 中，因此执行 <span class="arithmatex">\(i = m + 1\)</span> ；</li>
|
||||
<li>当 <code>nums[m] > target</code> 时，说明 <code>target</code> 在区间 <span class="arithmatex">\([i, m - 1]\)</span> 中，因此执行 <span class="arithmatex">\(j = m - 1\)</span> ；</li>
|
||||
<li>当 <code>nums[m] = target</code> 时，说明找到 <code>target</code> ，因此返回索引 <span class="arithmatex">\(m\)</span> ；</li>
|
||||
<li>当 <code>nums[m] < target</code> 时，说明 <code>target</code> 在区间 <span class="arithmatex">\([m + 1, j]\)</span> 中，因此执行 <span class="arithmatex">\(i = m + 1\)</span> 。</li>
|
||||
<li>当 <code>nums[m] > target</code> 时，说明 <code>target</code> 在区间 <span class="arithmatex">\([i, m - 1]\)</span> 中，因此执行 <span class="arithmatex">\(j = m - 1\)</span> 。</li>
|
||||
<li>当 <code>nums[m] = target</code> 时，说明找到 <code>target</code> ，因此返回索引 <span class="arithmatex">\(m\)</span> 。</li>
|
||||
</ol>
|
||||
</li>
|
||||
</ol>
|
||||
|
|
|
|||
|
|
@ -3396,7 +3396,7 @@
|
|||
<h2 id="1021">10.2.1. 线性方法<a class="headerlink" href="#1021" title="Permanent link">¶</a></h2>
|
||||
<p>为了查找数组中最左边的 <code>target</code> ，我们可以分为两步：</p>
|
||||
<ol>
|
||||
<li>进行二分查找，定位到任意一个 <code>target</code> 的索引，记为 <span class="arithmatex">\(k\)</span> ；</li>
|
||||
<li>进行二分查找，定位到任意一个 <code>target</code> 的索引，记为 <span class="arithmatex">\(k\)</span> 。</li>
|
||||
<li>以索引 <span class="arithmatex">\(k\)</span> 为起始点，向左进行线性遍历，找到最左边的 <code>target</code> 返回即可。</li>
|
||||
</ol>
|
||||
<p><img alt="线性查找最左边的元素" src="../binary_search_edge.assets/binary_search_left_edge_naive.png" /></p>
|
||||
|
|
|
|||
|
|
@ -3560,8 +3560,8 @@
|
|||
<h2 id="1032">10.3.2. 哈希查找：以空间换时间<a class="headerlink" href="#1032" title="Permanent link">¶</a></h2>
|
||||
<p>考虑借助一个哈希表，键值对分别为数组元素和元素索引。循环遍历数组，每轮执行：</p>
|
||||
<ol>
|
||||
<li>判断数字 <code>target - nums[i]</code> 是否在哈希表中，若是则直接返回这两个元素的索引；</li>
|
||||
<li>将键值对 <code>nums[i]</code> 和索引 <code>i</code> 添加进哈希表；</li>
|
||||
<li>判断数字 <code>target - nums[i]</code> 是否在哈希表中，若是则直接返回这两个元素的索引。</li>
|
||||
<li>将键值对 <code>nums[i]</code> 和索引 <code>i</code> 添加进哈希表。</li>
|
||||
</ol>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:3"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
|
|||
|
|
@ -3393,9 +3393,9 @@
|
|||
<h2 id="1181">11.8.1. 算法流程<a class="headerlink" href="#1181" title="Permanent link">¶</a></h2>
|
||||
<p>考虑一个长度为 <span class="arithmatex">\(n\)</span> 的数组，元素是范围 <span class="arithmatex">\([0, 1)\)</span> 的浮点数。桶排序的流程如下：</p>
|
||||
<ol>
|
||||
<li>初始化 <span class="arithmatex">\(k\)</span> 个桶，将 <span class="arithmatex">\(n\)</span> 个元素分配到 <span class="arithmatex">\(k\)</span> 个桶中；</li>
|
||||
<li>对每个桶分别执行排序（本文采用编程语言的内置排序函数）；</li>
|
||||
<li>按照桶的从小到大的顺序，合并结果；</li>
|
||||
<li>初始化 <span class="arithmatex">\(k\)</span> 个桶，将 <span class="arithmatex">\(n\)</span> 个元素分配到 <span class="arithmatex">\(k\)</span> 个桶中。</li>
|
||||
<li>对每个桶分别执行排序（本文采用编程语言的内置排序函数）。</li>
|
||||
<li>按照桶的从小到大的顺序，合并结果。</li>
|
||||
</ol>
|
||||
<p><img alt="桶排序算法流程" src="../bucket_sort.assets/bucket_sort_overview.png" /></p>
|
||||
<p align="center"> Fig. 桶排序算法流程 </p>
|
||||
|
|
|
|||
|
|
@ -3406,7 +3406,7 @@
|
|||
<h2 id="1191">11.9.1. 简单实现<a class="headerlink" href="#1191" title="Permanent link">¶</a></h2>
|
||||
<p>先来看一个简单的例子。给定一个长度为 <span class="arithmatex">\(n\)</span> 的数组 <code>nums</code> ，其中的元素都是“非负整数”。计数排序的整体流程如下：</p>
|
||||
<ol>
|
||||
<li>遍历数组，找出数组中的最大数字，记为 <span class="arithmatex">\(m\)</span> ，然后创建一个长度为 <span class="arithmatex">\(m + 1\)</span> 的辅助数组 <code>counter</code> ；</li>
|
||||
<li>遍历数组，找出数组中的最大数字，记为 <span class="arithmatex">\(m\)</span> ，然后创建一个长度为 <span class="arithmatex">\(m + 1\)</span> 的辅助数组 <code>counter</code> 。</li>
|
||||
<li><strong>借助 <code>counter</code> 统计 <code>nums</code> 中各数字的出现次数</strong>，其中 <code>counter[num]</code> 对应数字 <code>num</code> 的出现次数。统计方法很简单，只需遍历 <code>nums</code>（设当前数字为 <code>num</code>），每轮将 <code>counter[num]</code> 增加 <span class="arithmatex">\(1\)</span> 即可。</li>
|
||||
<li><strong>由于 <code>counter</code> 的各个索引天然有序，因此相当于所有数字已经被排序好了</strong>。接下来，我们遍历 <code>counter</code> ，根据各数字的出现次数，将它们按从小到大的顺序填入 <code>nums</code> 即可。</li>
|
||||
</ol>
|
||||
|
|
@ -3681,8 +3681,8 @@
|
|||
\]</div>
|
||||
<p><strong>前缀和具有明确的意义，<code>prefix[num] - 1</code> 代表元素 <code>num</code> 在结果数组 <code>res</code> 中最后一次出现的索引</strong>。这个信息非常关键，因为它告诉我们各个元素应该出现在结果数组的哪个位置。接下来，我们倒序遍历原数组 <code>nums</code> 的每个元素 <code>num</code> ，在每轮迭代中执行：</p>
|
||||
<ol>
|
||||
<li>将 <code>num</code> 填入数组 <code>res</code> 的索引 <code>prefix[num] - 1</code> 处；</li>
|
||||
<li>令前缀和 <code>prefix[num]</code> 减小 <span class="arithmatex">\(1\)</span> ，从而得到下次放置 <code>num</code> 的索引；</li>
|
||||
<li>将 <code>num</code> 填入数组 <code>res</code> 的索引 <code>prefix[num] - 1</code> 处。</li>
|
||||
<li>令前缀和 <code>prefix[num]</code> 减小 <span class="arithmatex">\(1\)</span> ，从而得到下次放置 <code>num</code> 的索引。</li>
|
||||
</ol>
|
||||
<p>遍历完成后，数组 <code>res</code> 中就是排序好的结果，最后使用 <code>res</code> 覆盖原数组 <code>nums</code> 即可。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:8"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label><label for="__tabbed_2_5"><5></label><label for="__tabbed_2_6"><6></label><label for="__tabbed_2_7"><7></label><label for="__tabbed_2_8"><8></label></div>
|
||||
|
|
|
|||
|
|
@ -3390,17 +3390,17 @@
|
|||
<h1 id="116">11.6. 归并排序<a class="headerlink" href="#116" title="Permanent link">¶</a></h1>
|
||||
<p>「归并排序 Merge Sort」基于分治思想实现排序，包含“划分”和“合并”两个阶段：</p>
|
||||
<ol>
|
||||
<li><strong>划分阶段</strong>：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题；</li>
|
||||
<li><strong>合并阶段</strong>：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束；</li>
|
||||
<li><strong>划分阶段</strong>：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题。</li>
|
||||
<li><strong>合并阶段</strong>：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束。</li>
|
||||
</ol>
|
||||
<p><img alt="归并排序的划分与合并阶段" src="../merge_sort.assets/merge_sort_overview.png" /></p>
|
||||
<p align="center"> Fig. 归并排序的划分与合并阶段 </p>
|
||||
|
||||
<h2 id="1161">11.6.1. 算法流程<a class="headerlink" href="#1161" title="Permanent link">¶</a></h2>
|
||||
<p>“划分阶段”从顶至底递归地将数组从中点切为两个子数组，直至长度为 1 ；</p>
|
||||
<p>“划分阶段”从顶至底递归地将数组从中点切为两个子数组：</p>
|
||||
<ol>
|
||||
<li>计算数组中点 <code>mid</code> ，递归划分左子数组（区间 <code>[left, mid]</code> ）和右子数组（区间 <code>[mid + 1, right]</code> ）；</li>
|
||||
<li>递归执行步骤 <code>1.</code> ，直至子数组区间长度为 1 时，终止递归划分；</li>
|
||||
<li>计算数组中点 <code>mid</code> ，递归划分左子数组（区间 <code>[left, mid]</code> ）和右子数组（区间 <code>[mid + 1, right]</code> ）。</li>
|
||||
<li>递归执行步骤 <code>1.</code> ，直至子数组区间长度为 1 时，终止递归划分。</li>
|
||||
</ol>
|
||||
<p>“合并阶段”从底至顶地将左子数组和右子数组合并为一个有序数组。需要注意的是，从长度为 1 的子数组开始合并，合并阶段中的每个子数组都是有序的。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:10"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label><label for="__tabbed_1_10"><10></label></div>
|
||||
|
|
@ -3952,7 +3952,7 @@
|
|||
<p>归并排序在排序链表时具有显著优势，空间复杂度可以优化至 <span class="arithmatex">\(O(1)\)</span> ，原因如下：</p>
|
||||
<ul>
|
||||
<li>由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无需创建辅助链表。</li>
|
||||
<li>通过使用“迭代划分”替代“递归划分”，可省去递归使用的栈帧空间；</li>
|
||||
<li>通过使用“迭代划分”替代“递归划分”，可省去递归使用的栈帧空间。</li>
|
||||
</ul>
|
||||
<p>具体实现细节比较复杂，有兴趣的同学可以查阅相关资料进行学习。</p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3419,9 +3419,9 @@
|
|||
<p>「快速排序 Quick Sort」是一种基于分治思想的排序算法，运行高效，应用广泛。</p>
|
||||
<p>快速排序的核心操作是「哨兵划分」，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。具体来说，哨兵划分的流程为：</p>
|
||||
<ol>
|
||||
<li>选取数组最左端元素作为基准数，初始化两个指针 <code>i</code> 和 <code>j</code> 分别指向数组的两端；</li>
|
||||
<li>设置一个循环，在每轮中使用 <code>i</code>（<code>j</code>）分别寻找第一个比基准数大（小）的元素，然后交换这两个元素；</li>
|
||||
<li>循环执行步骤 <code>2.</code> ，直到 <code>i</code> 和 <code>j</code> 相遇时停止，最后将基准数交换至两个子数组的分界线；</li>
|
||||
<li>选取数组最左端元素作为基准数，初始化两个指针 <code>i</code> 和 <code>j</code> 分别指向数组的两端。</li>
|
||||
<li>设置一个循环，在每轮中使用 <code>i</code>（<code>j</code>）分别寻找第一个比基准数大（小）的元素，然后交换这两个元素。</li>
|
||||
<li>循环执行步骤 <code>2.</code> ，直到 <code>i</code> 和 <code>j</code> 相遇时停止，最后将基准数交换至两个子数组的分界线。</li>
|
||||
</ol>
|
||||
<p>哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 <span class="arithmatex">\(\leq\)</span> 基准数 <span class="arithmatex">\(\leq\)</span> 右子数组任意元素”。因此，我们接下来只需对这两个子数组进行排序。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:9"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label></div>
|
||||
|
|
@ -3735,9 +3735,9 @@
|
|||
</div>
|
||||
<h2 id="1151">11.5.1. 算法流程<a class="headerlink" href="#1151" title="Permanent link">¶</a></h2>
|
||||
<ol>
|
||||
<li>首先，对原数组执行一次「哨兵划分」，得到未排序的左子数组和右子数组；</li>
|
||||
<li>然后，对左子数组和右子数组分别递归执行「哨兵划分」；</li>
|
||||
<li>持续递归，直至子数组长度为 1 时终止，从而完成整个数组的排序；</li>
|
||||
<li>首先，对原数组执行一次「哨兵划分」，得到未排序的左子数组和右子数组。</li>
|
||||
<li>然后，对左子数组和右子数组分别递归执行「哨兵划分」。</li>
|
||||
<li>持续递归，直至子数组长度为 1 时终止，从而完成整个数组的排序。</li>
|
||||
</ol>
|
||||
<p><img alt="快速排序流程" src="../quick_sort.assets/quick_sort_overview.png" /></p>
|
||||
<p align="center"> Fig. 快速排序流程 </p>
|
||||
|
|
|
|||
|
|
@ -3379,9 +3379,9 @@
|
|||
<h2 id="11101">11.10.1. 算法流程<a class="headerlink" href="#11101" title="Permanent link">¶</a></h2>
|
||||
<p>以学号数据为例，假设数字的最低位是第 <span class="arithmatex">\(1\)</span> 位，最高位是第 <span class="arithmatex">\(8\)</span> 位，基数排序的步骤如下：</p>
|
||||
<ol>
|
||||
<li>初始化位数 <span class="arithmatex">\(k = 1\)</span> ；</li>
|
||||
<li>对学号的第 <span class="arithmatex">\(k\)</span> 位执行「计数排序」。完成后，数据会根据第 <span class="arithmatex">\(k\)</span> 位从小到大排序；</li>
|
||||
<li>将 <span class="arithmatex">\(k\)</span> 增加 <span class="arithmatex">\(1\)</span> ，然后返回步骤 <code>2.</code> 继续迭代，直到所有位都排序完成后结束；</li>
|
||||
<li>初始化位数 <span class="arithmatex">\(k = 1\)</span> 。</li>
|
||||
<li>对学号的第 <span class="arithmatex">\(k\)</span> 位执行「计数排序」。完成后，数据会根据第 <span class="arithmatex">\(k\)</span> 位从小到大排序。</li>
|
||||
<li>将 <span class="arithmatex">\(k\)</span> 增加 <span class="arithmatex">\(1\)</span> ，然后返回步骤 <code>2.</code> 继续迭代，直到所有位都排序完成后结束。</li>
|
||||
</ol>
|
||||
<p><img alt="基数排序算法流程" src="../radix_sort.assets/radix_sort_overview.png" /></p>
|
||||
<p align="center"> Fig. 基数排序算法流程 </p>
|
||||
|
|
|
|||
|
|
@ -4494,8 +4494,8 @@
|
|||
<p>我们可以使用一个变量 <code>front</code> 指向队首元素的索引，并维护一个变量 <code>queSize</code> 用于记录队列长度。定义 <code>rear = front + queSize</code> ，这个公式计算出的 <code>rear</code> 指向队尾元素之后的下一个位置。</p>
|
||||
<p>基于此设计，<strong>数组中包含元素的有效区间为 [front, rear - 1]</strong>，进而：</p>
|
||||
<ul>
|
||||
<li>对于入队操作，将输入元素赋值给 <code>rear</code> 索引处，并将 <code>queSize</code> 增加 1 ；</li>
|
||||
<li>对于出队操作，只需将 <code>front</code> 增加 1 ，并将 <code>queSize</code> 减少 1 ；</li>
|
||||
<li>对于入队操作，将输入元素赋值给 <code>rear</code> 索引处，并将 <code>queSize</code> 增加 1 。</li>
|
||||
<li>对于出队操作，只需将 <code>front</code> 增加 1 ，并将 <code>queSize</code> 减少 1 。</li>
|
||||
</ul>
|
||||
<p>可以看到，入队和出队操作都只需进行一次操作，时间复杂度均为 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:3"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">ArrayQueue</label><label for="__tabbed_4_2">push()</label><label for="__tabbed_4_3">pop()</label></div>
|
||||
|
|
|
|||
|
|
@ -4997,8 +4997,8 @@
|
|||
<p>在链表实现中，链表的扩容非常灵活，不存在上述数组扩容时效率降低的问题。但是，入栈操作需要初始化节点对象并修改指针，因此效率相对较低。不过，如果入栈元素本身就是节点对象，那么可以省去初始化步骤，从而提高效率。</p>
|
||||
<p>综上所述，当入栈与出栈操作的元素是基本数据类型（如 <code>int</code> , <code>double</code> ）时，我们可以得出以下结论：</p>
|
||||
<ul>
|
||||
<li>基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高；</li>
|
||||
<li>基于链表实现的栈可以提供更加稳定的效率表现；</li>
|
||||
<li>基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。</li>
|
||||
<li>基于链表实现的栈可以提供更加稳定的效率表现。</li>
|
||||
</ul>
|
||||
<h3 id="_5">空间效率<a class="headerlink" href="#_5" title="Permanent link">¶</a></h3>
|
||||
<p>在初始化列表时，系统会为列表分配“初始容量”，该容量可能超过实际需求。并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容，扩容后的容量也可能超出实际需求。因此，<strong>基于数组实现的栈可能造成一定的空间浪费</strong>。</p>
|
||||
|
|
|
|||
|
|
@ -3480,8 +3480,8 @@
|
|||
|
||||
<p>如下代码给出了数组表示下的二叉树的简单实现，包括以下操作：</p>
|
||||
<ul>
|
||||
<li>给定某节点，获取它的值、左（右）子节点、父节点；</li>
|
||||
<li>获取前序遍历、中序遍历、后序遍历、层序遍历序列；</li>
|
||||
<li>给定某节点，获取它的值、左（右）子节点、父节点。</li>
|
||||
<li>获取前序遍历、中序遍历、后序遍历、层序遍历序列。</li>
|
||||
</ul>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:11"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
@ -3957,15 +3957,15 @@
|
|||
<h2 id="733">7.3.3. 优势与局限性<a class="headerlink" href="#733" title="Permanent link">¶</a></h2>
|
||||
<p>二叉树的数组表示的优点包括：</p>
|
||||
<ul>
|
||||
<li>数组存储在连续的内存空间中，对缓存友好，访问与遍历速度较快；</li>
|
||||
<li>不需要存储指针，比较节省空间；</li>
|
||||
<li>允许随机访问节点；</li>
|
||||
<li>数组存储在连续的内存空间中，对缓存友好，访问与遍历速度较快。</li>
|
||||
<li>不需要存储指针，比较节省空间。</li>
|
||||
<li>允许随机访问节点。</li>
|
||||
</ul>
|
||||
<p>然而，数组表示也具有一些局限性：</p>
|
||||
<ul>
|
||||
<li>数组存储需要连续内存空间，因此不适合存储数据量过大的树；</li>
|
||||
<li>增删节点需要通过数组插入与删除操作实现，效率较低；</li>
|
||||
<li>当二叉树中存在大量 <span class="arithmatex">\(\text{None}\)</span> 时，数组中包含的节点数据比重较低，空间利用率较低；</li>
|
||||
<li>数组存储需要连续内存空间，因此不适合存储数据量过大的树。</li>
|
||||
<li>增删节点需要通过数组插入与删除操作实现，效率较低。</li>
|
||||
<li>当二叉树中存在大量 <span class="arithmatex">\(\text{None}\)</span> 时，数组中包含的节点数据比重较低，空间利用率较低。</li>
|
||||
</ul>
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -5615,8 +5615,8 @@
|
|||
<p>AVL 树的节点查找操作与二叉搜索树一致，在此不再赘述。</p>
|
||||
<h2 id="754-avl">7.5.4. AVL 树典型应用<a class="headerlink" href="#754-avl" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
<li>组织和存储大型数据，适用于高频查找、低频增删的场景；</li>
|
||||
<li>用于构建数据库中的索引系统；</li>
|
||||
<li>组织和存储大型数据，适用于高频查找、低频增删的场景。</li>
|
||||
<li>用于构建数据库中的索引系统。</li>
|
||||
</ul>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">为什么红黑树比 AVL 树更受欢迎？</p>
|
||||
|
|
|
|||
|
|
@ -3458,8 +3458,8 @@
|
|||
<h1 id="74">7.4. 二叉搜索树<a class="headerlink" href="#74" title="Permanent link">¶</a></h1>
|
||||
<p>「二叉搜索树 Binary Search Tree」满足以下条件：</p>
|
||||
<ol>
|
||||
<li>对于根节点，左子树中所有节点的值 <span class="arithmatex">\(<\)</span> 根节点的值 <span class="arithmatex">\(<\)</span> 右子树中所有节点的值；</li>
|
||||
<li>任意节点的左、右子树也是二叉搜索树，即同样满足条件 <code>1.</code> ；</li>
|
||||
<li>对于根节点，左子树中所有节点的值 <span class="arithmatex">\(<\)</span> 根节点的值 <span class="arithmatex">\(<\)</span> 右子树中所有节点的值。</li>
|
||||
<li>任意节点的左、右子树也是二叉搜索树，即同样满足条件 <code>1.</code> 。</li>
|
||||
</ol>
|
||||
<p><img alt="二叉搜索树" src="../binary_search_tree.assets/binary_search_tree.png" /></p>
|
||||
<p align="center"> Fig. 二叉搜索树 </p>
|
||||
|
|
@ -3468,9 +3468,9 @@
|
|||
<h3 id="_1">查找节点<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>给定目标节点值 <code>num</code> ，可以根据二叉搜索树的性质来查找。我们声明一个节点 <code>cur</code> ，从二叉树的根节点 <code>root</code> 出发，循环比较节点值 <code>cur.val</code> 和 <code>num</code> 之间的大小关系</p>
|
||||
<ul>
|
||||
<li>若 <code>cur.val < num</code> ，说明目标节点在 <code>cur</code> 的右子树中，因此执行 <code>cur = cur.right</code> ；</li>
|
||||
<li>若 <code>cur.val > num</code> ，说明目标节点在 <code>cur</code> 的左子树中，因此执行 <code>cur = cur.left</code> ；</li>
|
||||
<li>若 <code>cur.val = num</code> ，说明找到目标节点，跳出循环并返回该节点；</li>
|
||||
<li>若 <code>cur.val < num</code> ，说明目标节点在 <code>cur</code> 的右子树中，因此执行 <code>cur = cur.right</code> 。</li>
|
||||
<li>若 <code>cur.val > num</code> ，说明目标节点在 <code>cur</code> 的左子树中，因此执行 <code>cur = cur.left</code> 。</li>
|
||||
<li>若 <code>cur.val = num</code> ，说明找到目标节点，跳出循环并返回该节点。</li>
|
||||
</ul>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:4"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
@ -3708,8 +3708,8 @@
|
|||
<h3 id="_2">插入节点<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>给定一个待插入元素 <code>num</code> ，为了保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，插入操作分为两步：</p>
|
||||
<ol>
|
||||
<li><strong>查找插入位置</strong>：与查找操作相似，从根节点出发，根据当前节点值和 <code>num</code> 的大小关系循环向下搜索，直到越过叶节点（遍历至 <span class="arithmatex">\(\text{None}\)</span> ）时跳出循环；</li>
|
||||
<li><strong>在该位置插入节点</strong>：初始化节点 <code>num</code> ，将该节点置于 <span class="arithmatex">\(\text{None}\)</span> 的位置；</li>
|
||||
<li><strong>查找插入位置</strong>：与查找操作相似，从根节点出发，根据当前节点值和 <code>num</code> 的大小关系循环向下搜索，直到越过叶节点（遍历至 <span class="arithmatex">\(\text{None}\)</span> ）时跳出循环。</li>
|
||||
<li><strong>在该位置插入节点</strong>：初始化节点 <code>num</code> ，将该节点置于 <span class="arithmatex">\(\text{None}\)</span> 的位置。</li>
|
||||
</ol>
|
||||
<p>二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回。</p>
|
||||
<p><img alt="在二叉搜索树中插入节点" src="../binary_search_tree.assets/bst_insert.png" /></p>
|
||||
|
|
@ -4041,8 +4041,8 @@
|
|||
|
||||
<p>当待删除节点的度为 <span class="arithmatex">\(2\)</span> 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左 <span class="arithmatex">\(<\)</span> 根 <span class="arithmatex">\(<\)</span> 右”的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。假设我们选择右子树的最小节点（或者称为中序遍历的下个节点），则删除操作为：</p>
|
||||
<ol>
|
||||
<li>找到待删除节点在“中序遍历序列”中的下一个节点，记为 <code>tmp</code> ；</li>
|
||||
<li>将 <code>tmp</code> 的值覆盖待删除节点的值，并在树中递归删除节点 <code>tmp</code> ；</li>
|
||||
<li>找到待删除节点在“中序遍历序列”中的下一个节点，记为 <code>tmp</code> 。</li>
|
||||
<li>将 <code>tmp</code> 的值覆盖待删除节点的值，并在树中递归删除节点 <code>tmp</code> 。</li>
|
||||
</ol>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:4"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1"><1></label><label for="__tabbed_4_2"><2></label><label for="__tabbed_4_3"><3></label><label for="__tabbed_4_4"><4></label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
|
|||
|
|
@ -3614,14 +3614,14 @@
|
|||
<h2 id="711">7.1.1. 二叉树常见术语<a class="headerlink" href="#711" title="Permanent link">¶</a></h2>
|
||||
<p>二叉树涉及的术语较多，建议尽量理解并记住。</p>
|
||||
<ul>
|
||||
<li>「根节点 Root Node」：位于二叉树顶层的节点，没有父节点；</li>
|
||||
<li>「叶节点 Leaf Node」：没有子节点的节点，其两个指针均指向 <span class="arithmatex">\(\text{None}\)</span> ；</li>
|
||||
<li>节点的「层 Level」：从顶至底递增，根节点所在层为 1 ；</li>
|
||||
<li>节点的「度 Degree」：节点的子节点的数量。在二叉树中，度的范围是 0, 1, 2 ；</li>
|
||||
<li>「边 Edge」：连接两个节点的线段，即节点指针；</li>
|
||||
<li>二叉树的「高度」：从根节点到最远叶节点所经过的边的数量；</li>
|
||||
<li>节点的「深度 Depth」 ：从根节点到该节点所经过的边的数量；</li>
|
||||
<li>节点的「高度 Height」：从最远叶节点到该节点所经过的边的数量；</li>
|
||||
<li>「根节点 Root Node」：位于二叉树顶层的节点，没有父节点。</li>
|
||||
<li>「叶节点 Leaf Node」：没有子节点的节点，其两个指针均指向 <span class="arithmatex">\(\text{None}\)</span> 。</li>
|
||||
<li>节点的「层 Level」：从顶至底递增，根节点所在层为 1 。</li>
|
||||
<li>节点的「度 Degree」：节点的子节点的数量。在二叉树中，度的范围是 0, 1, 2 。</li>
|
||||
<li>「边 Edge」：连接两个节点的线段，即节点指针。</li>
|
||||
<li>二叉树的「高度」：从根节点到最远叶节点所经过的边的数量。</li>
|
||||
<li>节点的「深度 Depth」 ：从根节点到该节点所经过的边的数量。</li>
|
||||
<li>节点的「高度 Height」：从最远叶节点到该节点所经过的边的数量。</li>
|
||||
</ul>
|
||||
<p><img alt="二叉树的常用术语" src="../binary_tree.assets/binary_tree_terminology.png" /></p>
|
||||
<p align="center"> Fig. 二叉树的常用术语 </p>
|
||||
|
|
@ -3930,8 +3930,8 @@
|
|||
<h2 id="714">7.1.4. 二叉树的退化<a class="headerlink" href="#714" title="Permanent link">¶</a></h2>
|
||||
<p>当二叉树的每层节点都被填满时，达到「完美二叉树」；而当所有节点都偏向一侧时，二叉树退化为「链表」。</p>
|
||||
<ul>
|
||||
<li>完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势；</li>
|
||||
<li>链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> ；</li>
|
||||
<li>完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势。</li>
|
||||
<li>链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> 。</li>
|
||||
</ul>
|
||||
<p><img alt="二叉树的最佳与最差结构" src="../binary_tree.assets/binary_tree_best_worst_cases.png" /></p>
|
||||
<p align="center"> Fig. 二叉树的最佳与最差结构 </p>
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
200
sitemap.xml
200
sitemap.xml
|
|
@ -2,502 +2,502 @@
|
|||
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/contribution/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/installation/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/array/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/linked_list/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/list/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/backtracking_algorithm/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/n_queens_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/permutations_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/subset_sum_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/performance_evaluation/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/space_complexity/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/time_complexity/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/basic_data_types/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/character_encoding/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/classification_of_data_structure/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/number_encoding/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/binary_search_recur/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/build_binary_tree_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/divide_and_conquer/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/hanota_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/dp_problem_features/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/dp_solution_pipeline/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/edit_distance_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/intro_to_dynamic_programming/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/knapsack_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/unbounded_knapsack_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph_operations/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph_traversal/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/fractional_knapsack_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/greedy_algorithm/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/max_capacity_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/max_product_cutting_problem/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_algorithm/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_collision/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_map/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/build_heap/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/heap/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/top_k/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/algorithms_are_everywhere/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/what_is_dsa/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/about_the_book/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/suggestions/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_reference/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/binary_search/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/binary_search_edge/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/replace_linear_by_hashing/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/searching_algorithm_revisited/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/bubble_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/bucket_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/counting_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/heap_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/insertion_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/merge_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/quick_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/radix_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/selection_sort/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/sorting_algorithm/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/deque/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/queue/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/stack/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/array_representation_of_tree/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/avl_tree/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_search_tree/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_tree/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_tree_traversal/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/summary/</loc>
|
||||
<lastmod>2023-07-25</lastmod>
|
||||
<lastmod>2023-07-26</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
</urlset>
|
||||
BIN
sitemap.xml.gz
BIN
sitemap.xml.gz
Binary file not shown.
Loading…
Reference in a new issue