deploy

chapter_hashing/hash_collision/index.html

@@ -1794,63 +1794,63 @@
 
 
 <h1 id="62">6.2. &nbsp; 哈希冲突<a class="headerlink" href="#62" title="Permanent link">&para;</a></h1>
-<p>理想情况下，哈希函数应该为每个输入产生唯一的输出，使得 key 和 value 一一对应。而实际上，往往存在向哈希函数输入不同的 key 而产生相同输出的情况，这种情况被称为「哈希冲突 Hash Collision」。哈希冲突会导致查询结果错误，从而严重影响哈希表的可用性。</p>
-<p>那么，为什么会出现哈希冲突呢？本质上看，<strong>由于哈希函数的输入空间往往远大于输出空间</strong>，因此不可避免地会出现多个输入产生相同输出的情况，即为哈希冲突。比如，输入空间是全体整数，输出空间是一个固定大小的数组，那么必定会有多个整数映射到同一个数组索引。</p>
-<p>为了缓解哈希冲突，一方面，<strong>我们可以通过哈希表扩容来减小冲突概率</strong>。极端情况下，当输入空间和输出空间大小相等时，哈希表就等价于数组了，每个 key 都对应唯一的数组索引，可谓“大力出奇迹”。</p>
-<p>另一方面，<strong>考虑通过优化哈希表的表示来缓解哈希冲突</strong>，常见的方法有「链式地址 Separate Chaining」和「开放寻址 Open Addressing」。</p>
+<p>在理想情况下，哈希函数应为每个输入生成唯一的输出，实现 key 和 value 的一一对应。然而实际上，向哈希函数输入不同的 key 却产生相同输出的情况是存在的，这种现象被称为「哈希冲突 Hash Collision」。哈希冲突可能导致查询结果错误，从而严重影响哈希表的可用性。</p>
+<p>那么，为何会出现哈希冲突呢？从本质上看，由于哈希函数的输入空间通常远大于输出空间，因此多个输入产生相同输出的情况是不可避免的。例如，若输入空间为全体整数，而输出空间为固定大小的数组，则必然有多个整数映射至同一数组索引。</p>
+<p>为了减轻哈希冲突，一方面，<strong>可以通过扩大哈希表容量来降低冲突概率</strong>。极端情况下，当输入空间和输出空间大小相等时，哈希表等同于数组，每个 key 都对应唯一的数组索引，可谓“大力出奇迹”。</p>
+<p>另一方面，<strong>可以考虑优化哈希表的表示以缓解哈希冲突</strong>，常用方法包括「链式地址 Separate Chaining」和「开放寻址 Open Addressing」。</p>
 <h2 id="621">6.2.1. &nbsp; 哈希表扩容<a class="headerlink" href="#621" title="Permanent link">&para;</a></h2>
-<p>哈希函数的最后一步往往是对桶数量 <span class="arithmatex">\(n\)</span> 取余，以将哈希值映射到桶的索引范围，从而将 key 放入对应的桶中。当哈希表容量越大（即 <span class="arithmatex">\(n\)</span> 越大）时，多个 key 被分配到同一个桶中的概率就越低，冲突就越少。</p>
-<p>因此，<strong>在哈希表内的冲突整体比较严重时，编程语言一般通过扩容哈希表来缓解</strong>。与数组扩容类似，哈希表扩容需要将所有键值对从原哈希表移动至新哈希表，<strong>开销很大</strong>。</p>
-<p>编程语言一般使用「负载因子 Load Factor」来评估哈希冲突的严重程度，<strong>其定义为哈希表中元素数量除以桶数量</strong>，常用作哈希表扩容的触发条件。比如在 Java 中，当负载因子 <span class="arithmatex">\(&gt; 0.75\)</span> 时，系统会将 HashMap 容量扩充至原先的 <span class="arithmatex">\(2\)</span> 倍。</p>
+<p>哈希函数的最后一步通常是对桶数量 <span class="arithmatex">\(n\)</span> 取余，作用是将哈希值映射到桶索引范围，从而将 key 放入对应的桶中。当哈希表容量越大（即 <span class="arithmatex">\(n\)</span> 越大）时，多个 key 被分配到同一个桶中的概率就越低，冲突就越少。</p>
+<p>因此，<strong>当哈希表内的冲突总体较为严重时，编程语言通常通过扩容哈希表来缓解冲突</strong>。类似于数组扩容，哈希表扩容需将所有键值对从原哈希表迁移至新哈希表，开销较大。</p>
+<p>编程语言通常使用「负载因子 Load Factor」来衡量哈希冲突的严重程度，<strong>定义为哈希表中元素数量除以桶数量</strong>，常作为哈希表扩容的触发条件。在 Java 中，当负载因子 <span class="arithmatex">\(&gt; 0.75\)</span> 时，系统会将 HashMap 容量扩展为原先的 <span class="arithmatex">\(2\)</span> 倍。</p>
 <h2 id="622">6.2.2. &nbsp; 链式地址<a class="headerlink" href="#622" title="Permanent link">&para;</a></h2>
-<p>在原始哈希表中，每个桶只能存储一个键值对。<strong>链式地址考虑将单个元素转化成一个链表，将键值对作为链表结点，将所有冲突键值对都存储在一个链表中</strong>。</p>
+<p>在原始哈希表中，每个桶仅能存储一个键值对。<strong>链式地址将单个元素转换为链表，将键值对作为链表节点，将所有发生冲突的键值对都存储在同一链表中</strong>。</p>
 <p><img alt="链式地址" src="../hash_collision.assets/hash_collision_chaining.png" /></p>
 <p align="center"> Fig. 链式地址 </p>
 
-<p>链式地址下，哈希表操作方法为：</p>
+<p>链式地址下，哈希表的操作方法包括：</p>
 <ul>
-<li><strong>查询元素</strong>：输入 key ，经过哈希函数得到数组索引，即可访问链表头结点，再通过遍历链表并对比 key 来查找键值对。</li>
-<li><strong>添加元素</strong>：先通过哈希函数访问链表头结点，再将结点（即键值对）添加到链表即可。</li>
-<li><strong>删除元素</strong>：同样先根据哈希函数结果访问链表头部，再遍历链表查找对应结点，删除之即可。</li>
+<li><strong>查询元素</strong>：输入 key ，经过哈希函数得到数组索引，即可访问链表头结点，然后遍历链表并对比 key 以查找目标键值对。</li>
+<li><strong>添加元素</strong>：先通过哈希函数访问链表头结点，然后将结点（即键值对）添加到链表中。</li>
+<li><strong>删除元素</strong>：根据哈希函数的结果访问链表头部，接着遍历链表以查找目标结点，并将其删除。</li>
 </ul>
-<p>链式地址虽然解决了哈希冲突问题，但仍存在局限性，包括：</p>
+<p>尽管链式地址法解决了哈希冲突问题，但仍存在一些局限性，包括：</p>
 <ul>
-<li><strong>占用空间变大</strong>，因为链表或二叉树包含结点指针，相比于数组更加耗费内存空间；</li>
+<li><strong>占用空间增大</strong>，由于链表或二叉树包含结点指针，相比数组更加耗费内存空间；</li>
 <li><strong>查询效率降低</strong>，因为需要线性遍历链表来查找对应元素；</li>
 </ul>
-<p>为了提升操作效率，<strong>可以把「链表」转化为「AVL 树」或「红黑树」</strong>，将查询操作的时间复杂度优化至 <span class="arithmatex">\(O(\log n)\)</span> 。</p>
+<p>为了提高操作效率，<strong>可以将链表转换为「AVL 树」或「红黑树」</strong>，将查询操作的时间复杂度优化至 <span class="arithmatex">\(O(\log n)\)</span> 。</p>
 <h2 id="623">6.2.3. &nbsp; 开放寻址<a class="headerlink" href="#623" title="Permanent link">&para;</a></h2>
-<p>「开放寻址」不引入额外数据结构，而是通过“多次探测”来解决哈希冲突。根据探测方法的不同，主要分为 <strong>线性探测、平方探测、多次哈希</strong>。</p>
+<p>「开放寻址」方法不引入额外的数据结构，而是通过“多次探测”来解决哈希冲突，<strong>探测方主要包括线性探测、平方探测、多次哈希</strong>。</p>
 <h3 id="_1">线性探测<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
-<p>「线性探测」使用固定步长的线性查找来解决哈希冲突。</p>
-<p><strong>插入元素</strong>：如果出现哈希冲突，则从冲突位置向后线性遍历（步长一般取 1 ），直到找到一个空位，则将元素插入到该空位中。</p>
-<p><strong>查找元素</strong>：若出现哈希冲突，则使用相同步长执行线性查找，会遇到两种情况：</p>
+<p>「线性探测」采用固定步长的线性查找来解决哈希冲突。</p>
+<p><strong>插入元素</strong>：若出现哈希冲突，则从冲突位置向后线性遍历（步长通常为 <span class="arithmatex">\(1\)</span> ），直至找到空位，将元素插入其中。</p>
+<p><strong>查找元素</strong>：在出现哈希冲突时，使用相同步长进行线性查找，可能遇到以下两种情况。</p>
 <ol>
 <li>找到对应元素，返回 value 即可；</li>
-<li>若遇到空位，则说明查找键值对不在哈希表中；</li>
+<li>若遇到空位，说明目标键值对不在哈希表中；</li>
 </ol>
 <p><img alt="线性探测" src="../hash_collision.assets/hash_collision_linear_probing.png" /></p>
 <p align="center"> Fig. 线性探测 </p>
 
 <p>线性探测存在以下缺陷：</p>
 <ul>
-<li><strong>不能直接删除元素</strong>。删除元素会导致数组内出现一个空位，在查找其他元素时，该空位有可能导致程序认为元素不存在（即上述第 <code>2.</code> 种情况）。因此需要借助一个标志位来标记删除元素。</li>
-<li><strong>容易产生聚集</strong>。数组内被占用的连续位置越长，这些连续位置发生哈希冲突的可能性越大，从而进一步促进这一位置的“聚堆生长”，最终导致增删查改操作效率的劣化。</li>
+<li><strong>不能直接删除元素</strong>。删除元素会在数组内产生一个空位，查找其他元素时，该空位可能导致程序误判元素不存在（即上述第 <code>2.</code> 种情况）。因此，需要借助一个标志位来标记已删除元素。</li>
+<li><strong>容易产生聚集</strong>。数组内连续被占用位置越长，这些连续位置发生哈希冲突的可能性越大，进一步促使这一位置的“聚堆生长”，最终导致增删查改操作效率降低。</li>
 </ul>
 <h3 id="_2">多次哈希<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
-<p>顾名思义，「多次哈希」的思路是使用多个哈希函数 <span class="arithmatex">\(f_1(x)\)</span> , <span class="arithmatex">\(f_2(x)\)</span> , <span class="arithmatex">\(f_3(x)\)</span> , <span class="arithmatex">\(\cdots\)</span> 进行探测。</p>
-<p><strong>插入元素</strong>：若哈希函数 <span class="arithmatex">\(f_1(x)\)</span> 出现冲突，则尝试 <span class="arithmatex">\(f_2(x)\)</span> ，以此类推……直到找到空位后插入元素。</p>
-<p><strong>查找元素</strong>：以相同的哈希函数顺序查找，存在两种情况：</p>
+<p>顾名思义，「多次哈希」方法是使用多个哈希函数 <span class="arithmatex">\(f_1(x)\)</span> , <span class="arithmatex">\(f_2(x)\)</span> , <span class="arithmatex">\(f_3(x)\)</span> , <span class="arithmatex">\(\cdots\)</span> 进行探测。</p>
+<p><strong>插入元素</strong>：若哈希函数 <span class="arithmatex">\(f_1(x)\)</span> 出现冲突，则尝试 <span class="arithmatex">\(f_2(x)\)</span> ，以此类推，直到找到空位后插入元素。</p>
+<p><strong>查找元素</strong>：在相同的哈希函数顺序下进行查找，存在以下两种情况：</p>
 <ol>
-<li>找到目标元素，则返回之；</li>
-<li>到空位或已尝试所有哈希函数，说明哈希表中无此元素；</li>
+<li>如果找到目标元素，则返回之；</li>
+<li>若遇到空位或已尝试所有哈希函数，则说明哈希表中不存在该元素；</li>
 </ol>
-<p>相比于「线性探测」，「多次哈希」方法更不容易产生聚集，代价是多个哈希函数增加了额外计算量。</p>
+<p>与线性探测相比，多次哈希方法不易产生聚集，但多个哈希函数会增加额外的计算量。</p>
 <div class="admonition note">
-<p class="admonition-title">工业界方案</p>
-<p>Java 采用「链式地址」。在 JDK 1.8 之后，HashMap 内数组长度大于 64 时，长度大于 8 的链表会被转化为「红黑树」，以提升查找性能。</p>
-<p>Python 采用「开放寻址」。字典 dict 使用伪随机数进行探测。 </p>
-<p>Golang 采用「链式地址」。Go 规定每个桶最多存储 8 个键值对，超出容量则连接一个溢出桶；当溢出桶过多时，会执行一次特殊的等量扩容操作，以保证性能。</p>
+<p class="admonition-title">哈希表设计方案</p>
+<p>Java 采用「链式地址」。自 JDK 1.8 以来，当 HashMap 内数组长度大于 64 且链表长度大于 8 时，链表会被转换为「红黑树」以提升查找性能。</p>
+<p>Python 采用「开放寻址」。字典 dict 使用伪随机数进行探测。</p>
+<p>Golang 采用「链式地址」。Go 规定每个桶最多存储 8 个键值对，超出容量则连接一个溢出桶；当溢出桶过多时，会执行一次特殊的等量扩容操作，以确保性能。</p>
 </div>
 
 

chapter_hashing/hash_map/index.html

@@ -1768,20 +1768,20 @@
 
 
 <h1 id="61">6.1. &nbsp; 哈希表<a class="headerlink" href="#61" title="Permanent link">&para;</a></h1>
-<p>哈希表通过建立「键 key」和「值 value」之间的映射，实现高效的元素查找。具体地，输入一个 key ，在哈希表中查询并获取 value ，时间复杂度为 <span class="arithmatex">\(O(1)\)</span> 。</p>
-<p>例如，给定一个包含 <span class="arithmatex">\(n\)</span> 个学生的数据库，每个学生有“姓名 <code>name</code> ”和“学号 <code>id</code> ”两项数据，希望实现一个查询功能：<strong>输入一个学号，返回对应的姓名</strong>，则可以使用哈希表实现。</p>
+<p>哈希表通过建立「键 key」与「值 value」之间的映射，实现高效的元素查询。具体而言，我们向哈希表输入一个 key，则可以在 <span class="arithmatex">\(O(1)\)</span> 时间内获取对应的 value 。</p>
+<p>以一个包含 <span class="arithmatex">\(n\)</span> 个学生的数据库为例，每个学生都有“姓名 <code>name</code>”和“学号 <code>id</code>”两项数据。假如我们希望实现查询功能，例如“输入一个学号，返回对应的姓名”，则可以采用哈希表来实现。</p>
 <p><img alt="哈希表的抽象表示" src="../hash_map.assets/hash_map.png" /></p>
 <p align="center"> Fig. 哈希表的抽象表示 </p>
 
 <h2 id="611">6.1.1. &nbsp; 哈希表效率<a class="headerlink" href="#611" title="Permanent link">&para;</a></h2>
-<p>除了哈希表之外，还可以使用以下数据结构来实现上述查询功能：</p>
+<p>除哈希表外，还可以使用以下数据结构来实现上述查询功能：</p>
 <ol>
 <li><strong>无序数组</strong>：每个元素为  <code>[学号, 姓名]</code> ；</li>
 <li><strong>有序数组</strong>：将 <code>1.</code> 中的数组按照学号从小到大排序；</li>
 <li><strong>链表</strong>：每个结点的值为 <code>[学号, 姓名]</code> ；</li>
 <li><strong>二叉搜索树</strong>：每个结点的值为 <code>[学号, 姓名]</code> ，根据学号大小来构建树；</li>
 </ol>
-<p>使用上述方法，各项操作的时间复杂度如下表所示（在此不做赘述，详解可见 <a href="https://www.hello-algo.com/chapter_tree/binary_search_tree/">二叉搜索树章节</a>）。无论是查找元素、还是增删元素，哈希表的时间复杂度都是 <span class="arithmatex">\(O(1)\)</span> ，全面胜出！</p>
+<p>各项操作的时间复杂度如下表所示（详解可见<a href="https://www.hello-algo.com/chapter_tree/binary_search_tree/">二叉搜索树章节</a>）。无论是查找元素还是增删元素，哈希表的时间复杂度都是 <span class="arithmatex">\(O(1)\)</span>，全面胜出！</p>
 <div class="center-table">
 <table>
 <thead>
@@ -2149,15 +2149,15 @@
 </div>
 </div>
 <h2 id="613">6.1.3. &nbsp; 哈希函数<a class="headerlink" href="#613" title="Permanent link">&para;</a></h2>
-<p>哈希表的底层实现是数组，并且可能包含链表、二叉树（红黑树）等数据结构，以提升查询性能（下节会讨论）。</p>
-<p>首先考虑最简单的情况，<strong>仅用一个「数组」来实现哈希表</strong>。根据习惯，我们将数组中的每个空位称为「桶 Bucket」，用于存储键值对。</p>
-<p>我们将键值对 key, value 包装成一个类 <code>Entry</code> ，并将所有 <code>Entry</code> 都放入数组中，那么每个 <code>Entry</code> 在数组中都有唯一的索引。而为了建立 key 和索引之间的映射关系，我们需要使用「哈希函数 Hash Function」。</p>
-<p>设哈希表的数组为 <code>buckets</code> ，哈希函数为 <code>f(x)</code> ，那么查询操作的步骤为：</p>
+<p>哈希表的底层实现为数组，同时可能包含链表、二叉树（红黑树）等数据结构，以提高查询性能（将在下节讨论）。</p>
+<p>首先考虑最简单的情况，<strong>仅使用一个数组来实现哈希表</strong>。通常，我们将数组中的每个空位称为「桶 Bucket」，用于存储键值对。</p>
+<p>我们将键值对 key, value 封装成一个类 <code>Entry</code> ，并将所有 <code>Entry</code> 放入数组中。这样，数组中的每个 <code>Entry</code> 都具有唯一的索引。为了建立 key 和索引之间的映射关系，我们需要使用「哈希函数 Hash Function」。</p>
+<p>设哈希表的数组为 <code>buckets</code> ，哈希函数为 <code>f(x)</code> ，那么查询操作的步骤如下：</p>
 <ol>
 <li>输入 <code>key</code> ，通过哈希函数计算出索引 <code>index</code> ，即 <code>index = f(key)</code> ；</li>
-<li>通过索引在数组中访问到键值对 <code>entry</code> ，即 <code>entry = buckets[index]</code> ，并在 <code>entry</code> 中获取到 <code>value</code> 即可；</li>
+<li>通过索引在数组中访问到键值对 <code>entry</code> ，即 <code>entry = buckets[index]</code> ，然后从 <code>entry</code> 中获取对应的 <code>value</code> ；</li>
 </ol>
-<p>以上述学生数据 <code>key 学号 -&gt; value 姓名</code> 为例，我们可以将「哈希函数」设计为</p>
+<p>以学生数据 <code>key 学号 -&gt; value 姓名</code> 为例，我们可以设计如下哈希函数：</p>
 <div class="arithmatex">\[
 f(x) = x \% 100
 \]</div>
@@ -3003,19 +3003,19 @@ f(x) = x \% 100
 </div>
 </div>
 <h2 id="614">6.1.4. &nbsp; 哈希冲突<a class="headerlink" href="#614" title="Permanent link">&para;</a></h2>
-<p>细心的同学可能会发现，<strong>哈希函数 <span class="arithmatex">\(f(x) = x \% 100\)</span> 会在某些情况下失效</strong>。具体地，当输入的 key 后两位相同时，哈希函数的计算结果也相同，指向同一个 value 。例如，分别查询两个学号 <span class="arithmatex">\(12836\)</span> 和 <span class="arithmatex">\(20336\)</span> ，则有</p>
+<p>细心的你可能已经注意到，<strong>在某些情况下，哈希函数 <span class="arithmatex">\(f(x) = x % 100\)</span> 可能无法正常工作</strong>。具体来说，当输入的 key 后两位相同时，哈希函数的计算结果也会相同，从而指向同一个 value 。例如，查询学号为 <span class="arithmatex">\(12836\)</span> 和 <span class="arithmatex">\(20336\)</span> 的两个学生时，我们得到：</p>
 <div class="arithmatex">\[
 f(12836) = f(20336) = 36
 \]</div>
-<p>两个学号指向了同一个姓名，这明显是不对的，我们将这种现象称为「哈希冲突 Hash Collision」。如何避免哈希冲突的问题将被留在下章讨论。</p>
+<p>这两个学号指向了同一个姓名，这显然是错误的。我们把这种情况称为「哈希冲突 Hash Collision」。在后续章节中，我们将讨论如何解决哈希冲突的问题。</p>
 <p><img alt="哈希冲突示例" src="../hash_map.assets/hash_collision.png" /></p>
 <p align="center"> Fig. 哈希冲突示例 </p>
 
-<p>综上所述，一个优秀的「哈希函数」应该具备以下特性：</p>
+<p>综上所述，一个优秀的哈希函数应具备以下特性：</p>
 <ul>
-<li>尽量少地发生哈希冲突；</li>
-<li>时间复杂度 <span class="arithmatex">\(O(1)\)</span> ，计算尽可能高效；</li>
-<li>空间使用率高，即“键值对占用空间 / 哈希表总占用空间”尽可能大；</li>
+<li>尽可能减少哈希冲突的发生；</li>
+<li>查询效率高且稳定，能够在绝大多数情况下达到 <span class="arithmatex">\(O(1)\)</span> 时间复杂度；</li>
+<li>较高的空间利用率，即使“键值对占用空间 / 哈希表总占用空间”比例最大化；</li>
 </ul>
 
 

chapter_hashing/summary/index.html

@@ -1681,15 +1681,15 @@
 
 <h1 id="63">6.3. &nbsp; 小结<a class="headerlink" href="#63" title="Permanent link">&para;</a></h1>
 <ul>
-<li>向哈希表中输入一个键 key ，查询到值 value 的时间复杂度为 <span class="arithmatex">\(O(1)\)</span> ，非常高效。</li>
-<li>哈希表的常用操作包括查询、添加与删除键值对、遍历键值对等。</li>
-<li>哈希函数将 key 映射到桶（数组）索引，从而访问到对应的值 value 。</li>
-<li>两个不同的 key 经过哈希函数可能得到相同的桶索引，进而发生哈希冲突，导致查询错误。</li>
-<li>缓解哈希冲突的途径有两种：哈希表扩容、优化哈希表的表示方式。</li>
-<li>负载因子定义为哈希表中元素数量除以桶槽数量，体现哈希冲突的严重程度，常用作哈希表扩容的触发条件。与数组扩容的原理类似，哈希表扩容操作开销也很大。</li>
-<li>链式地址考虑将单个元素转化成一个链表，将所有冲突元素都存储在一个链表中，从而解决哈希冲突。链表过长会导致查询效率变低，可以通过把链表转化为 AVL 树或红黑树来解决。</li>
-<li>开放寻址通过多次探测来解决哈希冲突。线性探测使用固定步长，缺点是不能删除元素且容易产生聚集。多次哈希使用多个哈希函数进行探测，相对线性探测不容易产生聚集，代价是多个哈希函数增加了计算量。</li>
-<li>在工业界中，Java 的 HashMap 采用链式地址、Python 的 Dict 采用开放寻址。</li>
+<li>哈希表能够在 <span class="arithmatex">\(O(1)\)</span> 时间内将键 key 映射到值 value，效率非常高。</li>
+<li>常见的哈希表操作包括查询、添加与删除键值对、遍历键值对等。</li>
+<li>哈希函数将 key 映射为数组索引（桶），以便访问对应的值 value 。</li>
+<li>两个不同的 key 可能在经过哈希函数后得到相同的索引，导致查询结果出错，这种现象被称为哈希冲突。</li>
+<li>缓解哈希冲突的方法主要有扩容哈希表和优化哈希表的表示方法。</li>
+<li>负载因子定义为哈希表中元素数量除以桶数量，反映了哈希冲突的严重程度，常用作触发哈希表扩容的条件。与数组扩容类似，哈希表扩容操作也会产生较大的开销。</li>
+<li>链式地址通过将单个元素转化为链表，将所有冲突元素存储在同一个链表中，从而解决哈希冲突。然而，过长的链表会降低查询效率，可以通过将链表转换为 AVL 树或红黑树来改善。</li>
+<li>开放寻址通过多次探测来解决哈希冲突。线性探测使用固定步长，缺点是不能删除元素且容易产生聚集。多次哈希使用多个哈希函数进行探测，相对线性探测不易产生聚集，但多个哈希函数增加了计算量。</li>
+<li>不同编程语言采取了不同的哈希表实现策略。例如，Java 的 HashMap 使用链式地址，而 Python 的 Dict 采用开放寻址。</li>
 </ul>