C++语言原理与实践(二十三):哈希表的实现

本篇目标:

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"
"张三"

这些字符串不能直接作为数组下标,也不能直接套用后面针对整数设计的计算方法。

因此,需要先规定一个转换规则:

让字符、字符串等类型的关键字,先得到一个整数,再利用这个整数计算存储位置。

转换的具体算法,在后面的代码实现中再展开。这里先理解两个不同的任务:

  1. 将关键字转换为便于计算的整数。
  2. 利用这个整数,计算合法的数组下标。

因此,后面讲哈希函数公式时,里面的 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 的链表中。

原图采用的是头插法,也就是把新节点插入链表最前面:

  1. 插入 19:桶 8 的头指针指向 19。
  2. 插入 30:让 30 指向原来的 19,再让头指针指向 30。
  3. 插入 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++;

找到位置后,依次完成三件事:

  1. 把整个键值对 kv 存入该槽位。
  2. 将槽位状态改成 EXIST,表示这里已经存放有效数据。
  3. 将有效元素数量 _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;
}

然后我们的扩容逻辑也比较简单,

  1. 创建更大的新表 :从质数表中选择下一个容量,创建 newht。
  2. 重新插入有效数据 :遍历旧表,把状态为 EXIST 的数据插入新表。表长变了,需要重新计算存放位置。
  3. 交换数组 :通过 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;

这几句按顺序做了四件事:

  • 保存旧链表的下一个节点。

    cpp 复制代码
    Node* next = cur->_next;

    后面要修改 cur->_next,所以必须先保存旧链表的后续位置。

  • 按照新桶数,重新计算当前节点所属的桶。

    cpp 复制代码
    size_t hashi = hs(cur->_kv.first) % newtables.size();
  • 把当前这个旧节点头插到新桶。

    cpp 复制代码
    cur->_next = newtables[hashi];
    newtables[hashi] = cur;

    节点本身没有改变,只是修改了连接关系。

  • 回到旧链表,继续处理下一个节点。

    cpp 复制代码
    cur = 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++ 实现开放定址法和链地址法哈希表。重点掌握插入、查找、删除、扩容与节点释放,理解两种存储结构的区别,为后续封装哈希容器打下基础。

相关推荐
AvocadoZeroOneOI3 小时前
B4500 [GESP202603 三级] 凯撒密码 详细解题报告
c++·算法
whitelbwwww5 小时前
cuBLAS--CUDA高性能线性代数计算库--第一部分
c++·线性代数·gpu算力·cuda c++
eggwyw8 小时前
C++设计模式之解释器模式
开发语言·c++
我不会插花弄玉21 小时前
13.多路转接epoll【由浅入深-网络】
网络·c++·epoll
郝学胜-神的一滴1 天前
Effective STL 条款03:容器中的对象复制要廉价且正确
开发语言·数据结构·c++·算法·rpc·stl
西西弗Sisyphus1 天前
C++ explicit 关键字工程实践
开发语言·c++
LK_071 天前
【力扣】142. 环形链表 II |Python
python·leetcode·链表
AIgorithmGEEK1 天前
std::unordered_map 与 std::unordered_set:接口、算法技巧与权衡 (速查)
c++·算法·哈希表·负载因子·桶·unordered_map·unordered_set
一拳一个呆瓜1 天前
【STL】头文件:<cmath>
c++·stl