文章目录

前言
1. 哈希的概念
2. 哈希冲突
3. 哈希函数
- 3.1 直接定址法
- 3.2 除留余数法--(常用)
- 3.3 平方取中法--(了解)
- 3.4 折叠法--(了解)
- 3.5 随机数法--(了解)
- 3.6 数学分析法--(了解)
4. 哈希冲突的解决方法及不同方法对应的哈希表实现
- 4.1 闭散列（开放定址法）
- - 线性探测
  - 二次探测（平方探测法）
- 4.2 闭散列哈希表实现
- - 闭散列的插入
  - 闭散列的删除
  - 伪删除法
  - 结构定义
  - 插入函数insert实现
  - 载荷因子/负载因子
  - 扩容
  - Insert测试
  - 查找函数Find实现
  - 删除函数Erase实现
  - Find、Erase测试
  - bug解决
- 4.3 开散列（拉链法）
- 4.4 开散列哈希表实现
- - 结构定义
  - 析构
  - 插入函数insert实现
  - 扩容
  - 扩容优化
  - insert和扩容测试
  - 查找函数Find实现
  - 删除函数Erase实现
  - Find、Erase测试
5. 思考：存储整型之外的其它类型元素
6. 字符串哈希
7. 哈希表性能测试分析
8. 除留余数法最好模一个素数
9. 源码
- 9.1 HashTable.h
- 9.2 Test.cpp

前言

上一篇文章我们学习了STL中unordered系列容器的使用，并且提到，unordered系列容器的效率之所以比较高（尤其是查找），是因为它底层使用了哈希结构，即哈希表。

那这篇文章，我们就来学习一下哈希表

1. 哈希的概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即
O( $log_2 N$ )，搜索的效率取决于搜索过程中元素的比较次数

理想的搜索方法：

可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(一般称为哈希函数hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素

当向该结构中：

插入元素

根据待插入元素的关键码，以此函数（即上面提到的哈希函数）计算出该元素的存储位置并按此位置进行存放

搜索元素

对元素的关键码进行同样的函数计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

举个栗子：

待插入数据集合{1，7，6，4，5，9}
哈希函数设置为：hash(key) = key % capacity（ capacity为存储元素底层空间总的大小）
假设表的capacity为10，那插入之后就是这样的

那查找的时候我们直接通过函数获取下标位置查找即可
用该方法进行搜索不必进行多次关键码的比较，元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素，因此搜索的速度比较快

但是，按照上述哈希方式，向集合中插入元素44，会出现什么问题？

44%10结果也是4，但是之前4这个元素已经存在下标为4的位置了！

那这种现象我们把它叫做哈希冲突。

2. 哈希冲突

对于两个数据元素的关键字 $k_i$ 和 $k_j$ (i != j)，有 $k_i$ != $k_j$ ，但有：Hash( $k_i$ ) == Hash( $k_j$ )，即：

不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

那引起哈希冲突的一个原因可能是：

哈希函数设计不够合理

那下面我们来介绍一下哈希函数。

3. 哈希函数

哈希函数（Hash Function）在哈希表中起着关键的作用。它接收键作为输入，并计算出一个索引或哈希码，用于确定键在哈希表中的位置。

哈希函数设计原则：

哈希函数的定义域必须包括需要存储的全部关键码，如果散列表允许有m个地址时，其值域必须在0到m-1之间
哈希函数计算出来的地址能均匀分布在整个空间中
哈希函数应该比较简单

那常见的哈希函数都有哪些呢？

3.1 直接定址法

第一种哈希函数——直接定址法：

取关键字的某个线性函数为散列地址（通常是键值直接映射）：Hash（Key）= A*Key + B
优点：简单高效
缺点：适用场景有限
使用场景：适合于键值比较均匀、分布比较集中的情况

我们之前文章里讲过一道题：

就这个，这道题其实就用了哈希的思想

我们来复习一下。

当时讲的思路是这样的：

字符串中字符的范围就是【a,z】，那我们就可以创建一个大小为26的整型数组，然后用一个相对映射去统计每个字母的出现次数，a就映射到下标为0的位置，b就映射到下标为1的位置，依次类推。
那怎么让这些字母映射到对应的位置呢？
减去’a’得到的值是不是就是它们映射的位置啊，然后遍历字符串，每个字母映射的值是几，就让下标为几的元素++，初值全为0，这样遍历过后每个字母出现的次数就统计出来了。（下标0的元素的值就是a出现的次数，1位置就是b出现的次数…）
但是现在有一个问题，那就是出现一次的字母可能不止一个，我们怎么判断那个是第一个只出现一次的字母呢？
🆗，这里我们不要去遍历统计次数的数组，还是从前往后去遍历字符串，然后看哪个字母的次数是1，第一个是1的就是第一个只出现一次的字母。

这是我们当时写的代码。
大家看这不就是运用了哈希的思想嘛——使元素的存储位置与它的关键码之间能够建立一一映射的关系。
这里用的哈希函数就是一种直接定址法嘛，哈希函数就是key-'a'

当然现在我们学了unordered系列的容器就可以这样写了：

统计次数用unorder_map就行了。

但是，我们上面提到，直接定址法只适用于键值比较均匀、分布比较集中的情况：

比如这种情况

如果我们选择用键值直接映射（直接定址法：Hash（Key）=key），当前这几个值的话开这10个空间就够了，但是如果是这样一组值呢？
4，5，12，33，55，1555，2333
难道我们要开2333个空间吗？
可以是可以的，但是不就太浪费了嘛。

所以呢，出来直接定址法，还提供了一些其它的哈希函数

3.2 除留余数法–(常用)

什么是除留余数法呢？
其实最开始给大家介绍的那个例子里面的哈希函数就是除留余数法。

除留余数法的概念：

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m)，将关键码转换成哈希地址

举个例子：

比如有这样一组值：1 2 5 1333 2447
如果用直接定址法的话，搞一个绝对映射，那就需要开好多个空间。
但是如果用除留余数法的话，那我们可以只开10个空间，p取10
那存储结果就是这样的

这样虽然key值得分布很不均匀，但是我们也能耗费比较小的空间把他们存起来。

但是，有没有什么问题呢？

如果我再加几个值，比如122，255，347，12

这是是不是会出现一个问题，就是我们上面提到的哈希冲突/哈希碰撞

那问题来了，对于哈希冲突，我们如何解决呢？

哈希冲突的解决是我们下面要重点讲解的一个问题。
不过，在讲解之前，还有几个哈希函数需要我们了解一下，下面几个不常用，所以我们了解即可

3.3 平方取中法–(了解)

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址
平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

3.4 折叠法–(了解)

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址（因为散列低地址不能超过表长）。
折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

3.5 随机数法–(了解)

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key)，其中random为随机数函数。
通常应用于关键字长度不等时采用此法

3.6 数学分析法–(了解)

举个例子供大家了解一下：

有学生的生日数据如下：
年.月.日
75.10.03
75.11.23
76.03.02
76.07.12
75.04.21
76.02.15
…
经分析，第一位，第二位，第三位重复的可能性大，取这三位造成冲突的机会增加，所以尽量不取前三位，取后三位比较好。

注意：

哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。

所以接下来我们就来讲一下如何处理哈希冲突。

4. 哈希冲突的解决方法及不同方法对应的哈希表实现

解决哈希冲突两种常见的方法是：闭散列和开散列

4.1 闭散列（开放定址法）

闭散列：

也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。

那如何寻找下一个空位置呢？

线性探测

线性探测：

从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止，将新插入的值放到该空位置。
即 $H_i$ = ( $H_0$ + $i$ )% m，i=1,2,3,4…
$H_0$ 是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小， $H_i$ 是向后探测的位置
为什么加完i还要模m呢，因为一直加的话可能会超过表长，这时就要回到开头往后进行探测了

比如上面我们举例的那种情况：

现在我要插入122，那根据哈希函数122%10定位到下标为2的位置，但是这个位置已经被占用了，怎么办？
向后进行线性探测，找下一个空位置，所以122就会放到下标4这个位置

那后续的插入如果发生冲突也是如此
当然如果插入满了的话肯定要涉及到扩容的问题，这个我们后面会说。

那大家觉得线性探测这样搞好不好啊，我们来简单分析一下：

线性探测优点：实现非常简单，
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”（我向后探测放到后面的空位置就占用了别的位置，其它key定位到这个位置也需要再向后探测），即：冲突值占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较（从冲突位置可能要向后查找多次），导致搜索效率降低。
可以认为闭散列本质是就是一种零和游戏

那如何缓解呢？

二次探测（平方探测法）

二次探测的产生呢能够在一定程度上缓解上面的问题：

二次探测找下一个空位置的方法为：
$H_i$ = ( $H_0$ + $i^2$ )% m 或者： $H_i$ = ( $H_0$ - $i^2$ )% m
其中：i = 1,2,3…， $H_0$ 是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小， $H_i$ 是向后探测的位置

那我们看到：

二次探测它在向后探测的过程中使用了二次增量（第一次冲突+ $1^2$ ，第二次+ $2^2$ ，第三次+ $3^2$ …），而不是线性增量，这样在寻找下一个可用槽位时，可以跳过一些位置，从而减少关键字在哈希表中的聚集程度，提高散列效果。

4.2 闭散列哈希表实现

闭散列的插入

那我们接下来一起来探讨一下，以闭散列线性探测的方式处理哈希冲突（哈希函数我们以除留余数法为例），具体如何进行插入删除，并带大家实现一下相关的代码

我们先来分析一下插入：

那思路是很清晰的，也比较简单：

首先通过哈希函数获取待插入元素在哈希表中的位置
然后如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

这里前面几个值插入都没有冲突，直接根据哈希函数获得的位置插入即可，44插入发生冲突，进行线性探测，探测到下一个空位置8进行插入。

闭散列的删除

然后我们分析一下删除：

大家想一下要删除一个值的时候怎么做？

比如这样的场景：

我们能看出来现在是存在一些冲突的。
假设我们现在要删除33，怎么做？
那首先我们还是根据哈希函数确定它的映射，33%10结果是3，但是3这个位置现在不是存的33，那这能证明33不存在吗？
不能，因为他有可能发生了冲突在后面存着呢，所以如果第一次没找到的话就要线性探测继续往后找（找到这个过程和你如何存是对应着的），那这里我们往后一个位置就找到了。

那找到了，如何删除呢？

把后面的值移动覆盖吗？
那这样效率就太低了。
那做一个标识吗？
比如删除一个值之后把它置成0或者-1表示这个位置为空（那最开始可以把所有位置初始化成0或-1表示全空）。
好像也不好，如果你要存的就是0或-1呢。

另外如果这样处理的话，会影响到查找。

大家想一下查找一个值的话什么时候结束？
其实分为两种情况，如果不冲突的话，其实一下直接就找到了，因为不冲突的话他就直接存到哈希函数确定的那个映射位置了。
如果冲突的话，就往后探测嘛，我们这里是线性探测，那就继续往后找，那往后找的话找到了好说，找不到的话，什么时候结束呢？
走到哈希表结尾吗？
那这样如果表比较长就太慢了，效率太低了。当然其实也不需要走到表尾。
大家看

比如这种情况，我们现在查找13
那首先定位到下标3这个位置，但是不是，所以要往后探测，一直走到5这个空位置，还是没有找到，大家想，还有必要往后查找吗？
我们查找的时候是按照对应的探测方法去查找的，所以我们往后查找的值一定是对应位置的冲突值，如果走到一个探测位置为空了，那就说明从这个位置开始以及后面都没有其它冲突值了，后面即使还有值它们对应的散列地址都跟你查找的这个不是一个值了，所以也没必要再往后查找了。
就我们当前这个情况，查找13的散列地址是3，但是那个空位置后面其它非空值的散列地址都不是3了。

那我们再过回来，上面那样删除如何就影响查找了呢？

回到上面删除的场景——删除33

删除之后是这样的
那然后我想查找13，大家看，现在能查找到吗？
按照我们上面的分析，正常查找到空就结束了，现在查找13的话散列地址是3，从下标3的位置开始，走到空并没有找到，因为要查找的13在空位置的后面。
但是这里13是真的不存在吗，我们看到并不是。

所以上面的删除方法是不行的，那如何搞呢？

🆗，我们这里采用标记的伪删除法删除一个元素

伪删除法

那具体怎么做呢？

我们给每个位置增加一个状态：

状态有三种取值——空、存在、删除
空不用解释，存在就是当前这个位置有值，删除就是这个位置存过值，但是现在被删除了。
这样我们进行相应的操作之后去该这个状态就行了（当然初始状态就应该全为空）

结构定义

那接下来我们就来实现一下代码，这里我们以KV模型为例

首先我们定义一下大致的结构：

然后哈希表的底层结构呢一般就使用数组，那我们用vector就可以了，也很方便

那用vector的话需要我们增加一个变量来记录哈希表中的数据个数。
那大家可能会疑问用vector的话vector.size()不就是数据个数嘛。
注意我们这里的插入不像vector的正常插入那样，从前往后连续插入，我们是按照得到的散列地址去插入的，vector的size不一定就是我们真实插入数据的size，而且我们哈希表删除只是把状态置为删除，也不会影响vector的size。
这里大家要区分一下。

插入函数insert实现

那然后我们来写一下插入——Insert

首先第一个问题，我们这里用vector实现哈希表，那我们除留余数法模的这个值应该是size还是capacity？
🆗，这里不能去%capacity，要去%size才可以。
为什么呢？
因为如果%capacity的，得到的那个散列值是可能会大于size的。
那我们之前也模拟实现过vector，要知道vector在进行插入操作的时候是会检查插入的那个位置是否在start和finish之间的

包括它对方括号的重载也会检查插入位置的下标是否小于size的。
所以如果这里%capacity的话有可能会越界，当然如果出现这种情况vector里面直接就报断言错误了。

那我们写一下插入的具体代码：

那就按照我们上面分析的逻辑走就行了

大家自己看一看理解一下

那大家有没有发现什么问题啊就上面插入的实现？

🆗，刚开始的时候size为0啊，那这里是不是就是除0错误了。
那除了size为0的情况我们还要考虑什么问题？
我们不断的插入，是不是要考虑在合适的时候进行扩容啊？
另外size是不是会发生变化啊，size一变这个映射关系是不是也就随之改变了？

那不着急，下面这些问题我们都会一一处理

载荷因子/负载因子

思考：哈希表什么情况下进行扩容？如何扩容？

对于哈希表来说，它的扩容不是等到当前表插入满了才去扩容。
而是去衡量哈希表的装满程度，如果当前表里面插入的元素已经比较多了，那这时再去插入新元素，发生冲突的可能性就比较大了，那冲突值就会增多，冲突值越多，那哈希表查找的效率就越低了。
所以当哈希表的装满程度已经比较大的时候，即使还没满，这个时候就要扩容了。

扩容

所以，这里引入了载荷因子来衡量一个哈希表的装满程度来判断要不要进行扩容：

散列表的载荷因子定义为：
α =填入表中的元素个数/散列表的长度
α是散列表装满程度的标志因子。
α越大，表明填入表中的元素越多，产生冲突的可能性就越大；
反之，α越小，表明填入表中的元素越少，产生冲突的可能性就越小。
实际上，散列表的平均查找长度是载荷因子α的函数，只是不同处理冲突的方法有不同的函数。
**对于开放定址法，荷载因子是特别重要因素，应严格限制在0.7-0.8以下。**超过0.8，查表时的CPU缓存不命中(cache missing）按照指数曲线上升。
所以当负载因子超过规定值就要扩容。

那我们来完善一下上面的代码：

我们这里可以取0.7为负载因子的最大值，大于等于这个值就扩容。
代码：

大家看这样可以了吗？还有其它问题吗？

大家翻上去看一下上面提到的几个问题处理完了吗？

是不是还没有啊，刚才的代码解决了扩容和size为0情况的处理。
但是还有一个问题：
就是我们使用resize扩容之后哈希表的size改变了，而我们用的哈希函数是除留余数法Hash(key) = key% size，那size变了，映射关系也就变了
扩容之后原来表里面已经插入的值，它现在新的散列地址如果还用之前的，可能就不对了。

所以这里的扩容操作：

我们要这样做
不能在原表的基础上进行扩容，而是要重新去开一块空间，该空间的大小就是扩容之后的大小，然后在新表上面把旧表的元素重新进行散列定位和插入。

那我们来修改补充一下上面的代码：

然后红框这里其实就是还是走一个插入的逻辑，我们可以把下面之前写的插入的代码拷贝上来修改一下。
这样写当然是可以的，如果嫌这样冗余的话，也可以单独把插入的部分封装一个函数，需要的地方直接调用就行了。

但是这里我们介绍一个新玩法：

这样就可以很好的实现一个复用。

Insert测试

那插入写好了，我们来测试一下：

比如我们就拿前面的这组数组测试一下

插入之后我们看跟图上一样不一样

来通过监视窗口看一下

大家可以自己对比一下，是完全一致的。

然后我们再来针对扩容的情况测试一下：

我们的平衡因子设置的是0.7，而上面我们刚好已经插入7个值了（对应的size是10）
所以，按理说我们再去插入一个值就会去扩容了，我们来看一下

比如我们再插入一个15，插入之后是这样的

我们来看一下

没有问题。

查找函数Find实现

上面把插入写好了，find我们顺便直接写一下，因为下面删除也要先查找：

那查找的话就按照对应的哈希函数确定散列地址就行了，然后如果有哈希冲突的话就按对应的探测方法往后查找就行了，找到了我们可以返回一下这个元素的指针，如果走到空还没找到就是没有这个值，返回空（如果表为空也没必要查找直接返回）
写一下代码

那find写好之后的话，其实insert里面我们可以再加一个，如果到时候封装unordered_map/set的时候，它们可以去重嘛，所以：

insert之前可以判断一下，如果存在就不再插入了。

删除函数Erase实现

那我们再来看一下删除的实现

那删除的逻辑呢我们上面已经讲过了，利用伪删除法，其实就是去改它的状态就行了。
那当然我们得先查找一下，确保这个值存在我们才能删除
🆗，来我们写一下

Find、Erase测试

然后查找删除我们一块测试一下

没什么问题。

bug解决

但是，现在我们上面写的代码在Find那里还有一个隐藏的bug，如果出现下面这种特殊情况就会有问题：

那种情况呢？
大多数情况下我们插入，只要负载因子达到设定值就会扩容。
但是不排除可能会出现这样的情况，就是我们插入了一些值之后，只要再插入一个值就会扩容，但是没有继续插入，而是删除了一些元素，删除一些之后又重新插入，这样没有引起扩容，但是导致了表中的状态只有删除和存在，而没有空的状态。
那此时我们的查找

就会陷入一个死循环（如果找不到的时候），因为这里这个while循环是遇到空才结束的

那如何解决呢？

也好办，加一个判断就行了

这样就可以了

那我们闭散列的实现差不多就到这里，当然我们这里是以线性探测为例实现，大家有兴趣可以自己写一下二次探测的版本。当然除了线性探测和二次探测也有其他的一些方法，大家有兴趣可以自行去了解。

闭散列的缺陷：

空间利用率低、冲突频率高：
开放定址法容易产生冲突，特别是当哈希表的负载因子较大时，即哈希表的装满程度更高。这会导致性能下降，因为冲突的数量会增加，导致查找的效率降低。而一旦减小负载因子，又会导致频繁扩容，空间利用率低。
聚集问题：
开放定址法在处理冲突时，有时会出现聚集问题。聚集是指数据项在哈希表中被连续地存储在相邻的位置上，这样会导致冲突更加频繁，并且会造成某些位置的利用率低而其他位置的利用率高的情况。

所以，实际应用中，处理哈希冲突更常用的是下面的方法

4.3 开散列（拉链法）

开散列/拉链法的概念：

开散列法又叫链地址法(拉链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素

4.4 开散列哈希表实现

那下面我们就用拉链法来重新实现一个哈希表。

结构定义

那我们来定义一下结构，还是以KV模型为例：

当然这里你直接用vector< list<K,V> >也可以，但是直接用list里面有些地方会不太好处理，所以这里里面的链接我们自己搞。