开放定址法详解：线性探测、平方探测与双重散列对比

1. 题眼拆解：开放定址法到底在考什么

1.1 一道“20分”题目的隐藏考点

如果你在刷题或者复习数据结构时看到“开放定址法 - 20分”这个标题，大概率是在某个在线评测系统里遇到了哈希表相关的题目。20分看起来不多，但它往往是整套卷子里区分“背过定义”和“真正会用”的一道分水岭。我见过太多人在这一题上丢分，不是不知道开放定址法是什么，而是拿到题目后不知道从哪一步开始思考——是先算哈希地址，还是先判断冲突，还是直接模拟插入过程？

这道题的核心只有一件事：给定一组关键字，让你用开放定址法的某种探测序列把它们逐个填入哈希表，并计算成功/失败情况下的平均查找长度。 表面是模拟，实际考的是三个层面：第一，你是否理解哈希函数和冲突处理的先后关系；第二，你是否能区分线性探测、二次探测、双重散列在“步长”上的本质差异；第三，你是否能在填表完成后正确统计探测次数。这三个层面任意一个出问题，20分基本就拿不全。

1.2 “定址”二字的含义：填坑而不是拉链

要真正理解开放定址法，先得跳出题目本身，看看它和另一种经典方法——链地址法（拉链法）——之间的思路差异。链地址法的逻辑是：每个桶是一个链表的头节点，冲突了就往链表后面挂，表里装的是“链表的入口”。而开放定址法的逻辑则完全不同：整个哈希表就是一块连续的数组空间，没有链表，每个槽位要么空着，要么被某个关键字占据。 当新元素算出的地址已经被占用时，它不能“另起炉灶”，只能在当前表里继续向后寻找下一个空位——这个过程叫“探测”。

“开放定址”这四个字，我个人理解是：哈希函数给出的初始地址只是一个“起点”，真正的存储位置是开放的，可以在整个表范围内通过探测序列重新确定。这个“重新确定”的过程依赖于三个要素：当前地址、探测步长、以及表是否还有空位。如果表满了还没找到空位，那才是真正的灾难——这种情况叫“溢出”，只能扩容或改用其他冲突处理方法。所以在实际题目里，通常都会保证表长大于关键字个数，或者明确告诉你装填因子，避免出现这种无解局面。

明白这个底层逻辑后，你会发现开放定址法所有看似复杂的规则，其实都围绕一个问题展开：当冲突发生时，下一步该跳到哪里去看？ 不同的探测方法只是回答这个问题的方式不同。把这个核心抓住，后面无论是算地址还是coding，思路都会清晰很多。

2. 三种探测方法：原理、场景与对比

2.1 线性探测法：最容易理解，也最容易踩坑

线性探测法的规则一句话就能说清：当初始地址 conflict 时，就依次检查 address+1、address+2……直到找到空位。用数学表达就是：

code复制探测序列 = (hash(key) + i) mod m   (i = 0, 1, 2, ...)

其中 m 是表长。注意 i从0开始，i=0时就是初始地址本身，如果那个位置正好空着，就直接放入，不需要额外探测。

让我用一个具体例子说明。假设表长 m = 11，哈希函数为 H(key) = key mod 11，需要依次插入的关键字序列是：{19, 14, 23, 1, 68, 20, 84, 27}。先算初始地址：

• 19 mod 11 = 8，槽位8空，直接放。
• 14 mod 11 = 3，槽位3空，直接放。
• 23 mod 11 = 1，槽位1空，直接放。
• 1 mod 11 = 1，槽位1已被23占据，冲突。线性探测到槽位2，空，放入。探测次数是2。
• 68 mod 11 = 2，槽位2已被1占据，冲突。探测到槽位3，也被14占据，继续探测槽位4，空，放入。探测次数是3。
• 20 mod 11 = 9，槽位9空，直接放。
• 84 mod 11 = 7，槽位7空，直接放。
• 27 mod 11 = 5，槽位5空，直接放。

最终表的状态（下标0到10）为：空、23、1、14、68、27、空、84、19、20、空。这个例子看起来简单，但注意看第5个关键字84：它虽然算出的地址是7，本身没冲突，但它前面的关键字68已经因为冲突被放到了4号位置——这就是开放定址法的一个特点：元素的最终存放位置和插入顺序强相关。 同样一组关键字，换一个插入顺序，最终表的结构可能完全不同。

线性探测的优点是实现最简单，CPU缓存友好（因为只访问连续内存），但它有个非常著名的缺陷：一次堆积（primary clustering）。当表中多个元素都映射到相近的地址区域时，冲突后会形成一条连续占据的“长队”，后续映射到该区域附近的元素都需要沿着这条长队一步步往后探测，导致平均探测次数迅速增加。更麻烦的是，这条长队一旦形成，即使删除其中某些元素（如果只是把槽位置空），也会破坏探测链的连续性，使得原本存放在更长探测链上的元素变得“不可达”。

2.2 平方探测法：打破堆积，但小心探测不到空位

平方探测法的思路是让探测步长不再是固定的1，而是 i 的平方：

code复制探测序列 = (hash(key) + i²) mod m   (i = 0, 1, 2, ...)

也就是说，探测顺序是 address+1、address+4、address+9……而不是每次只前进一格。这样做的好处是显而易见的：由于步长不断增大，连续插入的元素不会紧紧挨在一起，能够有效缓解线性探测的“一次堆积”问题。我用同一组数据演示一下，哈希函数和表长不变，还是 m = 11, H(key) = key mod 11，插入顺序也相同。

• 19 → 地址8，空，直接放。
• 14 → 地址3，空，直接放。
• 23 → 地址1，空，直接放。
• 1 → 地址1，冲突。i=1，探测地址(1+1) mod 11 = 2，空，放入。探测次数2。
• 68 → 地址2，冲突。i=1，探测地址3，被占；i=2，探测地址(2+4) mod 11 = 6，空，放入。探测次数3。
• 20 → 地址9，空，直接放。
• 84 → 地址7，空，直接放。
• 27 → 地址5，空，直接放。

这个例子里平方探测的优势还不算特别明显，因为数据量小。但你已经能看到一个关键差异：68在线性探测中被放到了4号位，而在平方探测中直接跨到了6号位，跳过了14所在的3号位和后续可能继续堆积的区域。这就是平方探测的跳跃性带来的好处。

不过平方探测有个让很多人考试时栽跟头的约束：它不一定能探测到表里所有空位。 数学上可以证明，如果表长 m 是形如 4k+3 的素数（比如11、19、23），那么平方探测序列恰好能覆盖表的一半位置。如果 m 不是这种形式，甚至可能出现表还有空位但探测序列已经循环的情况。所以在实际应用和考试题目中，使用平方探测时基本都会特别说明表长满足这个条件，或者题目直接给定了合适的 m。你在计算时不需要自己证明这个条件，但要意识到：不能用平方探测来无限次探测，它的循环周期是有限的。

2.3 双重散列：探测步长由第二个哈希函数决定

双重散列（再散列）是开放定址法里理论最优的探测方式：既然线性探测步长为1、平方探测步长随 i² 增长，那能不能让步长本身也“散列化”——不同关键字在冲突时走不同的探测路径？这就是双重散列的核心思想：

code复制探测序列 = (hash₁(key) + i × hash₂(key)) mod m

注意这里的 hash₂(key) 是另一个独立的哈希函数，它的值作为步长。因为不同关键字的 hash₂ 结果可能不同，所以即使它们映射到同一个初始地址，后续的探测路径也可能不同，这就在很大程度上避免了“堆积”现象。

继续用上面的例子，额外定义 hash₂(key) = 1 + (key mod (m-1))，这里 m-1 = 10。插入顺序不变，表长 m = 11，hash₁(key) = key mod 11。

• 19：hash₁ = 8，hash₂ = 1 + (19 mod 10) = 10。地址8空，直接放。
• 14：hash₁ = 3，hash₂ = 1 + (14 mod 10) = 5。地址3空，直接放。
• 23：hash₁ = 1，hash₂ = 1 + (23 mod 10) = 4。地址1空，直接放。
• 1：hash₁ = 1，hash₂ = 1 + (1 mod 10) = 2。地址1冲突，i=1，探测地址(1+2) mod 11 = 3，被占；i=2，探测地址(1+4) mod 11 = 5，空，放入。探测次数3。
• 68：hash₁ = 2，hash₂ = 1 + (68 mod 10) = 9。地址2被占；i=1，探测地址(2+9) mod 11 = 0，空，放入。探测次数2。
• 20：hash₁ = 9，hash₂ = 1 + (20 mod 10) = 1。地址9空，直接放。
• 84：hash₁ = 7，hash₂ = 1 + (84 mod 10) = 5。地址7空，直接放。
• 27：hash₁ = 5，hash₂ = 1 + (27 mod 10) = 8。地址5被 1 占了吗？还没有，上一步把1放到了5号位。所以冲突；i=1，探测地址(5+8) mod 11 = 2，被68占；i=2，探测地址(5+16) mod 11 = 10，空，放入。探测次数3。

你会发现，双重散列的探测序列是跳跃且不规律的，这最大程度上避免了聚集。但从工程实现角度，双重散列需要额外计算一次哈希函数，在关键字数量不大时，这点性能开销完全可以忽略。需要注意的约束是：hash₂(key) 的结果必须与表长 m 互质（最大公约数为1），否则探测序列可能提前循环，无法遍历整个表空间。常用的做法是让 hash₂(key) 返回一个小于 m 且与 m 互质的数，或者直接把表长定义为素数。

2.4 三种方法对比速查

为了让你在考试或面试时能快速取舍，我把三种方法的核心差异整理成一张对照表：

选择建议很简单：如果题目没有特别说明用哪种探测方法，默认是线性探测；如果题目告诉你用平方探测，先检查表长是否满足 4k+3 形式的素数；如果题目给了两个哈希函数，那一定是在考双重散列。 不要看到开放定址法就直接按线性探测去算，读题时圈出探测方法比什么都重要。

3. 从填表到计算平均查找长度

3.1 查找成功和查找失败到底在算什么东西

很多人在这一步彻底绕晕了。明明表已经填完了，为什么还要分别算“查找成功”和“查找失败”？这两个概念容易混淆，其实它们的视角完全不同。

查找成功的平均查找长度（ASL_succ） 衡量的是：从表里查找一个“确定存在”的关键字，平均需要探测多少次才能找到它。具体计算方式是：把每个关键字在插入过程中实际用掉的探测次数加起来，除以关键字的个数。这个“探测次数”从某种意义上等同于“查找次数”，因为在插入时你也是从初始地址出发，逐个探测，最后落定在某个位置上的。我用线性探测那一节的例子继续说明。

表长 m = 11，关键字序列 {19, 14, 23, 1, 68, 20, 84, 27}，线性探测后的表状态为：下标[0]=空、[1]=23、[2]=1、[3]=14、[4]=68、[5]=27、[6]=空、[7]=84、[8]=19、[9]=20、[10]=空。

各关键字的查找成功探测次数如下：

• 查找19：初始地址8，槽位8存的就是19，比较1次，命中。
• 查找14：初始地址3，槽位3存的就是14，比较1次，命中。
• 查找23：初始地址1，比较1次，命中。
• 查找1：初始地址1，存的是23，不等于1，继续；地址2，存的是1，比较2次，命中。
• 查找68：初始地址2，存的是1，不等于68；地址3，存的是14；地址4，存的是68，比较3次，命中。
• 查找20：初始地址9，存的就是20，比较1次，命中。
• 查找84：初始地址7，比较1次，命中。
• 查找27：初始地址5，比较1次，命中。

所以 ASL_succ = (1+1+1+2+3+1+1+1) / 8 = 11 / 8 = 1.375。

这里有个容易被忽略的细节：计算 ASL_succ 时用的分母是成功查找的元素个数，也就是被插入的关键字总个数，而不是表长 m。 这个细节我在阅卷和批改作业时反复看到有人栽跟头——分子算对了，分母却用了11，白白丢分。

查找失败的平均查找长度（ASL_fail） 则是另一个维度：它衡量的是，从表里查找一个“确定不存在”的关键字，平均要探测多少次才能确认它不在表里。这里的终止条件是：探测到一个空槽位，就说明这个关键字肯定不在表中——因为在开放定址法中，插入过程遇到空位就会停下来，所以如果表中存在该关键字，它不可能被存放在一个空位之后。这个逻辑是理解失败查找的关键。

计算 ASL_fail 的方法：对每个可能的哈希地址（范围为0到 m-1），模拟查找一个假想中哈希到这个地址但实际不存在的关键字，统计从该地址出发到遇到第一个空槽位所需要的探测次数，然后求和，除以哈希地址的取值范围大小 m。

以上面的表状态为例，从每个地址出发：

• 地址0：槽位0本身就是空，探测1次，失败。贡献+1。
• 地址1：槽位1=23，不是要找的；槽位2=1，继续；槽位3=14；槽位4=68；槽位5=27；槽位6为空，遇到空位。共探测6次，失败。
• 地址2：槽位2=1，继续；槽位3=14；槽位4=68；槽位5=27；槽位6空。共探测5次。
• 地址3：从3出发，经过4、5，到6空。共探测4次。
• 地址4：经过4、5，到6空。共探测3次。
• 地址5：槽位5=27，继续到6空。共探测2次。
• 地址6：槽位6空。探测1次。
• 地址7：槽位7=84，继续到10号，8=19、9=20、10空。共探测4次。
• 地址8：槽位8=19、9=20、10空。共探测3次。
• 地址9：槽位9=20、10空。共探测2次。
• 地址10：槽位10本身空。探测1次。

所以失败探测总次数为 1+6+5+4+3+2+1+4+3+2+1 = 32，ASL_fail = 32 / 11 ≈ 2.91。

注意这里的计算顺序：地址7和8的探测会一路走到槽位10才遇到空位，因为中间没有空槽可停。这就是为什么开放定址法中“空槽位”如此重要——它既是插入的终点，也是查找失败的判据。如果表中已经被填满了，没有任何空槽，那么查找失败时就会陷入无限循环。因此在实际工程中，负载因子（装入因子）必须保持在一个安全范围内，通常建议不超过0.7。

3.2 边界情况：表尾回绕和无休止的争论

在计算探测序列时，取模运算保证了地址始终落在 [0, m-1] 区间内。但有些同学在算的时候容易犯一个顺序错误：他们先算 hash(key) + i*step，而不取模，得到一个大数之后再用纸笔慢慢减——这种方法在 m 较小时虽然也能得到正确结果，但一旦表长变大，出错率极高。

正确做法是先取模，把每一步的探测地址都约束在表长范围内。比如表长 m = 11，当前地址是10，线性探测下一步应该是 (10+1) mod 11 = 0，这就是“回绕”。所谓回绕，就是在视觉上从表尾跳回表头继续探测。这个行为本身不复杂，但很多人在手工模拟填表时容易忘记回绕，导致后续的关键字被错误地放到表外位置。

另外还有一个实战中很常见的争论点：题目给定 hash 函数是 H(key) = key % 13，但表长 m = 11，这时候哈希地址的范围是0到12，而表只有11个槽位。怎么处理？

通常这种题目的设计意图是：哈希函数的结果虽然是从0到12，但你在查找空位时，只能把结果对11取模后再映射到表内。但严格来说，如果题目没有明确说要对表长取模，你应当先确认表长和哈希函数取模数是否一致。如果它们不一致，是题目的坑，还是出题人有意让你先对哈希地址取模再存放？以我的经验，绝大多数教材和考试题里，表长和哈希函数的模数是一致的，但若真遇到不一致的情况，务必以“实际能用的槽位下标为0到m-1”为准——也就是 地址 = hash_result % m。

3.3 删除操作：万不能直接置空

这可以说是一个“隐藏的高频考点”，很多同学从来没想过开放定址法里的元素删除会有这么多讲究。设想你在线性探测构造的表 {23, 1, 14} 中，元素1存放在23后面。如果此时直接删除23，把槽位1置空，那么再查找1时，过程是这样的：从槽位1开始，发现是空——按照之前“遇到空位就代表查找失败”的规则，查找直接结束，返回不存在。但实际上1确实在表里！这就是直接置空带来的致命问题：它会把本来连续探测链上的后续元素“截断”，导致这些元素变得无法被查找到。

解决方案是引入“墓碑标记”，既不置空也不清数据，而是把这个槽位标记为“已删除”。在查找时遇到墓碑要继续往后探测；在插入时遇到墓碑可以直接覆盖使用。这样既不会截断探测链，又能使被删除的空间得到复用。这个操作我建议你在计算题中也要留意：如果题目给出的表状态里有“已删除”标记，那查找失败的统计方式会有所调整——遇到“已删除”标记仍然要继续探测，不能停下来算失败；而遇到真正的空位才能判定为查找失败。

4. 常见问题排查与避坑经验

4.1 题目模拟易错点汇总

在实际刷题或考试中，以下问题“命中率”最高：

4.2 如何检查你的答案是否合理

有一个很实用的直觉检验法：ASL_succ 不应该大于 ASL_fail。 因为成功查找最多只需要沿着插入路径走一遍就能找到元素，而失败查找需要一直探测到某个空槽位才能停下来，通常探测距离会更长。当然极端情况下（比如表很空、关键字很少）两者会比较接近，但 ASL_succ 大于 ASL_fail 的情况几乎不可能出现在正常构造的表中。如果算出来的结果反了，先回头检查是不是分母用错了。

另一个检验思路是：累加所有关键字的探测次数时，可以反推一下表的状态是否自洽。比如你用线性探测插入一组数据后，每个元素都能在对应位置被“反向查找”到，且查找路径不会越过一个空位——这是判断表状态合法性的一个重要标准。

4.3 考场和时间窗口下的策略

在线评测系统里，这道题通常会给一个时限。如果你在准备考研笔试或面试，我给你一个明确的策略：先手算模拟一遍，再写代码验证答案。 手算时的表结构一定要画出来，不能只在脑子里推演——特别是关键字超过5个时，脑内模拟几乎必然出错。画一个横向的数组，下标写上面，填入的关键字写下面，然后每插入一个元素就更新一次表，同时在草稿纸上记录这次插入的探测次数。整组数据插入完毕后，这些记录就是你计算 ASL_succ 的分子。

计算 ASL_fail 时换一种思路：不要试图枚举“所有不存在的关键字”，因为你无法枚举无穷多个。改为枚举所有可能的起始下标（0到m-1），从每一个起始下标出发，按探测规则向后走，记录遇到第一个空位需要的探测次数。这种“从槽位出发”的眼光，比“从关键字出发”要清晰得多，也是我教学生时最强调的技巧切换点。

5. 工程视角：理论之外的实测体会

5.1 负载因子的临界值并不是拍脑袋定的

做理论题时，我们很少会思考“为什么表长要取一个素数”这类问题。但在实际工程中，开放定址法的表现和负载因子（α = 已存元素数 / 表长）强相关。线性探测在 α 接近0.7时，平均探测次数会急剧上升；平方探测略好一些，但也不建议超过0.7；双重散列虽然抗堆积能力强，但当 α 超过0.8后，无论哪种开放定址法，性能都会劣化到接近线性扫描。

我曾经在一个内部工具里用开放定址法实现过一套键值缓存，初始表长为1024，存储约600个键时一切正常。某天数据量突增到900多个键，性能肉眼可见地下降——一次查询的探测次数从平均1.2次飙升到近5次。后来我加了一个触发条件：当已用槽位数超过总槽位数的70%时，自动扩容为原来的两倍并重新散列所有旧键。 这一改，性能问题立刻消失。

5.2 常见哈希函数选型的取舍

开放定址法虽然关注的是冲突后的探测策略，但哈希函数本身的质量同样重要。如果哈希函数质量差，关键字集中映射到某几个地址，再好的探测策略也扛不住。实际工程中最常用的哈希函数是 MurmurHash 或 xxHash 这类非加密哈希；在教科书和考试场景里则常用 key % m 这种取模哈希。取模哈希的唯一要求是 m 最好是素数，这样可以减少分布不均匀的概率——尤其当关键字本身存在某种间隔规律时（比如都是偶数），如果 m 也是偶数，那么哈希结果就只会落在偶数地址上，一半的槽位被浪费。

5.3 一个小代码模板：开放定址法如何落地

最后给你一段可以直接使用的代码思路，用 Python 写一个最小的线性探测哈希表骨架。这段代码不追求性能极致，但能帮你快速验证手工计算题目的答案，也能作为面试手写代码的底稿。

python复制class LinearProbingHashTable:
    def __init__(self, capacity=11):
        self.capacity = capacity   # 表长
        self.table = [None] * capacity
        self.DELETED = object()    # 墓碑标记
        self.size = 0

    def _hash(self, key):
        return key % self.capacity

    def insert(self, key):
        idx = self._hash(key)
        probes = 1
        while self.table[idx] is not None and self.table[idx] is not self.DELETED and self.table[idx] != key:
            idx = (idx + 1) % self.capacity
            probes += 1
        if self.table[idx] is None or self.table[idx] is self.DELETED:
            self.table[idx] = key
            self.size += 1
        return probes   # 返回本次插入的探测次数

    def search(self, key):
        idx = self._hash(key)
        probes = 1
        while self.table[idx] is not None:
            if self.table[idx] is not self.DELETED and self.table[idx] == key:
                return idx, probes
            idx = (idx + 1) % self.capacity
            probes += 1
        return -1, probes   # 已探测到一个空位，确认不存在

    def delete(self, key):
        idx, _ = self.search(key)
        if idx == -1:
            return False
        self.table[idx] = self.DELETED
        self.size -= 1
        return True

这段代码最值得留意的地方是 DELETED 对象的存在。如果不引入标记而直接置 None，前面说的“截断探测链”问题就会在代码里真实发生。你可以自己试着把 delete 改成直接置空，再插入几个同样哈希到附近的关键字，然后查找最初插入的那个元素，大概率会返回“不存在”。

我在实际使用中还有一个经验：对于规模超过10万条的数据，优先选择链地址法而不是开放定址法。 开放定址法在工程上的优势是内存连续性更好、无指针开销、对缓存友好；但当数据量变大、扩容频繁时，链地址法的实现和维护成本更低。想要用开放定址法拿稳这20分，关键是把基础原理吃透，然后通过上面代码模板里的 insert 返回值自行验证手工计算只要练熟这个闭环，考试里遇到的任何“开放定址法”变体都只是换个探测步长、换个哈希函数而已，骨架没变。