deploy

2026-04-05 03:30:30 +08:00 · 2023-12-02 06:24:11 +08:00
parent 5783c402bf
commit d20d8b3ee1
107 changed files with 1685 additions and 1745 deletions
--- a/chapter_hashing/hash_algorithm/index.html
+++ b/chapter_hashing/hash_algorithm/index.html
@@ -3410,32 +3410,32 @@

 <!-- Page content -->
 <h1 id="63">6.3 &nbsp; 哈希算法<a class="headerlink" href="#63" title="Permanent link">&para;</a></h1>
-<p>在上两节中，我们了解了哈希表的工作原理和哈希冲突的处理方法。然而无论是开放寻址还是链地址法，<strong>它们只能保证哈希表可以在发生冲突时正常工作，但无法减少哈希冲突的发生</strong>。</p>
-<p>如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。如图 6-8 所示，对于链地址哈希表，理想情况下键值对平均分布在各个桶中，达到最佳查询效率；最差情况下所有键值对都被存储到同一个桶中，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> 。</p>
-<p><a class="glightbox" href="../hash_algorithm.assets/hash_collision_best_worst_condition.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="哈希冲突的最佳与最差情况" class="animation-figure" src="../hash_algorithm.assets/hash_collision_best_worst_condition.png" /></a></p>
-<p align="center"> 图 6-8 &nbsp; 哈希冲突的最佳与最差情况 </p>
+<p>前两节介绍了哈希表的工作原理和哈希冲突的处理方法。然而无论是开放寻址还是链式地址，<strong>它们只能保证哈希表可以在发生冲突时正常工作，而无法减少哈希冲突的发生</strong>。</p>
+<p>如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。如图 6-8 所示，对于链式地址哈希表，理想情况下键值对均匀分布在各个桶中，达到最佳查询效率；最差情况下所有键值对都存储到同一个桶中，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> 。</p>
+<p><a class="glightbox" href="../hash_algorithm.assets/hash_collision_best_worst_condition.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="哈希冲突的最佳情况与最差情况" class="animation-figure" src="../hash_algorithm.assets/hash_collision_best_worst_condition.png" /></a></p>
+<p align="center"> 图 6-8 &nbsp; 哈希冲突的最佳情况与最差情况 </p>

 <p><strong>键值对的分布情况由哈希函数决定</strong>。回忆哈希函数的计算步骤，先计算哈希值，再对数组长度取模：</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-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>
 <p>观察以上公式，当哈希表容量 <code>capacity</code> 固定时，<strong>哈希算法 <code>hash()</code> 决定了输出值</strong>，进而决定了键值对在哈希表中的分布情况。</p>
-<p>这意味着，为了减小哈希冲突的发生概率，我们应当将注意力集中在哈希算法 <code>hash()</code> 的设计上。</p>
+<p>这意味着，为了降低哈希冲突的发生概率，我们应当将注意力集中在哈希算法 <code>hash()</code> 的设计上。</p>
 <h2 id="631">6.3.1 &nbsp; 哈希算法的目标<a class="headerlink" href="#631" title="Permanent link">&para;</a></h2>
-<p>为了实现“既快又稳”的哈希表数据结构，哈希算法应包含以下特点。</p>
+<p>为了实现“既快又稳”的哈希表数据结构，哈希算法应具备以下特点。</p>
 <ul>
 <li><strong>确定性</strong>：对于相同的输入，哈希算法应始终产生相同的输出。这样才能确保哈希表是可靠的。</li>
 <li><strong>效率高</strong>：计算哈希值的过程应该足够快。计算开销越小，哈希表的实用性越高。</li>
-<li><strong>均匀分布</strong>：哈希算法应使得键值对平均分布在哈希表中。分布越平均，哈希冲突的概率就越低。</li>
+<li><strong>均匀分布</strong>：哈希算法应使得键值对均匀分布在哈希表中。分布越均匀，哈希冲突的概率就越低。</li>
 </ul>
 <p>实际上，哈希算法除了可以用于实现哈希表，还广泛应用于其他领域中。</p>
 <ul>
 <li><strong>密码存储</strong>：为了保护用户密码的安全，系统通常不会直接存储用户的明文密码，而是存储密码的哈希值。当用户输入密码时，系统会对输入的密码计算哈希值，然后与存储的哈希值进行比较。如果两者匹配，那么密码就被视为正确。</li>
-<li><strong>数据完整性检查</strong>：数据发送方可以计算数据的哈希值并将其一同发送；接收方可以重新计算接收到的数据的哈希值，并与接收到的哈希值进行比较。如果两者匹配，那么数据就被视为完整的。</li>
+<li><strong>数据完整性检查</strong>：数据发送方可以计算数据的哈希值并将其一同发送；接收方可以重新计算接收到的数据的哈希值，并与接收到的哈希值进行比较。如果两者匹配，那么数据就被视为完整。</li>
 </ul>
 <p>对于密码学的相关应用，为了防止从哈希值推导出原始密码等逆向工程，哈希算法需要具备更高等级的安全特性。</p>
 <ul>
 <li><strong>单向性</strong>：无法通过哈希值反推出关于输入数据的任何信息。</li>
-<li><strong>抗碰撞性</strong>：应当极其困难找到两个不同的输入，使得它们的哈希值相同。</li>
+<li><strong>抗碰撞性</strong>：应当极难找到两个不同的输入，使得它们的哈希值相同。</li>
 <li><strong>雪崩效应</strong>：输入的微小变化应当导致输出的显著且不可预测的变化。</li>
 </ul>
 <p>请注意，<strong>“均匀分布”与“抗碰撞性”是两个独立的概念</strong>，满足均匀分布不一定满足抗碰撞性。例如，在随机输入 <code>key</code> 下，哈希函数 <code>key % 100</code> 可以产生均匀分布的输出。然而该哈希算法过于简单，所有后两位相等的 <code>key</code> 的输出都相同，因此我们可以很容易地从哈希值反推出可用的 <code>key</code> ，从而破解密码。</p>
@@ -3443,7 +3443,7 @@
 <p>哈希算法的设计是一个需要考虑许多因素的复杂问题。然而对于某些要求不高的场景，我们也能设计一些简单的哈希算法。</p>
 <ul>
 <li><strong>加法哈希</strong>：对输入的每个字符的 ASCII 码进行相加，将得到的总和作为哈希值。</li>
-<li><strong>乘法哈希</strong>：利用了乘法的不相关性，每轮乘以一个常数，将各个字符的 ASCII 码累积到哈希值中。</li>
+<li><strong>乘法哈希</strong>：利用乘法的不相关性，每轮乘以一个常数，将各个字符的 ASCII 码累积到哈希值中。</li>
 <li><strong>异或哈希</strong>：将输入数据的每个元素通过异或操作累积到一个哈希值中。</li>
 <li><strong>旋转哈希</strong>：将每个字符的 ASCII 码累积到一个哈希值中，每次累积之前都会对哈希值进行旋转操作。</li>
 </ul>
@@ -3942,8 +3942,8 @@
 </div>
 </div>
 <p>观察发现，每种哈希算法的最后一步都是对大质数 <span class="arithmatex">\(1000000007\)</span> 取模，以确保哈希值在合适的范围内。值得思考的是，为什么要强调对质数取模，或者说对合数取模的弊端是什么？这是一个有趣的问题。</p>
-<p>先抛出结论：<strong>当我们使用大质数作为模数时，可以最大化地保证哈希值的均匀分布</strong>。因为质数不会与其他数字存在公约数，可以减少因取模操作而产生的周期性模式，从而避免哈希冲突。</p>
-<p>举个例子，假设我们选择合数 <span class="arithmatex">\(9\)</span> 作为模数，它可以被 <span class="arithmatex">\(3\)</span> 整除。那么所有可以被 <span class="arithmatex">\(3\)</span> 整除的 <code>key</code> 都会被映射到 <span class="arithmatex">\(0\)</span>、<span class="arithmatex">\(3\)</span>、<span class="arithmatex">\(6\)</span> 这三个哈希值。</p>
+<p>先抛出结论：<strong>使用大质数作为模数，可以最大化地保证哈希值的均匀分布</strong>。因为质数不与其他数字存在公约数，可以减少因取模操作而产生的周期性模式，从而避免哈希冲突。</p>
+<p>举个例子，假设我们选择合数 <span class="arithmatex">\(9\)</span> 作为模数，它可以被 <span class="arithmatex">\(3\)</span> 整除，那么所有可以被 <span class="arithmatex">\(3\)</span> 整除的 <code>key</code> 都会被映射到 <span class="arithmatex">\(0\)</span>、<span class="arithmatex">\(3\)</span>、<span class="arithmatex">\(6\)</span> 这三个哈希值。</p>
 <div class="arithmatex">\[
 \begin{aligned}
 \text{modulus} &amp; = 9 \newline
@@ -3951,7 +3951,7 @@
 \text{hash} &amp; = \{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\dots \}
 \end{aligned}
 \]</div>
-<p>如果输入 <code>key</code> 恰好满足这种等差数列的数据分布，那么哈希值就会出现聚堆，从而加重哈希冲突。现在，假设将 <code>modulus</code> 替换为质数 <span class="arithmatex">\(13\)</span> ，由于 <code>key</code> 和 <code>modulus</code> 之间不存在公约数，输出的哈希值的均匀性会明显提升。</p>
+<p>如果输入 <code>key</code> 恰好满足这种等差数列的数据分布，那么哈希值就会出现聚堆，从而加重哈希冲突。现在，假设将 <code>modulus</code> 替换为质数 <span class="arithmatex">\(13\)</span> ，由于 <code>key</code> 和 <code>modulus</code> 之间不存在公约数，因此输出的哈希值的均匀性会明显提升。</p>
 <div class="arithmatex">\[
 \begin{aligned}
 \text{modulus} &amp; = 13 \newline
@@ -3959,15 +3959,15 @@
 \text{hash} &amp; = \{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \dots \}
 \end{aligned}
 \]</div>
-<p>值得说明的是，如果能够保证 <code>key</code> 是随机均匀分布的，那么选择质数或者合数作为模数都是可以的，它们都能输出均匀分布的哈希值。而当 <code>key</code> 的分布存在某种周期性时，对合数取模更容易出现聚集现象。</p>
+<p>值得说明的是，如果能够保证 <code>key</code> 是随机均匀分布的，那么选择质数或者合数作为模数都可以，它们都能输出均匀分布的哈希值。而当 <code>key</code> 的分布存在某种周期性时，对合数取模更容易出现聚集现象。</p>
 <p>总而言之，我们通常选取质数作为模数，并且这个质数最好足够大，以尽可能消除周期性模式，提升哈希算法的稳健性。</p>
 <h2 id="633">6.3.3 &nbsp; 常见哈希算法<a class="headerlink" href="#633" title="Permanent link">&para;</a></h2>
 <p>不难发现，以上介绍的简单哈希算法都比较“脆弱”，远远没有达到哈希算法的设计目标。例如，由于加法和异或满足交换律，因此加法哈希和异或哈希无法区分内容相同但顺序不同的字符串，这可能会加剧哈希冲突，并引起一些安全问题。</p>
-<p>在实际中，我们通常会用一些标准哈希算法，例如 MD5、SHA-1、SHA-2、SHA3 等。它们可以将任意长度的输入数据映射到恒定长度的哈希值。</p>
+<p>在实际中，我们通常会用一些标准哈希算法，例如 MD5、SHA-1、SHA-2、SHA-3 等。它们可以将任意长度的输入数据映射到恒定长度的哈希值。</p>
 <p>近一个世纪以来，哈希算法处在不断升级与优化的过程中。一部分研究人员努力提升哈希算法的性能，另一部分研究人员和黑客则致力于寻找哈希算法的安全性问题。表 6-2 展示了在实际应用中常见的哈希算法。</p>
 <ul>
 <li>MD5 和 SHA-1 已多次被成功攻击，因此它们被各类安全应用弃用。</li>
-<li>SHA-2 系列中的 SHA-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常被用在各类安全应用与协议中。</li>
+<li>SHA-2 系列中的 SHA-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常用在各类安全应用与协议中。</li>
 <li>SHA-3 相较 SHA-2 的实现开销更低、计算效率更高，但目前使用覆盖度不如 SHA-2 系列。</li>
 </ul>
 <p align="center"> 表 6-2 &nbsp; 常见的哈希算法 </p>
@@ -3995,7 +3995,7 @@
 <td>输出长度</td>
 <td>128 bits</td>
 <td>160 bits</td>
-<td>256 / 512 bits</td>
+<td>256/512 bits</td>
 <td>224/256/384/512 bits</td>
 </tr>
 <tr>
@@ -4026,7 +4026,7 @@
 <p>我们知道，哈希表的 <code>key</code> 可以是整数、小数或字符串等数据类型。编程语言通常会为这些数据类型提供内置的哈希算法，用于计算哈希表中的桶索引。以 Python 为例，我们可以调用 <code>hash()</code> 函数来计算各种数据类型的哈希值。</p>
 <ul>
 <li>整数和布尔量的哈希值就是其本身。</li>
-<li>浮点数和字符串的哈希值计算较为复杂，有兴趣的同学请自行学习。</li>
+<li>浮点数和字符串的哈希值计算较为复杂，有兴趣的读者请自行学习。</li>
 <li>元组的哈希值是对其中每一个元素进行哈希，然后将这些哈希值组合起来，得到单一的哈希值。</li>
 <li>对象的哈希值基于其内存地址生成。通过重写对象的哈希方法，可实现基于内容生成哈希值。</li>
 </ul>
@@ -4051,7 +4051,7 @@
 <a id="__codelineno-13-12" name="__codelineno-13-12" href="#__codelineno-13-12"></a>
 <a id="__codelineno-13-13" name="__codelineno-13-13" href="#__codelineno-13-13"></a><span class="nb">str</span> <span class="o">=</span> <span class="s2">&quot;Hello 算法&quot;</span>
 <a id="__codelineno-13-14" name="__codelineno-13-14" href="#__codelineno-13-14"></a><span class="n">hash_str</span> <span class="o">=</span> <span class="nb">hash</span><span class="p">(</span><span class="nb">str</span><span class="p">)</span>
-<a id="__codelineno-13-15" name="__codelineno-13-15" href="#__codelineno-13-15"></a><span class="c1"># 字符串 Hello 算法 的哈希值为 4617003410720528961</span>
+<a id="__codelineno-13-15" name="__codelineno-13-15" href="#__codelineno-13-15"></a><span class="c1"># 字符串“Hello 算法”的哈希值为 4617003410720528961</span>
 <a id="__codelineno-13-16" name="__codelineno-13-16" href="#__codelineno-13-16"></a>
 <a id="__codelineno-13-17" name="__codelineno-13-17" href="#__codelineno-13-17"></a><span class="n">tup</span> <span class="o">=</span> <span class="p">(</span><span class="mi">12836</span><span class="p">,</span> <span class="s2">&quot;小哈&quot;</span><span class="p">)</span>
 <a id="__codelineno-13-18" name="__codelineno-13-18" href="#__codelineno-13-18"></a><span class="n">hash_tup</span> <span class="o">=</span> <span class="nb">hash</span><span class="p">(</span><span class="n">tup</span><span class="p">)</span>
@@ -4077,7 +4077,7 @@
 <a id="__codelineno-14-12" name="__codelineno-14-12" href="#__codelineno-14-12"></a>
 <a id="__codelineno-14-13" name="__codelineno-14-13" href="#__codelineno-14-13"></a><span class="n">string</span><span class="w"> </span><span class="n">str</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&quot;Hello 算法&quot;</span><span class="p">;</span>
 <a id="__codelineno-14-14" name="__codelineno-14-14" href="#__codelineno-14-14"></a><span class="kt">size_t</span><span class="w"> </span><span class="n">hashStr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hash</span><span class="o">&lt;</span><span class="n">string</span><span class="o">&gt;</span><span class="p">()(</span><span class="n">str</span><span class="p">);</span>
-<a id="__codelineno-14-15" name="__codelineno-14-15" href="#__codelineno-14-15"></a><span class="c1">// 字符串 Hello 算法 的哈希值为 15466937326284535026</span>
+<a id="__codelineno-14-15" name="__codelineno-14-15" href="#__codelineno-14-15"></a><span class="c1">// 字符串“Hello 算法”的哈希值为 15466937326284535026</span>
 <a id="__codelineno-14-16" name="__codelineno-14-16" href="#__codelineno-14-16"></a>
 <a id="__codelineno-14-17" name="__codelineno-14-17" href="#__codelineno-14-17"></a><span class="c1">// 在 C++ 中，内置 std:hash() 仅提供基本数据类型的哈希值计算</span>
 <a id="__codelineno-14-18" name="__codelineno-14-18" href="#__codelineno-14-18"></a><span class="c1">// 数组、对象的哈希值计算需要自行实现</span>
@@ -4098,7 +4098,7 @@
 <a id="__codelineno-15-12" name="__codelineno-15-12" href="#__codelineno-15-12"></a>
 <a id="__codelineno-15-13" name="__codelineno-15-13" href="#__codelineno-15-13"></a><span class="n">String</span><span class="w"> </span><span class="n">str</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&quot;Hello 算法&quot;</span><span class="p">;</span>
 <a id="__codelineno-15-14" name="__codelineno-15-14" href="#__codelineno-15-14"></a><span class="kt">int</span><span class="w"> </span><span class="n">hashStr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">str</span><span class="p">.</span><span class="na">hashCode</span><span class="p">();</span>
-<a id="__codelineno-15-15" name="__codelineno-15-15" href="#__codelineno-15-15"></a><span class="c1">// 字符串 Hello 算法 的哈希值为 -727081396</span>
+<a id="__codelineno-15-15" name="__codelineno-15-15" href="#__codelineno-15-15"></a><span class="c1">// 字符串“Hello 算法”的哈希值为 -727081396</span>
 <a id="__codelineno-15-16" name="__codelineno-15-16" href="#__codelineno-15-16"></a>
 <a id="__codelineno-15-17" name="__codelineno-15-17" href="#__codelineno-15-17"></a><span class="n">Object</span><span class="o">[]</span><span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="mi">12836</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;小哈&quot;</span><span class="w"> </span><span class="p">};</span>
 <a id="__codelineno-15-18" name="__codelineno-15-18" href="#__codelineno-15-18"></a><span class="kt">int</span><span class="w"> </span><span class="n">hashTup</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Arrays</span><span class="p">.</span><span class="na">hashCode</span><span class="p">(</span><span class="n">arr</span><span class="p">);</span>
@@ -4124,7 +4124,7 @@
 <a id="__codelineno-16-12" name="__codelineno-16-12" href="#__codelineno-16-12"></a>
 <a id="__codelineno-16-13" name="__codelineno-16-13" href="#__codelineno-16-13"></a><span class="kt">string</span><span class="w"> </span><span class="n">str</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&quot;Hello 算法&quot;</span><span class="p">;</span>
 <a id="__codelineno-16-14" name="__codelineno-16-14" href="#__codelineno-16-14"></a><span class="kt">int</span><span class="w"> </span><span class="n">hashStr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">str</span><span class="p">.</span><span class="n">GetHashCode</span><span class="p">();</span>
-<a id="__codelineno-16-15" name="__codelineno-16-15" href="#__codelineno-16-15"></a><span class="c1">// 字符串 Hello 算法 的哈希值为 -586107568;</span>
+<a id="__codelineno-16-15" name="__codelineno-16-15" href="#__codelineno-16-15"></a><span class="c1">// 字符串“Hello 算法”的哈希值为 -586107568;</span>
 <a id="__codelineno-16-16" name="__codelineno-16-16" href="#__codelineno-16-16"></a>
 <a id="__codelineno-16-17" name="__codelineno-16-17" href="#__codelineno-16-17"></a><span class="kt">object</span><span class="p">[]</span><span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">[</span><span class="m">12836</span><span class="p">,</span><span class="w"> </span><span class="s">&quot;小哈&quot;</span><span class="p">];</span>
 <a id="__codelineno-16-18" name="__codelineno-16-18" href="#__codelineno-16-18"></a><span class="kt">int</span><span class="w"> </span><span class="n">hashTup</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">arr</span><span class="p">.</span><span class="n">GetHashCode</span><span class="p">();</span>
@@ -4154,7 +4154,7 @@
 <a id="__codelineno-18-12" name="__codelineno-18-12" href="#__codelineno-18-12"></a>
 <a id="__codelineno-18-13" name="__codelineno-18-13" href="#__codelineno-18-13"></a><span class="kd">let</span> <span class="nv">str</span> <span class="p">=</span> <span class="s">&quot;Hello 算法&quot;</span>
 <a id="__codelineno-18-14" name="__codelineno-18-14" href="#__codelineno-18-14"></a><span class="kd">let</span> <span class="nv">hashStr</span> <span class="p">=</span> <span class="n">str</span><span class="p">.</span><span class="n">hashValue</span>
-<a id="__codelineno-18-15" name="__codelineno-18-15" href="#__codelineno-18-15"></a><span class="c1">// 字符串 Hello 算法 的哈希值为 -7850626797806988787</span>
+<a id="__codelineno-18-15" name="__codelineno-18-15" href="#__codelineno-18-15"></a><span class="c1">// 字符串“Hello 算法”的哈希值为 -7850626797806988787</span>
 <a id="__codelineno-18-16" name="__codelineno-18-16" href="#__codelineno-18-16"></a>
 <a id="__codelineno-18-17" name="__codelineno-18-17" href="#__codelineno-18-17"></a><span class="kd">let</span> <span class="nv">arr</span> <span class="p">=</span> <span class="p">[</span><span class="n">AnyHashable</span><span class="p">(</span><span class="mi">12836</span><span class="p">),</span> <span class="n">AnyHashable</span><span class="p">(</span><span class="s">&quot;小哈&quot;</span><span class="p">)]</span>
 <a id="__codelineno-18-18" name="__codelineno-18-18" href="#__codelineno-18-18"></a><span class="kd">let</span> <span class="nv">hashTup</span> <span class="p">=</span> <span class="n">arr</span><span class="p">.</span><span class="n">hashValue</span>
@@ -4188,7 +4188,7 @@
 <a id="__codelineno-21-12" name="__codelineno-21-12" href="#__codelineno-21-12"></a>
 <a id="__codelineno-21-13" name="__codelineno-21-13" href="#__codelineno-21-13"></a><span class="kt">String</span><span class="w"> </span><span class="n">str</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">&quot;Hello 算法&quot;</span><span class="p">;</span>
 <a id="__codelineno-21-14" name="__codelineno-21-14" href="#__codelineno-21-14"></a><span class="kt">int</span><span class="w"> </span><span class="n">hashStr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">str</span><span class="p">.</span><span class="n">hashCode</span><span class="p">;</span>
-<a id="__codelineno-21-15" name="__codelineno-21-15" href="#__codelineno-21-15"></a><span class="c1">// 字符串 Hello 算法 的哈希值为 468167534</span>
+<a id="__codelineno-21-15" name="__codelineno-21-15" href="#__codelineno-21-15"></a><span class="c1">// 字符串“Hello 算法”的哈希值为 468167534</span>
 <a id="__codelineno-21-16" name="__codelineno-21-16" href="#__codelineno-21-16"></a>
 <a id="__codelineno-21-17" name="__codelineno-21-17" href="#__codelineno-21-17"></a><span class="n">List</span><span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">[</span><span class="m">12836</span><span class="p">,</span><span class="w"> </span><span class="s2">&quot;小哈&quot;</span><span class="p">];</span>
 <a id="__codelineno-21-18" name="__codelineno-21-18" href="#__codelineno-21-18"></a><span class="kt">int</span><span class="w"> </span><span class="n">hashArr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">arr</span><span class="p">.</span><span class="n">hashCode</span><span class="p">;</span>
@@ -4226,7 +4226,7 @@
 <a id="__codelineno-22-24" name="__codelineno-22-24" href="#__codelineno-22-24"></a><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">str_hasher</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">DefaultHasher</span>::<span class="n">new</span><span class="p">();</span>
 <a id="__codelineno-22-25" name="__codelineno-22-25" href="#__codelineno-22-25"></a><span class="kt">str</span><span class="p">.</span><span class="n">hash</span><span class="p">(</span><span class="o">&amp;</span><span class="k">mut</span><span class="w"> </span><span class="n">str_hasher</span><span class="p">);</span>
 <a id="__codelineno-22-26" name="__codelineno-22-26" href="#__codelineno-22-26"></a><span class="kd">let</span><span class="w"> </span><span class="n">hash_str</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">str_hasher</span><span class="p">.</span><span class="n">finish</span><span class="p">();</span>
-<a id="__codelineno-22-27" name="__codelineno-22-27" href="#__codelineno-22-27"></a><span class="c1">// 字符串 Hello 算法 的哈希值为 16092673739211250988</span>
+<a id="__codelineno-22-27" name="__codelineno-22-27" href="#__codelineno-22-27"></a><span class="c1">// 字符串“Hello 算法”的哈希值为 16092673739211250988</span>
 <a id="__codelineno-22-28" name="__codelineno-22-28" href="#__codelineno-22-28"></a>
 <a id="__codelineno-22-29" name="__codelineno-22-29" href="#__codelineno-22-29"></a><span class="kd">let</span><span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="o">&amp;</span><span class="mi">12836</span><span class="p">,</span><span class="w"> </span><span class="o">&amp;</span><span class="s">&quot;小哈&quot;</span><span class="p">);</span>
 <a id="__codelineno-22-30" name="__codelineno-22-30" href="#__codelineno-22-30"></a><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">tup_hasher</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">DefaultHasher</span>::<span class="n">new</span><span class="p">();</span>