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

deploy

Browse source
This commit is contained in:
krahets 2023-05-21 19:58:42 +08:00
parent 61055d21bd
commit bb99d5789a
8 changed files with 22 additions and 14 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
chapter_backtracking/backtracking_algorithm/index.html
View file

@ -1920,7 +1920,8 @@
<p>「回溯算法 Backtracking Algorithm」是一种通过穷举来解决问题的方法，它的核心思想是从一个初始状态出发，暴力搜索所有可能的解决方案，当遇到正确的解则将其记录，直到找到解或者尝试了所有可能的选择都无法找到解为止。</p> <p>「回溯算法 Backtracking Algorithm」是一种通过穷举来解决问题的方法，它的核心思想是从一个初始状态出发，暴力搜索所有可能的解决方案，当遇到正确的解则将其记录，直到找到解或者尝试了所有可能的选择都无法找到解为止。</p>
<p>回溯算法通常采用「深度优先搜索」来遍历解空间。在二叉树章节中，我们提到前序、中序和后序遍历都属于深度优先搜索。下面，我们从二叉树的前序遍历入手，逐步了解回溯算法的工作原理。</p> <p>回溯算法通常采用「深度优先搜索」来遍历解空间。在二叉树章节中，我们提到前序、中序和后序遍历都属于深度优先搜索。下面，我们从二叉树的前序遍历入手，逐步了解回溯算法的工作原理。</p>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">例题一：在二叉树中搜索并返回所有值为 <span class="arithmatex">\(7\)</span> 的节点</p> <p class="admonition-title">例题一</p>
<p>给定一个二叉树，搜索并记录所有值为 <span class="arithmatex">\(7\)</span> 的节点，返回节点列表。</p>
</div> </div>
<p><strong>解题思路</strong>：前序遍历这颗树，并判断当前节点的值是否为 <span class="arithmatex">\(7\)</span> ，若是则将该节点的值加入到结果列表 <code>res</code> 之中。</p> <p><strong>解题思路</strong>：前序遍历这颗树，并判断当前节点的值是否为 <span class="arithmatex">\(7\)</span> ，若是则将该节点的值加入到结果列表 <code>res</code> 之中。</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">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></div> <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">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></div>
@ -2060,7 +2061,8 @@
<p>对于例题一，访问每个节点都代表一次“尝试”，而越过叶结点或返回父节点的 <code>return</code> 则表示“回退”。</p> <p>对于例题一，访问每个节点都代表一次“尝试”，而越过叶结点或返回父节点的 <code>return</code> 则表示“回退”。</p>
<p>值得说明的是，<strong>回退并不等价于函数返回</strong>。为解释这一点，我们对例题一稍作拓展。</p> <p>值得说明的是，<strong>回退并不等价于函数返回</strong>。为解释这一点，我们对例题一稍作拓展。</p>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">在二叉树中搜索所有值为 <span class="arithmatex">\(7\)</span> 的节点，<strong>返回根节点到这些节点的路径</strong></p> <p class="admonition-title">例题二</p>
<p>在二叉树中搜索所有值为 <span class="arithmatex">\(7\)</span> 的节点，<strong>返回根节点到这些节点的路径</strong>。</p>
</div> </div>
<p><strong>解题思路</strong>：在例题一代码的基础上，我们需要借助一个列表 <code>path</code> 记录访问过的节点路径。当访问到值为 <span class="arithmatex">\(7\)</span> 的节点时，则复制 <code>path</code> 并添加进结果列表 <code>res</code> 。遍历完成后，<code>res</code> 中保存的就是所有的解。</p> <p><strong>解题思路</strong>：在例题一代码的基础上，我们需要借助一个列表 <code>path</code> 记录访问过的节点路径。当访问到值为 <span class="arithmatex">\(7\)</span> 的节点时，则复制 <code>path</code> 并添加进结果列表 <code>res</code> 。遍历完成后，<code>res</code> 中保存的就是所有的解。</p>
<div class="tabbed-set tabbed-alternate" data-tabs="2:10"><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" /><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></div> <div class="tabbed-set tabbed-alternate" data-tabs="2:10"><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" /><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></div>
@ -2269,8 +2271,9 @@
<h2 id="1212">12.1.2. &nbsp; 剪枝<a class="headerlink" href="#1212" title="Permanent link">&para;</a></h2> <h2 id="1212">12.1.2. &nbsp; 剪枝<a class="headerlink" href="#1212" title="Permanent link">&para;</a></h2>
<p>复杂的回溯问题通常包含一个或多个约束条件，<strong>约束条件通常可用于“剪枝”</strong>。</p> <p>复杂的回溯问题通常包含一个或多个约束条件，<strong>约束条件通常可用于“剪枝”</strong>。</p>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">例题三：在二叉树中搜索所有值为 <span class="arithmatex">\(7\)</span> 的节点，返回根节点到这些节点的路径，<strong>路径中不能包含值为 <span class="arithmatex">\(3\)</span> 的节点</strong></p> <p class="admonition-title">例题三</p>
</div> </div>
<p>在二叉树中搜索所有值为 <span class="arithmatex">\(7\)</span> 的节点，返回根节点到这些节点的路径，<strong>路径中不能包含值为 <span class="arithmatex">\(3\)</span> 的节点</strong>。</p>
<p><strong>解题思路</strong>：在例题二的基础上添加剪枝操作，当遇到值为 <span class="arithmatex">\(3\)</span> 的节点时，则终止继续搜索。</p> <p><strong>解题思路</strong>：在例题二的基础上添加剪枝操作，当遇到值为 <span class="arithmatex">\(3\)</span> 的节点时，则终止继续搜索。</p>
<div class="tabbed-set tabbed-alternate" data-tabs="4:10"><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" /><div class="tabbed-labels"><label for="__tabbed_4_1">Java</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Python</label><label for="__tabbed_4_4">Go</label><label for="__tabbed_4_5">JavaScript</label><label for="__tabbed_4_6">TypeScript</label><label for="__tabbed_4_7">C</label><label for="__tabbed_4_8">C#</label><label for="__tabbed_4_9">Swift</label><label for="__tabbed_4_10">Zig</label></div> <div class="tabbed-set tabbed-alternate" data-tabs="4:10"><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" /><div class="tabbed-labels"><label for="__tabbed_4_1">Java</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Python</label><label for="__tabbed_4_4">Go</label><label for="__tabbed_4_5">JavaScript</label><label for="__tabbed_4_6">TypeScript</label><label for="__tabbed_4_7">C</label><label for="__tabbed_4_8">C#</label><label for="__tabbed_4_9">Swift</label><label for="__tabbed_4_10">Zig</label></div>
<div class="tabbed-content"> <div class="tabbed-content">

3
chapter_backtracking/n_queens_problem/index.html
View file

@ -1862,7 +1862,8 @@
<h1 id="123-n">12.3. &nbsp; N 皇后问题<a class="headerlink" href="#123-n" title="Permanent link">&para;</a></h1> <h1 id="123-n">12.3. &nbsp; N 皇后问题<a class="headerlink" href="#123-n" title="Permanent link">&para;</a></h1>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">根据国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给定 <span class="arithmatex">\(n\)</span> 个皇后和一个 <span class="arithmatex">\(n \times n\)</span> 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。</p> <p class="admonition-title">Question</p>
<p>根据国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给定 <span class="arithmatex">\(n\)</span> 个皇后和一个 <span class="arithmatex">\(n \times n\)</span> 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。</p>
</div> </div>
<p>如下图所示，当 <span class="arithmatex">\(n = 4\)</span> 时，共可以找到两个解。从回溯算法的角度看，<span class="arithmatex">\(n \times n\)</span> 大小的棋盘共有 <span class="arithmatex">\(n^2\)</span> 个格子，给出了所有的选择 <code>choices</code> 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 <code>state</code> 。</p> <p>如下图所示，当 <span class="arithmatex">\(n = 4\)</span> 时，共可以找到两个解。从回溯算法的角度看，<span class="arithmatex">\(n \times n\)</span> 大小的棋盘共有 <span class="arithmatex">\(n^2\)</span> 个格子，给出了所有的选择 <code>choices</code> 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 <code>state</code> 。</p>
<p><img alt="4 皇后问题的解" src="../n_queens_problem.assets/solution_4_queens.png" /></p> <p><img alt="4 皇后问题的解" src="../n_queens_problem.assets/solution_4_queens.png" /></p>

6
chapter_backtracking/permutations_problem/index.html
View file

@ -1917,7 +1917,8 @@
</div> </div>
<h2 id="1221">12.2.1. &nbsp; 无重复的情况<a class="headerlink" href="#1221" title="Permanent link">&para;</a></h2> <h2 id="1221">12.2.1. &nbsp; 无重复的情况<a class="headerlink" href="#1221" title="Permanent link">&para;</a></h2>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">输入一个整数数组，数组中不包含重复元素，返回所有可能的排列。</p> <p class="admonition-title">Question</p>
<p>输入一个整数数组，数组中不包含重复元素，返回所有可能的排列。</p>
</div> </div>
<p><strong>从回溯算法的角度看，我们可以把生成排列的过程想象成一系列选择的结果</strong>。假设输入数组为 <span class="arithmatex">\([1, 2, 3]\)</span> ，如果我们先选择 <span class="arithmatex">\(1\)</span> 、再选择 <span class="arithmatex">\(3\)</span> 、最后选择 <span class="arithmatex">\(2\)</span> ，则获得排列 <span class="arithmatex">\([1, 3, 2]\)</span> 。回退表示撤销一个选择，之后继续尝试其他选择。</p> <p><strong>从回溯算法的角度看，我们可以把生成排列的过程想象成一系列选择的结果</strong>。假设输入数组为 <span class="arithmatex">\([1, 2, 3]\)</span> ，如果我们先选择 <span class="arithmatex">\(1\)</span> 、再选择 <span class="arithmatex">\(3\)</span> 、最后选择 <span class="arithmatex">\(2\)</span> ，则获得排列 <span class="arithmatex">\([1, 3, 2]\)</span> 。回退表示撤销一个选择，之后继续尝试其他选择。</p>
<p>从回溯算法代码的角度看，候选集合 <code>choices</code> 是输入数组中的所有元素，状态 <code>state</code> 是直至目前已被选择的元素。注意，每个元素只允许被选择一次，<strong>因此在遍历选择时，应当排除已经选择过的元素</strong>。</p> <p>从回溯算法代码的角度看，候选集合 <code>choices</code> 是输入数组中的所有元素，状态 <code>state</code> 是直至目前已被选择的元素。注意，每个元素只允许被选择一次，<strong>因此在遍历选择时，应当排除已经选择过的元素</strong>。</p>
@ -2217,7 +2218,8 @@
<h2 id="1222">12.2.2. &nbsp; 考虑重复的情况<a class="headerlink" href="#1222" title="Permanent link">&para;</a></h2> <h2 id="1222">12.2.2. &nbsp; 考虑重复的情况<a class="headerlink" href="#1222" title="Permanent link">&para;</a></h2>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">输入一个整数数组，<strong>数组中可能包含重复元素</strong>，返回所有不重复的排列。</p> <p class="admonition-title">Question</p>
<p>输入一个整数数组，<strong>数组中可能包含重复元素</strong>，返回所有不重复的排列。</p>
</div> </div>
<p>假设输入数组为 <span class="arithmatex">\([1, 1, 2]\)</span> 。为了方便区分两个重复的元素 <span class="arithmatex">\(1\)</span> ，接下来我们将第二个元素记为 <span class="arithmatex">\(\hat{1}\)</span> 。如下图所示，上述方法生成的排列有一半都是重复的。</p> <p>假设输入数组为 <span class="arithmatex">\([1, 1, 2]\)</span> 。为了方便区分两个重复的元素 <span class="arithmatex">\(1\)</span> ，接下来我们将第二个元素记为 <span class="arithmatex">\(\hat{1}\)</span> 。如下图所示，上述方法生成的排列有一半都是重复的。</p>
<p><img alt="重复排列" src="../permutations_problem.assets/permutations_ii.png" /></p> <p><img alt="重复排列" src="../permutations_problem.assets/permutations_ii.png" /></p>

3
chapter_searching/binary_search/index.html
View file

@ -1878,7 +1878,8 @@
<p>「二分查找 Binary Search」是一种基于分治思想的高效搜索算法。它利用数据的有序性，每轮减少一半搜索范围，直至找到目标元素或搜索区间为空为止。</p> <p>「二分查找 Binary Search」是一种基于分治思想的高效搜索算法。它利用数据的有序性，每轮减少一半搜索范围，直至找到目标元素或搜索区间为空为止。</p>
<p>我们先来求解一个简单的二分查找问题。</p> <p>我们先来求解一个简单的二分查找问题。</p>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">给定一个长度为 <span class="arithmatex">\(n\)</span> 的有序数组 <code>nums</code> ，元素按从小到大的顺序排列。查找并返回元素 <code>target</code> 在该数组中的索引。若数组中不包含该元素，则返回 <span class="arithmatex">\(-1\)</span> 。数组中不包含重复元素。</p> <p class="admonition-title">Question</p>
<p>给定一个长度为 <span class="arithmatex">\(n\)</span> 的有序数组 <code>nums</code> ，元素按从小到大的顺序排列。请查找并返回元素 <code>target</code> 在该数组中的索引。若数组中不包含该元素，则返回 <span class="arithmatex">\(-1\)</span> 。数组中不包含重复元素。</p>
</div> </div>
<p>该数组的索引范围可以使用区间 <span class="arithmatex">\([0, n - 1]\)</span> 来表示。其中，<strong>中括号表示“闭区间”，即包含边界值本身</strong>。在该表示下，区间 <span class="arithmatex">\([i, j]\)</span> 在 <span class="arithmatex">\(i = j\)</span> 时仍包含一个元素，在 <span class="arithmatex">\(i &gt; j\)</span> 时为空区间。</p> <p>该数组的索引范围可以使用区间 <span class="arithmatex">\([0, n - 1]\)</span> 来表示。其中，<strong>中括号表示“闭区间”，即包含边界值本身</strong>。在该表示下，区间 <span class="arithmatex">\([i, j]\)</span> 在 <span class="arithmatex">\(i = j\)</span> 时仍包含一个元素，在 <span class="arithmatex">\(i &gt; j\)</span> 时为空区间。</p>
<p>接下来，我们基于上述区间定义实现二分查找。先初始化指针 <span class="arithmatex">\(i = 0\)</span> 和 <span class="arithmatex">\(j = n - 1\)</span> ，分别指向数组首元素和尾元素。之后循环执行以下两个步骤:</p> <p>接下来，我们基于上述区间定义实现二分查找。先初始化指针 <span class="arithmatex">\(i = 0\)</span> 和 <span class="arithmatex">\(j = n - 1\)</span> ，分别指向数组首元素和尾元素。之后循环执行以下两个步骤:</p>

9
chapter_searching/binary_search_edge/index.html
View file

@ -1882,7 +1882,8 @@
<h2 id="1021">10.2.1. &nbsp; 查找最左一个元素<a class="headerlink" href="#1021" title="Permanent link">&para;</a></h2> <h2 id="1021">10.2.1. &nbsp; 查找最左一个元素<a class="headerlink" href="#1021" title="Permanent link">&para;</a></h2>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">查找并返回元素 <code>target</code> 在有序数组 <code>nums</code> 中首次出现的索引。若数组中不包含该元素，则返回 <span class="arithmatex">\(-1\)</span> 。数组可能包含重复元素。</p> <p class="admonition-title">Question</p>
<p>给定一个长度为 <span class="arithmatex">\(n\)</span> 的有序数组 <code>nums</code> 。请查找并返回元素 <code>target</code> 在该数组中首次出现的索引。若数组中不包含该元素，则返回 <span class="arithmatex">\(-1\)</span> 。数组可能包含重复元素。</p>
</div> </div>
<p>实际上，我们可以仅通过二分查找解决以上问题。方法的整体框架不变，先计算中点索引 <code>m</code> ，再判断 <code>target</code> 和 <code>nums[m]</code> 大小关系：</p> <p>实际上，我们可以仅通过二分查找解决以上问题。方法的整体框架不变，先计算中点索引 <code>m</code> ，再判断 <code>target</code> 和 <code>nums[m]</code> 大小关系：</p>
<ul> <ul>
@ -1971,11 +1972,11 @@
<a id="__codelineno-2-5" name="__codelineno-2-5" href="#__codelineno-2-5"></a> <span class="k">while</span> <span class="n">i</span> <span class="o">&lt;=</span> <span class="n">j</span><span class="p">:</span> <a id="__codelineno-2-5" name="__codelineno-2-5" href="#__codelineno-2-5"></a> <span class="k">while</span> <span class="n">i</span> <span class="o">&lt;=</span> <span class="n">j</span><span class="p">:</span>
<a id="__codelineno-2-6" name="__codelineno-2-6" href="#__codelineno-2-6"></a> <span class="n">m</span> <span class="o">=</span> <span class="p">(</span><span class="n">i</span> <span class="o">+</span> <span class="n">j</span><span class="p">)</span> <span class="o">//</span> <span class="mi">2</span> <span class="c1"># 计算中点索引 m</span> <a id="__codelineno-2-6" name="__codelineno-2-6" href="#__codelineno-2-6"></a> <span class="n">m</span> <span class="o">=</span> <span class="p">(</span><span class="n">i</span> <span class="o">+</span> <span class="n">j</span><span class="p">)</span> <span class="o">//</span> <span class="mi">2</span> <span class="c1"># 计算中点索引 m</span>
<a id="__codelineno-2-7" name="__codelineno-2-7" href="#__codelineno-2-7"></a> <span class="k">if</span> <span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span> <span class="o">&lt;</span> <span class="n">target</span><span class="p">:</span> <a id="__codelineno-2-7" name="__codelineno-2-7" href="#__codelineno-2-7"></a> <span class="k">if</span> <span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span> <span class="o">&lt;</span> <span class="n">target</span><span class="p">:</span>
<a id="__codelineno-2-8" name="__codelineno-2-8" href="#__codelineno-2-8"></a> <span class="n">i</span> <span class="o">=</span> <span class="n">m</span> <span class="o">+</span> <span class="mi">1</span> <span class="c1"># 此情况说明 target 在区间 [m+1, j] 中</span> <a id="__codelineno-2-8" name="__codelineno-2-8" href="#__codelineno-2-8"></a> <span class="n">i</span> <span class="o">=</span> <span class="n">m</span> <span class="o">+</span> <span class="mi">1</span> <span class="c1"># target 在区间 [m+1, j] 中</span>
<a id="__codelineno-2-9" name="__codelineno-2-9" href="#__codelineno-2-9"></a> <span class="k">elif</span> <span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span> <span class="o">&gt;</span> <span class="n">target</span><span class="p">:</span> <a id="__codelineno-2-9" name="__codelineno-2-9" href="#__codelineno-2-9"></a> <span class="k">elif</span> <span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span> <span class="o">&gt;</span> <span class="n">target</span><span class="p">:</span>
<a id="__codelineno-2-10" name="__codelineno-2-10" href="#__codelineno-2-10"></a> <span class="n">j</span> <span class="o">=</span> <span class="n">m</span> <span class="o">-</span> <span class="mi">1</span> <span class="c1"># 此情况说明 target 在区间 [i, m-1] 中</span> <a id="__codelineno-2-10" name="__codelineno-2-10" href="#__codelineno-2-10"></a> <span class="n">j</span> <span class="o">=</span> <span class="n">m</span> <span class="o">-</span> <span class="mi">1</span> <span class="c1"># target 在区间 [i, m-1] 中</span>
<a id="__codelineno-2-11" name="__codelineno-2-11" href="#__codelineno-2-11"></a> <span class="k">else</span><span class="p">:</span> <a id="__codelineno-2-11" name="__codelineno-2-11" href="#__codelineno-2-11"></a> <span class="k">else</span><span class="p">:</span>
<a id="__codelineno-2-12" name="__codelineno-2-12" href="#__codelineno-2-12"></a> <span class="n">j</span> <span class="o">=</span> <span class="n">m</span> <span class="o">-</span> <span class="mi">1</span> <span class="c1"># 此情况说明首个小于 target 的元素在区间 [i, m-1] 中</span> <a id="__codelineno-2-12" name="__codelineno-2-12" href="#__codelineno-2-12"></a> <span class="n">j</span> <span class="o">=</span> <span class="n">m</span> <span class="o">-</span> <span class="mi">1</span> <span class="c1"># 首个小于 target 的元素在区间 [i, m-1] 中</span>
<a id="__codelineno-2-13" name="__codelineno-2-13" href="#__codelineno-2-13"></a> <span class="k">if</span> <span class="n">i</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="ow">or</span> <span class="n">nums</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">!=</span> <span class="n">target</span><span class="p">:</span> <a id="__codelineno-2-13" name="__codelineno-2-13" href="#__codelineno-2-13"></a> <span class="k">if</span> <span class="n">i</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="ow">or</span> <span class="n">nums</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">!=</span> <span class="n">target</span><span class="p">:</span>
<a id="__codelineno-2-14" name="__codelineno-2-14" href="#__codelineno-2-14"></a> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span> <span class="c1"># 未找到目标元素，返回 -1</span> <a id="__codelineno-2-14" name="__codelineno-2-14" href="#__codelineno-2-14"></a> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span> <span class="c1"># 未找到目标元素，返回 -1</span>
<a id="__codelineno-2-15" name="__codelineno-2-15" href="#__codelineno-2-15"></a> <span class="k">return</span> <span class="n">i</span> <a id="__codelineno-2-15" name="__codelineno-2-15" href="#__codelineno-2-15"></a> <span class="k">return</span> <span class="n">i</span>

4
chapter_searching/replace_linear_by_hashing/index.html
View file

@ -1877,8 +1877,8 @@
<h1 id="103">10.3. &nbsp; 哈希优化策略<a class="headerlink" href="#103" title="Permanent link">&para;</a></h1> <h1 id="103">10.3. &nbsp; 哈希优化策略<a class="headerlink" href="#103" title="Permanent link">&para;</a></h1>
<p>在算法题中，<strong>我们常通过将线性查找替换为哈希查找来降低算法的时间复杂度</strong>。我们借助一个算法题来加深理解。</p> <p>在算法题中，<strong>我们常通过将线性查找替换为哈希查找来降低算法的时间复杂度</strong>。我们借助一个算法题来加深理解。</p>
<div class="admonition question"> <div class="admonition question">
<p class="admonition-title">两数之和</p> <p class="admonition-title">Question</p>
<p>给定一个整数数组 <code>nums</code> 和一个整数目标值 <code>target</code> ，请在数组中搜索“和”为目标值 <code>target</code> 的两个整数，并返回他们在数组中的索引。注意，数组中同一个元素在答案里不能重复出现。返回任意一个解即可。</p> <p>给定一个整数数组 <code>nums</code> 和一个目标元素 <code>target</code> ，请在数组中搜索“和”为 <code>target</code> 的两个元素，并返回它们的数组索引。返回任意一个解即可。</p>
</div> </div>
<h2 id="1031">10.3.1. &nbsp; 线性查找：以时间换空间<a class="headerlink" href="#1031" title="Permanent link">&para;</a></h2> <h2 id="1031">10.3.1. &nbsp; 线性查找：以时间换空间<a class="headerlink" href="#1031" title="Permanent link">&para;</a></h2>
<p>考虑直接遍历所有可能的组合。开启一个两层循环，在每轮中判断两个整数的和是否为 <code>target</code> ，若是，则返回它们的索引。</p> <p>考虑直接遍历所有可能的组合。开启一个两层循环，在每轮中判断两个整数的和是否为 <code>target</code> ，若是，则返回它们的索引。</p>

2
search/search_index.json
View file

File diff suppressed because one or more lines are too long

BIN
sitemap.xml.gz
View file

Binary file not shown.