本篇目标:
1.掌握哈希表实现的算法思路
2.学会哈希表的代码实现,方便后续的封装
一.哈希表的算法思路
1. 直接定址法
首先,我们先认识一下哈希概念 :哈希(hash)⼜称散列,是⼀种组织数据的方式。从译名来看,有散乱排列的意思。本质就是通过哈希函数把关键字Key跟存储位置建⽴⼀个映射关系,查找时通过这个哈希函数计算出Key存储的位置,进行快速查找。
接下来就是直接定址法的概念了。
它的出发点是:既然数组可以通过下标直接访问,能不能让关键字直接决定下标?
例如,关键字都在 [0,99],就开一个大小为 100 的数组:
cpp
int count[100] = {0};
读到数字 19,就去下标 19:
cpp
count[19]++;
查询数字 19 出现几次,也去下标 19:
cpp
count[19]
存和查都遵守同一个对应关系 :位置=关键字
如果关键字是小写字母,就把 'a' 当作起点:
index = ch - 'a';
于是 'a' 对应 0,`'b'对应1`,直到 'z' 对应 25。
算法思路就是:给每个可能的关键字预留固定位置,通过关键字直接算出这个位置。
它适合关键字范围较小、比较集中的情况。否则,可能只存几个数据,却要预留大量位置。
2. 哈希冲突
2.1.问题
直接定址法是用关键字直接确定数组位置。因此,数组需要容纳整个关键字范围,而不只是实际存入的数据。
假设关键字范围是 [0,9999],但实际只有这三个数:
cpp
1、5000、9999
按照这个范围直接定址,需要开 10000 个位置,实际却只使用 3 个,大量位置没有用到。
我们真正需要存储的只有三个数据,所以希望:根据实际数据量,开一个较小的数组。 例如开 10 个位置。
但问题来了:
- 关键字可能是
5000、`9999`。 - 数组合法下标只有
0~9。 - 它们不能再直接作为这个数组的下标。
因此,需要设计一个根据关键字计算数组下标的规则,这个规则就叫哈希函数,记作:
cpp
h(key)
存储关键字时,把它放到:
cpp
arr[h(key)]
这里先不讨论具体计算方法,只要求它算出的结果必须是合法下标:0<= h(key)<M
接着考虑另一个问题:不同关键字,会不会算出相同的位置?
可能会。以这个例子来说,关键字有 10000 种可能,而输出位置只有 10 个,不可能让所有可能的关键字都拥有互不相同的位置。
因此,存在这样的情况:key₁ ≠ key₂,但 h(key₁) = h(key₂)
两个不同的关键字映射到了同一个位置,就叫哈希冲突,也叫哈希碰撞。
所以,实现哈希表时,需要做两件事:
- 尽量设计好的哈希函数,让数据分布均匀,减少冲突。
- 为已经发生的冲突设计处理办法,让数据仍然能够正确存储和查找。
2.2. 负载因子
负载因子用来描述:这张哈希表装得有多满。
假设:
- 已经存了
N个有效元素。 - 表的大小是
M。
那么:负载因子=N/M;
容量固定为 11 时:
| 已存元素数量 N | 负载因子 | 表的拥挤程度 |
|---|---|---|
| 2 | 约 0.18 | 比较空 |
| 6 | 约 0.55 | 装了一半左右 |
| 10 | 约 0.91 | 很拥挤 |
在其他条件相近时,表越拥挤,插入和查找通常越容易受到冲突影响。
所以,实现时需要关注负载因子,在表过于拥挤前扩大容量。
它表示元素数量与容量的比例,不是"发生冲突的元素比例"。
另外,开放定址法通常会保留空位置;链地址法一个桶可以保存多个元素,负载因子可以大于 1。
2.3. 将关键字转为整数
前面用的关键字都是整数,可以直接参与位置计算。
但实际关键字也可能是:
cpp
"hello"
"张三"
这些字符串不能直接作为数组下标,也不能直接套用后面针对整数设计的计算方法。
因此,需要先规定一个转换规则:
让字符、字符串等类型的关键字,先得到一个整数,再利用这个整数计算存储位置。
转换的具体算法,在后面的代码实现中再展开。这里先理解两个不同的任务:
- 将关键字转换为便于计算的整数。
- 利用这个整数,计算合法的数组下标。
因此,后面讲哈希函数公式时,里面的 key 统一按整数理解:原本就是整数的直接参与计算,其他类型则先转换成整数。
3. 哈希函数
哈希函数负责:把关键字映射到表中的位置,并尽量让不同关键字分散开。
下面三种方法,讲的都是"位置怎么算"。
3.1 除法散列法
先考虑我们需要什么:关键字可能很大,但数组只有 M 个位置,因此需要把它转换成 0~M-1 的下标。
对于非负整数,除以 M 得到的余数,恰好就在这个范围内。因此,可以选择:
cpp
h(key) = key % M;
例如:
cpp
63 = 3 × 16 + 15
所以容量为 16 时,`63` 对应下标 15。
但是容量的选择会影响冲突,这是为什么?
因为不同的容量,会决定关键字中的哪些信息影响余数。
| 容量 M | 取余相当于保留什么 | 原文中的例子 |
|---|---|---|
16 = 2^4 |
二进制后 4 位 | 63、`31` 的后 4 位都是 1111,结果都为 15 |
100 = 10^2 |
十进制后 2 位 | 112、`12312` 的后 2 位都是 12,结果都为 12 |
以前一组为例:
cpp
63:00111111
31:00011111
虽然高位不同,但对 16 取余时,高位所代表的数都是 16 的倍数,余数只由低 4 位决定。
如果数据的低位存在重复规律,这种容量就容易让数据集中到少数位置。
因此,简单取模时,常建议选择合适的质数,减少容量与数据规律之间的关联。但质数也不能消除所有冲突。
其中,关于容量的选择,Java 使用 2 的幂,是因为它先混合哈希值的高低位,再通过位运算取得下标。以 OpenJDK 21 为例,主要过程是:
cpp
int h = key.hashCode();
int hash = h ^ (h >>> 16);
int index = hash & (M - 1);
高位信息经过混合,也能影响低位,从而改善直接截取原始低位时可能出现的分布问题。
3.2 乘法散列法
这个仅作了解即可。
这个方法换了一个思路:
先把关键字变成一个 0~1 之间的小数,再把它放大到数组下标范围。
为什么这样能够得到合法下标?
- 小数在
[0,1)。 - 乘以
M,结果就在[0,M)。 - 向下取整,就得到
0~M-1中的一个整数。
现在的问题是:怎样根据关键字得到这个小数?
乘法散列法选择:让关键字乘上常数 A,然后取乘积的小数部分。
完整过程是:
cpp
第一步:计算 key × A。
第二步:去掉整数部分,保留小数部分。
第三步:小数部分乘以 M。
第四步:向下取整,得到数组下标。
例子:
cpp
M = 1024
key = 1234
A = 0.6180339887
先乘:
cpp
1234 × 0.6180339887 = 762.6539420558
只保留小数部分:
cpp
0.6539420558
放大到数组范围:
cpp
0.6539420558 × 1024 = 669.6366651392
最后向下取整:
cpp
h(1234) = 669
公式可以写成:
cpp
h(key) = floor(M × frac(A × key))
其中,frac 表示取小数部分,floor 表示向下取整。
为什么 A 不能随便选?
假设选择 A = 0.5:
- 偶数乘
0.5,小数部分都是0。 - 奇数乘
0.5,小数部分都是0.5。
那么容量即使有 1024,结果也只会集中到下标 0 和 512,显然很差。
所以需要选择合适的 A。你材料中给出的常见选择是:
cpp
A = (√5 - 1) / 2 ≈ 0.6180339887
这个方法不要求容量 M 必须为质数,但分布效果仍与常数和数据有关。
3.3 全域散列法
这个仅作了解即可。
全域散列的思路是:
准备一族候选哈希函数,每次创建哈希表时,随机选其中一个。
可以把它理解成:每张新表都有机会采用不同的映射规则,让一批数据不容易始终针对同一个固定规则造成严重冲突。
函数族是:
cpp
h(key) = ((a × key + b) % P) % M
这里:
| 参数 | 作用或选择方式 |
|---|---|
M |
最终哈希表的大小 |
P |
中间取模使用的质数,通常应大于所考虑的整数关键字范围 |
a |
从 1~P-1 中随机选择 |
b |
从 0~P-1 中随机选择 |
为什么要有 a、b?
因为改变 a、b,就能得到不同的映射规则。它们共有 P × (P-1) 种参数组合。
a 不取 0,是因为一旦取 0,a × key + b 就只剩下 b,所有关键字都会得到相同结果。
为什么最后还要对 M 取余?
因为无论前面怎样计算,最终结果都必须回到数组的合法下标范围。
例如:
cpp
P = 17
M = 6
a = 3
b = 4
key = 8
逐步计算:
cpp
3 × 8 + 4 = 28
28 % 17 = 11
11 % 6 = 5
因此:
cpp
h(8) = 5
最后有一个关键要求:随机选择发生在建表时,选定以后就固定使用。
例如,插入 8 时,使用 a=3、b=4,把它放在下标 5。
如果查找时又随机换成 a=5、b=2:
cpp
((5 × 8 + 2) % 17) % 6
= 8 % 6
= 2
这次会去下标 2,存储位置和查找位置就不一致了。
所以,同一张表的插入、查找、删除,都必须遵守建表时选定的同一个函数。
4. 处理哈希冲突
这一部分解决的是:哈希函数算出了位置,但这个位置已经有其他数据,接下来怎么办。
4.1 线性探测
先通过哈希函数计算最初的位置:
cpp
hash0 = key % M
如果这个位置空着,直接存入;如果已经被占用,就向后逐个检查,找到空位为止。
数组只有 M 个位置,下标是 0~M-1,因此走过末尾后,需要回到下标 0 继续找。
探测公式是:
cpp
hashi = (hash0 + i) % M
这里的 i 表示相对于起点向后移动多少格:
i = 0:检查起点。i = 1:检查起点后面第一个位置。i = 2:检查起点后面第二个位置。
% M 的作用就是让超出末尾的位置回绕到数组开头 。例如表长是 11,从下标 10 再向后一步:
cpp
(10 + 1) % 11 = 0
只要表没有满,就一定存在空位。线性探测会依次经过所有位置,因此检查起点以后,最多再探测 M-1 次就能找到空位。
按顺序插入:
cpp
19、30、5、36、13、20、21、12
表长为 11,插入过程如下。探测路线中的数字都是数组下标。
| 插入的关键字 | 起点 key % 11 |
实际探测路线 | 最终存放下标 |
|---|---|---|---|
| 19 | 8 | 8,空着,存入 | 8 |
| 30 | 8 | 8 已有 19 → 9 空着 | 9 |
| 5 | 5 | 5,空着,存入 | 5 |
| 36 | 3 | 3,空着,存入 | 3 |
| 13 | 2 | 2,空着,存入 | 2 |
| 20 | 9 | 9 已有 30 → 10 空着 | 10 |
| 21 | 10 | 10 已有 20 → 回到 0,空着 | 0 |
| 12 | 1 | 1,空着,存入 | 1 |

这里要分清:30 % 11 = 8 算出来的是起点 。因为发生了冲突,30 最终存放在下标 9。
线性探测的问题是容易产生群集,也叫堆积。
例如插入 20 后,下标 8、9、10 已经连续存放了数据。之后算出的起点只要落在这段区域中,就需要向后经过这些已占用的位置,争夺后面的空位。
连续存放的数据越多,后来的关键字就可能需要检查越多的位置。
4.2 二次探测
为了减少连续向后寻找造成的堆积,可以把探测距离改成平方数,跳着寻找空位。
仍然先计算起点:
hash0 = key % M
按照你给的正负平方探测方式,这里约定顺序为:
cpp
起点、起点 + 1²、起点 - 1²、起点 + 2²、起点 - 2²......
也就是偏移:
cpp
0、+1、-1、+4、-4、+9、-9......
每次偏移,都相对于最初的 hash0 计算。
对应公式:
cpp
hashi = (hash0 ± i*i) % M
向右越过末尾,通过取余回绕;向左得到负数时,还需要处理负下标。
例如表长是 11,计算出位置 -1,它对应的就是数组末尾的下标 10。在 C++ 中,取余结果可能为负数,因此取余后若结果小于 0,再加上 M。
用你给的数据,依次插入:
cpp
19、30、52、63、11、22
| 插入的关键字 | 起点 key % 11 |
实际探测路线 | 最终存放下标 |
|---|---|---|---|
| 19 | 8 | 8 | 8 |
| 30 | 8 | 8 → 9 | 9 |
| 52 | 8 | 8 → 9 → 7 | 7 |
| 63 | 8 | 8 → 9 → 7 → 1 | 1 |
| 11 | 0 | 0 | 0 |
| 22 | 0 | 0 → 1 → 10 | 10 |

重点看 63 的插入过程。它的起点是 8:
cpp
起点:8,已有 19。
加 1²:8 + 1 = 9,已有 30。
减 1²:8 - 1 = 7,已有 52。
加 2²:8 + 4 = 12,12 % 11 = 1,空着,存入。
再看 22:
cpp
起点:0,已有 11。
加 1²:0 + 1 = 1,已有 63。
减 1²:0 - 1 = -1,回绕到下标 10,空着,存入。
这样可以分散探测的位置,缓解线性探测的连续堆积。不过,起点相同的关键字,仍会沿着相同的探测路线寻找 。例如 19、30、52、63 的起点都是 8。
另外,二次探测能否经过所有槽位,与表长和具体探测规则有关,不能仅凭"表里还有空位"就保证一定能找到。
4.3 双重散列
这个是重点!
二次探测中,起点相同的关键字会采用相同的偏移顺序。我们可以进一步考虑:
让不同的关键字,根据自身的值计算出不同的步长。
于是使用两个哈希函数:
cpp
h1(key):计算起点。
h2(key):计算每次向后移动的步长。
探测公式为:
cpp
hashi = (h1(key) + i * h2(key)) % M
对于同一个关键字,先算出步长,后续就一直使用这个固定步长。
例如步长是 3,就检查:
cpp
起点、起点 + 3、起点 + 6、起点 + 9......
这里有一个要求:
cpp
1 <= h2(key) < M
并且 h2(key) 与 M 互质。
为什么要互质? 因为我们希望按照这个步长,可以走遍整个数组。
例如有个表长为 12,起点是 1,步长是 3。
探测次数 i |
计算过程 | 检查的下标 |
|---|---|---|
| 0 | (1 + 0×3) % 12 |
1 |
| 1 | (1 + 1×3) % 12 |
4 |
| 2 | (1 + 2×3) % 12 |
7 |
| 3 | (1 + 3×3) % 12 |
10 |
| 4 | (1 + 4×3) % 12 |
1 |
走到这里又回到了起点,之后继续重复。
它只能检查下标 1、4、7、10,其他位置即使空着,也永远检查不到。
能够经过的不同位置数量为:
cpp
M / gcd(M, 步长)
这里 gcd 表示最大公约数:
cpp
12 / gcd(12, 3) = 12 / 3 = 4
所以,要求步长与表长互质,就是让最大公约数为 1,从而能够经过全部 M 个位置。
常见的选法是:
M为2的整数次幂时,选择小于M的正奇数作为步长。M为质数时,可以使用h2(key) = key % (M-1) + 1。对于非负关键字,步长范围是1~M-1,都与质数M互质。
最后,数据演示:
| 关键字 | 起点 h1(key) |
步长 h2(key) |
实际探测路线 | 最终存放下标 |
|---|---|---|---|---|
| 19 | 8 | 10 | 8,空着 | 8 |
| 30 | 8 | 1 | 8 已占用 → (8+1)%11=9 |
9 |
| 52 | 8 | 3 | 8 已占用 → (8+3)%11=0 |
0 |
| 74 | 8 | 5 | 8 已占用 → (8+5)%11=2 |
2 |

这四个关键字的起点都是 8,但发生冲突后,30、52、74 分别按照步长 1、3、5 寻找,走到了不同的位置。
4.4 链地址法
开放定址法把数据直接存放在数组中,发生冲突以后,需要按照一定规则寻找其他空位。
链地址法采用另一种思路:给数组的每个位置挂一条链表,把映射到同一个位置的数据连接起来。
此时,数组中存放的是链表的头指针:
- 没有数据映射到这个位置,头指针就是
nullptr。 - 有数据映射到这个位置,就创建链表节点,由头指针指向它。
- 多个数据映射到同一个位置,就把这些节点连接成一条链表。
这种解决冲突的方法也叫拉链法。
数据演示,按照下面的顺序插入:
cpp
19、30、5、36、13、20、21、12、24、96
桶数为 11,采用哈希函数:
cpp
h(key) = key % 11
例如:
cpp
19 % 11 = 8
30 % 11 = 8
96 % 11 = 8
三个关键字都映射到下标 8,因此都挂在桶 8 的链表中。
原图采用的是头插法,也就是把新节点插入链表最前面:
- 插入
19:桶8的头指针指向19。 - 插入
30:让30指向原来的19,再让头指针指向30。 - 插入
96:让96指向原来的30,再让头指针指向96。
所以,最终的链表顺序是 96 → 30 → 19 → nullptr。
全部插入以后,各桶的情况如下:
| 桶下标 | 映射到该桶的数据,按插入顺序列出 | 头插后的链表 |
|---|---|---|
| 1 | 12 | 12 → nullptr |
| 2 | 13、24 | 24 → 13 → nullptr |
| 3 | 36 | 36 → nullptr |
| 5 | 5 | 5 → nullptr |
| 8 | 19、30、96 | 96 → 30 → 19 → nullptr |
| 9 | 20 | 20 → nullptr |
| 10 | 21 | 21 → nullptr |
如图:

下标 0、4、6、7 没有数据,头指针保持为 nullptr。
查找时,先计算桶的位置,再沿着对应链表比较关键字。例如查找 30,先通过 30 % 11 = 8 找到桶 8,接着检查 96、30,找到后结束。如果一直走到 nullptr,就说明不存在这个关键字。
但是如果是在极端场景下,某个桶特别长怎么办?其实我们可以考虑使用全域散列法,这样就不容易被针对 了。但是假设不是被针对了,用了全域散列法,但是偶然情况下,某个桶很长,查找效率很低怎么 办?这里在Java8的HashMap中当桶的长度超过⼀定阀值(8)时就把链表转换成红黑树。⼀般情况下, 不断扩容,单个桶很长的场景还是比较少的,下面我们实现就不搞这么复杂了,这个解决极端场景的思路,大家了解⼀下。
二.代码实现
1.开发定址法
1.1.框架
cpp
namespace open_addrese
{
using namespace std;
enum State
{
EXIST,
EMPTY,
DELETE
};
template<class K, class V>
struct HashData
{
pair<K, V> _kv;
State _state = EMPTY;
};
template<class K, class V>
class HashTable
{
HashTable(size_t n = 11)
:_tables(n),
_n(0)
{ }
private:
vector<HashData<K, V>> _tables;
size_t _n = 0; // 表中存储数据个数
};
解释**State**
作用:记录每个位置的状态
| 状态 | 含义 | 查找时如何处理 |
|---|---|---|
EXIST |
当前有有效数据 | 比较键是否相等,相等就找到了 |
EMPTY |
尚未存放过数据 | 可以结束查找,说明目标不存在 |
DELETE |
曾经有数据,后来删除了 | 继续向后探测 |
为什么删除后不能直接设置成 EMPTY?
假设数组长度为 5,使用线性探测:
hash(key) = key % 5;
依次插入键 1 和 6:
1 % 5 = 1,将1放在下标1。6 % 5 = 1,下标1已经被占用,将6放在下标2。
此时:
| 下标 | 存储的键 | 状态 |
|---|---|---|
| 0 | --- | EMPTY |
| 1 | 1 | EXIST |
| 2 | 6 | EXIST |
| 3 | --- | EMPTY |
| 4 | --- | EMPTY |
现在删除 1。
如果把下标 1 标记为 EMPTY,之后查找 6 时:
6 % 5 = 1;
查找从下标 1 开始,一看到 EMPTY 就停止了,于是错误地认为 6 不存在。
所以要标记为 DELETE,表示这里的数据虽然删除了,但后面可能还有因冲突而存放的数据,查找必须继续。
1.2.insert接口
我们需要先用 Find 判断关键字是否已经存在
cpp
if (Find(kv.first))
{
return false;
}
接下来跳过扩容部分,直接看插入过程。
我们要计算起始位置:
cpp
size_t hash0 = kv.first % _tables.size();
size_t hashi = hash0;
_tables.size() 是哈希表的槽位数量。
通过关键字取余,计算出最开始应该检查的位置,保存在 hash0 中。
两个变量的作用分别是:
hash0:最初计算出的位置,后续保持不变。hashi:当前正在检查的位置,发生冲突后会改变。
一开始先检查起点,因此让:
cpp
hashi = hash0;
计算发生冲突后的探测步长:
size_t hash2 = kv.first % (_tables.size() - 1) + 1;
int i = 1;
这里采用的是前面讲过的双重散列。
第一个哈希计算起点,第二个哈希计算步长:
起点 = key % M
步长 = key % (M - 1) + 1
然后我们就寻找空位置,进行插入:
cpp
while (_tables[hashi]._state == EXIST)
{
hashi = (hash0 + i*hash2) % _tables.size();
i++;
}
先检查当前槽位的状态:
EXIST:存放着有效数据,不能覆盖,继续寻找。EMPTY:空槽位,可以插入。DELETE:原来的数据已经删除,这个位置可以复用。
因此,循环条件只判断是否为 EXIST。遇到 EMPTY 或 DELETE,循环就结束。
发生冲突后,按照下面的方式寻找位置:
cpp
第一次冲突:检查 (hash0 + 1 × hash2) % M
再次冲突: 检查 (hash0 + 2 × hash2) % M
再次冲突: 检查 (hash0 + 3 × hash2) % M
......
每次都以最初的 hash0 为基准,偏移量随着 i 增大。
循环结束后,hashi 就保存着本次找到的可用位置。
这里也能看出开头先 Find 的作用:确认关键字不存在以后,后面的循环只需要寻找可用槽位。 即使先遇到了 DELETE,也可以直接使用,不必担心相同关键字还存在于后面的探测位置中。
之后存入键值对,修改状态和元素数量:
cpp
_tables[hashi]._kv = kv;
_tables[hashi]._state = EXIST;
_n++;
找到位置后,依次完成三件事:
- 把整个键值对
kv存入该槽位。 - 将槽位状态改成
EXIST,表示这里已经存放有效数据。 - 将有效元素数量
_n加一。
最后:
cpp
return true;
表示本次插入成功。
1.3.Find接口
这个接口我们仅需在之前的insert查找空位置的代码修改一下即可,如下:
cpp
HashData<K, V>* Find(const K& key)
{
size_t hash0 = key % _tables.size();
size_t hashi = hash0;
size_t hash2 = key % (_tables.size() - 1) + 1;
int i = 1;
while (_tables[hashi]._state == EXIST)
{
if (_tables[hashi]._kv.first == key)
{
return &_tables[hashi];
}
hashi = (hash0 + i*hash2) % _tables.size();
i++;
}
return nullptr;
}
1.4.erase接口
关于删除,我们可以先用Find查找这个key是否存在,存在就将其状态变为DELETE,不存在就返回false,代码如下:
cpp
bool Erase(const K& key)
{
auto ret = Find(key);
if (ret == nullptr)
{
return false;
}
else
{
ret->_state = DELETE;
_n--;
return true;
}
}
1.5.扩容问题
扩容时,我们需要关注负载因子的变化,所以我们哈希表负载因⼦控制在0.7 ,当负载因子到0.7以后我们就需要扩容了,我们还是按照2倍扩 容,但是同时我们要保持哈希表大小是⼀个质数,第⼀个是质数,2倍后就不是质数了。那么如何解决 了,⼀种方案就是上面1.4.1除法散列中我们讲的JavaHashMap的使⽤2的整数幂,但是计算时不能直 接取模的改进⽅法。另外⼀种方案是sgi版本的哈希表使用的方法,给了⼀个近似2倍的质数表,每次去质数表获取扩容后的大小,这里我们用方案二,代码如下:
cpp
inline static unsigned long __stl_next_prime(unsigned long n)
{
// Note: assumes long is at least 32 bits.
static const int __stl_num_primes = 28;
static const unsigned long __stl_prime_list[__stl_num_primes] =
{ 53, 97, 193, 389, 769,
1543, 3079, 6151, 12289, 24593,
49157, 98317, 196613, 393241, 786433,
1572869, 3145739, 6291469, 12582917, 25165843,
50331653, 100663319, 201326611, 402653189, 805306457,
1610612741, 3221225473, 4294967291
};
const unsigned long* first = __stl_prime_list;
const unsigned long* last = __stl_prime_list + __stl_num_primes;
const unsigned long* pos = std::lower_bound(first, last, n);
return pos == last ? *(last - 1) : *pos;
}
然后我们的扩容逻辑也比较简单,
- 创建更大的新表 :从质数表中选择下一个容量,创建
newht。 - 重新插入有效数据 :遍历旧表,把状态为
EXIST的数据插入新表。表长变了,需要重新计算存放位置。 - 交换数组 :通过
swap让当前对象使用新数组,newht 接管旧数组。离开作用域后,newht 析构,自动释放旧数组。
扩容只改变容量,有效元素数量没变,所以当前对象的 _n 不需要修改。
cpp
if ((double)_n / _tables.size() >= 0.7)
{
HashTable<K, V> newht(__stl_next_prime(_tables.size() + 1));
for (size_t i = 0; i < _tables.size(); i++)
{
if (_tables[i]._state == EXIST)
{
newht.Insert(_tables[i]._kv);
}
}
_tables.swap(newht._tables);
}
然后,为了保持我们的哈希表的大小始终为一个质数,我们也需要将构造函数改一下:
cpp
HashTable(size_t n = 53)
:_tables(__stl_next_prime(n)),
_n(0)
{ }
2.链地址法
2.1.框架
cpp
namespace link_address
{
template<class K,class V>
struct HashNode
{
std::pair<K, V> _kv;
HashNode<K, V>* _next;
HashNode(const std::pair<K, V>& kv)
:_kv(kv),
_next(nullptr)
{
}
};
template<class K,class V,class Hash=HashFunc<K>>
class HashTable
{
typedef HashNode<K, V> Node;
public:
HashTable(size_t n = 53)
:_tables(__stl_next_prime(n)),
_n(0)
{ }
private:
std::vector<Node*> _tables;
size_t _n;
};
}
HashNode:链表节点。_kv保存键值对,_next 指向下一个节点。构造时保存传入的数据,并将_next初始化为nullptr。
2.2.insert接口
先查找关键字是否已经存在
cpp
if (Find(kv.first))
{
return false;
}
这个哈希表不允许关键字重复,所以先查找 kv.first。
如果已经存在,就直接返回 false;不存在,才继续插入。
计算所属桶的下标
cpp
size_t hashi = hs(kv.first) % _tables.size();
这行先理解为:根据关键字计算出它所属的桶,下标保存在 hashi 中。
接下来,新节点就挂到这个桶的链表中。
然后创建新节点
cpp
Node* cur = new Node(kv);
创建一个节点,将传入的键值对 kv 保存到节点的 _kv 中,节点的 _next 初始化为 nullptr。
此时节点已经创建,但还没有接入链表。
之后将新节点头插到对应桶中
cpp
cur->_next = _tables[hashi];
_tables[hashi] = cur;
这两句的顺序是:先接住原链表,再修改桶的头指针。
例如,桶 8 中原来是:30 → 19 → nullptr
现在插入同样映射到桶 8 的 96:
cur->_next = _tables[hashi];:让新节点96指向原来的头节点30。_tables[hashi] = cur;:让桶8的头指针改为指向新节点96。
最终得到:96 → 30 → 19 → nullptr
如果桶原来为空,头指针就是 nullptr,执行相同的两句代码,也能得到:96 → nullptr
最后更新元素数量,返回成功
_n++;
return true;
成功插入一个节点,有效元素总数 _n 加一,返回 true 表示插入成功。
2.3.Find接口
Find接口其实也很简单,我们明白了insert的操作,就可以直接写出,代码如下:
cpp
Node* Find(const K& key)
{
Hash hs;
size_t hashi = hs(key) % _tables.size();
Node* cur = _tables[hashi];
while (cur)
{
if (cur->_kv.first == key)
{
return cur;
}
cur = cur->_next;
}
return nullptr;
}
2.4.erase接口
我们先找到对应的桶
cpp
size_t hashi = hs(key) % _tables.size();
根据 key 计算桶下标,后面只需要在这个桶的链表中查找。
然后用两个指针遍历链表
cpp
Node* prev = nullptr;
Node* cur = _tables[hashi];
cur:当前正在检查的节点,开始时指向头节点。prev:`cur` 的前一个节点,用于删除时重新连接链表。
头节点前面没有节点,所以开始时 prev 为 nullptr。
之后找到关键字,调整链表连接
cpp
if (cur->_kv.first == key)
找到以后,需要区分头节点和其他节点。
以原链表 96 → 30 → 19 → nullptr 分别说明。
删除头节点,例如删除 96:
cpp
if (prev == nullptr)
{
_tables[hashi] = cur->_next;
}
此时 prev 为空,说明 cur 就是头节点。
让桶的头指针指向 cur 的下一个节点 30,链表变成:
30 → 19 → nullptr
删除非头节点,例如删除 30:
cpp
else
{
prev->_next = cur->_next;
}
此时 prev 指向 96,`cur` 指向 30。
让 96 直接指向 30 后面的 19,跳过待删除节点,链表变成:
96 → 19 → nullptr
删除尾节点也适用这一句,因为尾节点的 _next 就是 nullptr。
然后释放节点,更新数量
delete cur;
_n--;
return true;
前面只是把节点从链表中断开,这里才真正释放节点空间。
然后有效元素数量减一,返回 true,表示删除成功。
如果当前节点不匹配,就继续向后找
prev = cur;
cur = cur->_next;
先让 prev 记录当前节点,再让 cur 移动到下一个节点,使两个指针始终保持前后关系。
如果一直走到 cur == nullptr,说明整条链表中都没有这个关键字,最后:
return false;
表示没有找到,删除失败。
2.4.扩容问题
开放定址法负载因子必须小于1,链地址法的负载因子就没有限制了,可以等于1。负载因子越大,哈希冲突的概率越高,空间利用率越高;负载因子越小,哈希冲突的概率越低,空间利用率越低;stl中 unordered_xxx的最大负载因子基本控制在1,等于1就扩容,我们下⾯实现也使用这个方式。
我们有以下的两种方法:
2.4.1.方法一
① 创建更大的新表
cpp
HashTable<K, V> newHT;
newHT._tables.resize(__stl_next_prime(_tables.size() + 1));
先创建一个空哈希表,再从质数表中选择新的容量,调整它的桶数组大小。此时新表中还没有链表节点。
② 遍历旧表中的所有节点
cpp
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
newHT.Insert(cur->_kv);
cur = cur->_next;
}
}
外层循环遍历每个桶,内层循环遍历这个桶中的链表。
每找到一个旧节点,就取出它的 _kv,调用新表的 Insert。
这里的 Insert 会按照新表的桶数计算位置,然后执行之前写过的节点创建和头插:
cpp
Node* cur = new Node(kv);
cur->_next = _tables[hashi];
_tables[hashi] = cur;
_n++;
由于这是通过 newHT.Insert 调用的,这里的 _tables 和 _n 都属于 newHT。
所以,新表会另外创建一个节点,保存旧节点的数据。旧节点和旧链表都没有被修改,可以继续通过 cur = cur->_next 向后遍历。
③ 交换新旧桶数组
cpp
_tables.swap(newHT._tables);
交换以后:
- 当前对象使用新的大数组,其中挂着重新创建的节点。
newHT接管旧数组,其中仍然挂着旧节点。
离开 if 代码块后,newHT 析构,旧节点应由 HashTable 的析构函数逐个释放,旧桶数组也随之释放。这里需要已经实现链表节点的清理,`vector<Node*>` 自身不会替你 delete 节点。
但是这个方法是会创建新的节点的,我们可以直接拿之前的旧节点放到新表中。
2.4.2.方法二
先创建更大的桶数组:
cpp
vector<Node*> newtables(__stl_next_prime(_tables.size()+1), nullptr);
这里只创建桶数组,所有头指针初始化为空,没有创建新的链表节点。
然后逐个搬动旧节点:
cpp
Node* next = cur->_next;
size_t hashi = hs(cur->_kv.first) % newtables.size();
cur->_next = newtables[hashi];
newtables[hashi] = cur;
cur = next;
这几句按顺序做了四件事:
-
保存旧链表的下一个节点。
cppNode* next = cur->_next;后面要修改
cur->_next,所以必须先保存旧链表的后续位置。 -
按照新桶数,重新计算当前节点所属的桶。
cppsize_t hashi = hs(cur->_kv.first) % newtables.size(); -
把当前这个旧节点头插到新桶。
cppcur->_next = newtables[hashi]; newtables[hashi] = cur;节点本身没有改变,只是修改了连接关系。
-
回到旧链表,继续处理下一个节点。
cppcur = next;必须沿着之前保存的
next继续走,因为cur->_next已经接到新表中了。
一个旧桶搬完以后:
cpp
_tables[i] = nullptr;
清空这个旧桶的头指针,表示它的节点已经全部搬走。
最后:
cpp
_tables.swap(newtables);
当前哈希表接管新桶数组,`newtables` 接管已经清空的旧桶数组。离开作用域时,只需要释放旧桶数组,节点继续由新表使用。
| 对比项 | 第一种 | 第二种 |
|---|---|---|
| 创建新节点 | 需要 | 不需要 |
| 复制键值对 | 需要 | 不需要 |
| 旧节点的处理 | 搬完数据后释放 | 继续使用 |
| 重新计算所属桶 | 需要 | 需要 |
两种方式扩容后,有效元素数量都没有变化,因此当前哈希表的 _n 不需要修改。
2.5.析构函数
cpp
~HashTable()
{
for (size_t i = 0; i < _tables.size(); i++)
{
if (_tables[i])
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
}
_tables[i] = nullptr;
}
}
解释:
首先遍历每个桶,空桶直接跳过。
然后cur 指向当前桶的头节点,逐个删除:
cpp
Node* next = cur->_next; // 先保存下一个节点
delete cur; // 释放当前节点
cur = next; // 继续处理下一个节点
必须先保存 next,因为删除 cur 后,就不能再访问它的 _next。
当前桶的节点全部删除后,将头指针置为 nullptr。
析构函数执行结束后,成员 _tables 会自动析构,释放桶数组本身占用的空间。
总结:
本文介绍哈希映射、负载因子及常见的冲突处理方法,并用 C++ 实现开放定址法和链地址法哈希表。重点掌握插入、查找、删除、扩容与节点释放,理解两种存储结构的区别,为后续封装哈希容器打下基础。