CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-13 18:00:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

deploy

Browse Source
This commit is contained in:
krahets
2023-07-24 03:03:58 +08:00
parent a86a371780
commit 3e2ab6a857
19 changed files with 379 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
chapter_hashing/hash_algorithm/index.html
View File

@@ -3402,23 +3402,24 @@
<h1 id="63">6.3. &nbsp; 哈希算法<a class="headerlink" href="#63" title="Permanent link">&para;</a></h1>
<p>在上两节中，我们了解了哈希表的工作原理，以及哈希冲突的处理方法。然而，无论是开放寻址还是链地址法，<strong>它们只能保证哈希表可以在发生冲突时正常工作，但无法减少哈希冲突的发生</strong>。</p>
<p>如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。例如对于链地址哈希表，理想情况下键值对平均分布在各个桶中，达到最好的查询效率；最差情况下全部键值都被存储到同一个桶中，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> 。</p>
<p>在上两节中，我们了解了哈希表的工作原理和哈希冲突的处理方法。然而无论是开放寻址还是链地址法，<strong>它们只能保证哈希表可以在发生冲突时正常工作，但无法减少哈希冲突的发生</strong>。</p>
<p>如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。对于链地址哈希表，理想情况下键值对平均分布在各个桶中，达到最佳查询效率；最差情况下所有键值对都被存储到同一个桶中，时间复杂度退化至 <span class="arithmatex">\(O(n)\)</span> 。</p>
<p><img alt="哈希冲突的最佳与最差情况" src="../hash_algorithm.assets/hash_collision_best_worst_condition.png" /></p>
<p align="center"> Fig. 哈希冲突的最佳与最差情况 </p>
<p><strong>键值对的分布情况是由哈希函数决定的</strong>。回忆哈希函数的计算步骤，先计算哈希值，再对数组长度取模：</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>，进而决定了键值对在哈希表中的分布。因此，为了减小哈希冲突的发生概率，我们需要将注意力集中在哈希算法 <code>hash()</code> 的设计上。</p>
<p>观察以上公式，当哈希表容量 <code>capacity</code> 固定时，<strong>哈希算法 <code>hash()</code> 决定了输出值</strong>，进而决定了键值对在哈希表中的分布情况。</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>
</ul>
<p>实际上，哈希算法除了可以用于实现哈希表，还广泛应用于其他领域中，包括：</p>
<p>实际上，哈希算法除了可以用于实现哈希表，还广泛应用于其他领域中。举两个例子：</p>
<ul>
<li><strong>密码存储</strong>：为了保护用户密码的安全，系统通常不会直接存储用户的明文密码，而是存储密码的哈希值。当用户输入密码时，系统会对输入的密码计算哈希值，然后与存储的哈希值进行比较。如果两者匹配，那么密码就被视为正确。</li>
<li><strong>数据完整性检查</strong>：数据发送方可以计算数据的哈希值并将其一同发送；接收方可以重新计算接收到的数据的哈希值，并与接收到的哈希值进行比较。如果两者匹配，那么数据就被视为完整的。</li>
@@ -3428,9 +3429,9 @@
<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>
<p>请注意，<strong>“均匀分布”与“抗碰撞性”是两个独立的概念</strong>，满足均匀分布不一定满足抗碰撞性。例如，在随机输入 <code>key</code> 下，哈希函数 <code>key % 100</code> 可以产生均匀分布的输出。然而该哈希算法过于简单，所有后两位相等的 <code>key</code> 的输出都相同，因此我们可以很容易地从哈希值反推出可用的 <code>key</code> ，从而破解密码。</p>
<h2 id="632">6.3.2. &nbsp; 哈希算法的设计<a class="headerlink" href="#632" title="Permanent link">&para;</a></h2>
<p>哈希算法的设计是一个复杂且需要考虑许多因素的问题。然而，对于一些简单场景，我们也能设计一些简单的哈希算法，以字符串哈希为例：</p>
<p>哈希算法的设计是一个复杂且需要考虑许多因素的问题。然而对于简单场景，我们也能设计一些简单的哈希算法。以字符串哈希为例：</p>
<ul>
<li><strong>加法哈希</strong>：对输入的每个字符的 ASCII 码进行相加，将得到的总和作为哈希值。</li>
<li><strong>乘法哈希</strong>：利用了乘法的不相关性，每轮乘以一个常数，将各个字符的 ASCII 码累积到哈希值中。</li>
@@ -3752,7 +3753,7 @@
</div>
</div>
</div>
<p>观察发现，每种哈希算法的最后一步都是对大质数 <span class="arithmatex">\(1000000007\)</span> 取模，以确保哈希值在合适的范围内。值得思考的是，为什么要强调对质数取模，对合数取模的弊端是什么？这是一个有趣的问题。</p>
<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>
<div class="arithmatex">\[
@@ -3770,12 +3771,17 @@
\text{hash} &amp; = \{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \cdots \}
\end{aligned}
\]</div>
<p>值得强调的是，如果能够保证 <code>key</code> 是随机均匀分布的，那么选择质数或者合数作为模数都是可以的，它们都能输出均匀分布的哈希值。而当 <code>key</code> 的分布存在某种周期性时，对合数取模更容易出现聚集现象。</p>
<p>总而言之，我们通常选取质数作为模数，并且这个质数最好大一些，以提升哈希算法的稳健性。</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-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常被用在各类安全应用与协议中。SHA-3 相较 SHA-2 的实现开销更低、计算效率更高，但目前使用覆盖度不如 SHA-2 系列。</p>
<p>在实际中，我们通常会用一些标准哈希算法，例如 MD5 , SHA-1 , SHA-2 , SHA3 等。它们可以将任意长度的输入数据映射到恒定长度的哈希值。</p>
<p>近一个世纪以来，哈希算法处在不断升级与优化的过程中。一部分研究人员努力提升哈希算法的性能，另一部分研究人员和黑客则致力于寻找哈希算法的安全性问题。直至目前：</p>
<ul>
<li>MD5 和 SHA-1 已多次被成功攻击，因此它们被各类安全应用弃用。</li>
<li>SHA-2 系列中的 SHA-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常被用在各类安全应用与协议中。</li>
<li>SHA-3 相较 SHA-2 的实现开销更低、计算效率更高，但目前使用覆盖度不如 SHA-2 系列。</li>
</ul>
<table>
<thead>
<tr>
@@ -4011,12 +4017,9 @@
</div>
</div>
</div>
<p>在大多数编程语言中，<strong>只有不可变对象才可作为哈希表的 <code>key</code></strong> 。假如我们将列表（动态数组）作为 <code>key</code> ，当列表的内容发生变化时，它的哈希值也随之改变，我们就无法在哈希表中查询到原先的 <code>value</code> 了。</p>
<p>虽然自定义对象（例如链表节点）的成员变量是可变的，但它是可哈希的，这是因为对象的哈希值默认基于内存地址生成。即使对象的内容发生了变化，但它的内存地址不变，哈希值仍然是不变的。</p>
<div class="admonition tip">
<p class="admonition-title">向哈希函数加盐</p>
<p>Python 解释器在每次启动时，都会为字符串哈希函数加入一个随机的盐（Salt）值。因此在不同的 Python 运行实例中，同一字符串的哈希值通常是不同的。此做法可以有效防止 HashDoS 攻击，提升哈希算法的安全性。</p>
</div>
<p>在许多编程语言中，<strong>只有不可变对象才可作为哈希表的 <code>key</code></strong> 。假如我们将列表（动态数组）作为 <code>key</code> ，当列表的内容发生变化时，它的哈希值也随之改变，我们就无法在哈希表中查询到原先的 <code>value</code> 了。</p>
<p>虽然自定义对象（比如链表节点）的成员变量是可变的，但它是可哈希的。<strong>这是因为对象的哈希值通常是基于内存地址生成的</strong>，即使对象的内容发生了变化，但它的内存地址不变，哈希值仍然是不变的。</p>
<p>细心的你可能发现在不同控制台中运行程序时，输出的哈希值是不同的。<strong>这是因为 Python 解释器在每次启动时，都会为字符串哈希函数加入一个随机的盐（Salt）值</strong>。这种做法可以有效防止 HashDoS 攻击，提升哈希算法的安全性。</p>