Hello大家好！ 很高兴与大家见面！ 给生活添点快乐，开始今天的编程之路。
我的博客: <但愿.
欢迎点赞，关注
目录
一 STL标准库中unordered_set/unordered_map的使用
1.1参考文档
二 哈希表的实现(抓住映射)
2.1哈希表的概念
2.2哈希表的实现方法一直接定址法
2.3哈希表相关概念
2.3.1 哈希冲突
2.3.2负载因⼦(由于扩容，注意不同方法的扩容条件不同)
2.3.3将关键字转为整数
2.4哈希函数(用于解决/降低哈希冲突）
2.4.1除法散列法/除留余数法
2.4.1.1除法散列法/除留余数法的概念
2.4.1.2怎么设置出优秀的除法散列法/除留余数法[规则]
2.4.2 乘法散列法（了解）
2.4.2.1 乘法散列法的概念
2.4.2.2 怎么设置出优秀的乘法散列法
2.4.3全域散列法（了解）
2.4.4其他⽅法（了解）
2.4.5 处理哈希冲突的方法选择
2.5 哈希表的实现方法二开放定址法
2.5.1 开放定址法的概念
2.5.2开放定址法处理函数冲突的方法
2.5.2.1 线性探测
2.5.2.1.1线性探测的规则(概念)
2.5.2.1.2 线性探测的实例
2.5.2.2 ⼆次探测
2.5.2.2.1 ⼆次探测规则(概念)
2.5.2.2.2 ⼆次探测的实例
2.5.2.3 双重散列（了解）
2.5.2.3.1双重散列的规则(概念)
2.5.3开放定址法实现哈希表的代码
2.6 哈希表的实现方法三链地址法
2.6.1链地址法解决冲突的思路
2.6.2扩容和怎么解决极端情况(一个哈希表的位置(一个桶很长))
2.6.2.1扩容
2.6.2.2解决极端情况(一个哈希表的位置(一个桶很长))
2.6.3链地址法的代码实现
三 封装哈希表实现unordered_set/unordered_map
一 STL标准库中unordered_set/unordered_map的使用
1.1参考文档
这两个的使用set和map一样，这里我只讲一讲它们的区别和效率上的差异。
二 哈希表的实现(抓住映射)
2.1哈希表的概念
哈希(hash)⼜称散列，是⼀种组织数据的⽅式。从译名来看，有散乱排列的意思。本质就是通过哈希函数把关键字Key跟存储位置建⽴⼀个映射关系，查找时通过这个哈希函数计算出Key存储的位置，进 ⾏快速查找。
2.2哈希表的实现方法一直接定址法
顾名思义 哈希表中每个数据的储存位置是确定的 ，当关键字的范围⽐较集中时，直接定址法就是⾮常简单⾼效的⽅法， ⽐如⼀组关键字都在[0,99]之间， 那么我们开⼀个100个数的数组，每个关键字的值直接就是存储位置的下标。再⽐如⼀组关键字值都在 [a,z]的⼩写字⺟，那么我们开⼀个26个数的数组，每个关键字acsii码-a ascii码就是存储位置的下标。 也就是说直接定址法本质就是⽤关键字计算出⼀个绝对位置或者相对位置 。
【例体统计字符串中字符的第一个唯一出现的个数，并且字符串中只有小写】
这里我们就可以使用直接定址法因为小写字母只有26个很集中，这里我们开⼀个26个数的数组，每个关键字acsii码-a ascii码就是存储位置的下标即可。
字符串中的第一个唯一字符
【题解】
cpp
class Solution {
public:
int firstUniqChar(string s) {
// 每个字⺟的ascii码-'a'的ascii码作为下标映射到count数组，数组中存储出现的次数
int count[26] = {0};
// 统计次数
for(auto ch : s)
{
count[ch-'a']++;
}
for(size_t i = 0; i < s.size(); ++i)
{
if(count[s[i]-'a'] == 1)
return i;
}
return -1;
}
};【总结】
上面这体使用了直接导致法实现，多少其题目给的字符串说明了只包含小写字母，所以关键子(数据)的范围很集中。所以这种方法的使用很局限，只有在关键子的范围较集中时使用才效率高，当关键字的范围⽐较分散时，就很浪费内存甚⾄内存不够⽤。
2.3哈希表相关概念
2.3.1 哈希冲突
顾名思义是不同的关键字(值)映射到哈希表中的同一个位置，从而发生哈希冲突。即**两个不同的key可能会映射到同⼀个位置去，这种问题我们叫做哈希冲突，**或者哈希碰撞。理想情况是找出⼀个好的哈希函数避免冲突，但是实际场景中，冲突是不可避免的， 所以我们尽可能设计出优秀的哈希函数，减少冲突的次数，同时也要去设计出解决冲突的⽅案。哈希冲突会影响哈希表的效率，所以哈希冲突越多其效率越低。
2.3.2负载因⼦(由于扩容，注意不同方法的扩容条件不同)
假设哈希表中已经映射存储了N个值，哈希表的⼤⼩为M，那么负载因子=N/M ，负载因⼦有些地⽅也翻译为载荷因⼦/装载因⼦等。负载因⼦越⼤，哈希冲突的概率越⾼，空间利⽤率越⾼；负载因⼦越⼩，哈希冲突的概率越低，空间利⽤率越低(即扩容再一定程度上也能减少哈希冲突）。
2.3.3将关键字转为整数
由于哈希表对于key的要求是可以取模即可以转为整数。我们将关键字映射到数组中位置，⼀般是整数好做映射计算，如果不是整数，我们要想办法转换成整数，这个细节我们后⾯代码实现中再进⾏细节展⽰。下⾯哈希函数部分我们讨论时，如果关键字不是整数，那么我们讨论的Key是关键字转换成的整数。
2.4哈希函数(用于解决/降低哈希冲突）
【概念】
⼀个好的哈希函数应该让N个关键字被等概率的均匀的散列分布到哈希表的M个空间中，但是实际中却很难做到，但是我们要尽量往这个⽅向去考量设计。哈希函数用于插入所以在查找时也要用这个哈希函数。所以一个哈希函数其计算key的映射位置每次要相同(不可能插入时应该位置，查找时应该位置)。哈希函数是哈希原理：插入是用这个规则，查找时也用这个规则。
2.4.1除法散列法/除留余数法
2.4.1.1除法散列法/除留余数法的概念
除法散列法也叫做除留余数法，顾名思义，假设哈希表的⼤⼩为M，那么通过key除以M的余数作为 映射位置的下标，也就是哈希函数为：h(key) = key % M。 h就是key映射在哈希表中的位置(实际要插入的位置。这里 只进行除所以对于表的大小没有要求，只是取值满足其规则即可 (即对M的要求)。
2.4.1.2怎么设置出优秀的除法散列法/除留余数法[规则]
• 当使⽤除法散列法时， 要尽量避免M为某些值，如2的幂，10的幂等 。如果是 ，那么key %
本质相当于保留key的后X位，那么后x位相同的值，计算出的哈希值都是⼀样的，就冲突了。如：{63 , 31}看起来没有关联的值，如果M是16，也就是 ，那么计算出的哈希值都是15，因为63的⼆ 进制后8位是 00111111，31的⼆进制后8位是 00011111。如果是 ，就更明显了，保留的都是10进值的后x位，如：{112, 12312}，如果M是100，也就是 ，那么计算出的哈希值都是12。这里不能取 2的幂，10的幂等，其实我们把key和M化成对应的进制就知道了，即只有后x为参与了计算，这就大大增加了发生哈希冲突的概率(这里我们应该让 key和M两者的位数尽可能的多参与方可减少哈希冲突的发生)。
• 当使⽤除法散列法时，建议 M取不太接近2的整数次幂的⼀个质数(素数) 【其一定不是哪个数的幂)。
注意在 实践中也是⼋仙过海，各显神通，不同语言可能也不同 。例如Java的HashMap采⽤除法散列法时就是2的整数 次幂做哈希表的⼤⼩M，这样玩的话，就不⽤取模，⽽可以直接位运算，相对⽽⾔位运算⽐模更⾼ 效⼀些。但是他不是单纯的去取模，⽐如M是2^16次⽅，本质是取后16位，那么⽤key' = key>>16，然后把key和key' 异或的结果作为哈希值。也就是说我们映射出的值还是在[0,M)范围 内， 但是本质都是尽量让key所有的位都参与计算，这样映射出的哈希值更均匀⼀些 即可。所以我们上⾯建 议M取不太接近2的整数次幂的⼀个质数的理论是⼤多数数据结构书籍中写的理论吗，但是实践中， 灵活运⽤，抓住本质即可。
2.4.2 乘法散列法（了解）
2.4.2.1 乘法散列法的概念
乘法散列法对哈希表⼤⼩M没有要求，他的⼤思路第⼀步：⽤关键字 K 乘上常数 A (0<A<1)，并抽
取出 k*A 的⼩数部分。第⼆步：后再⽤M乘以k*A 的⼩数部分，再向下取整。
即h(key)=floor(M x ( (A x key) % 1.0)), 其中floor表⽰对表达式进⾏下取整，A∈(0,1)。本质就是算出一个和key有关的小数。
2.4.2.2 怎么设置出优秀的乘法散列法
• 这⾥ 最重要的是A的值应该如何设定 ，Knuth认为A是⻩⾦分割点(（根号5-1）/2=0.618.......
• 注意乘法散列法对哈希表⼤⼩M是没有要求的，例如假设M为1024，key为1234，A = 0.6180339887, A*key= 762.6539420558，取⼩数部分为0.6539420558, M×((A×key)%1.0) = 0.6539420558*1024 = 669.6366651392，那么h(1234) = 669。
2.4.3全域散列法（了解）
• 如果存在⼀个恶意的对⼿，他针对我们提供的散列函数，特意构造出⼀个发⽣严重冲突的数据集， ⽐如，让所有关键字全部落⼊同⼀个位置中。这种情况是可以存在的，只要散列函数是公开且确定的，就可以实现此攻击。解决⽅法⾃然是⻅招拆招，给散列函数增加随机性，攻击者就⽆法找出确 **定可以导致最坏情况的数据。**这种⽅法叫做全域散列。
• h ab ( key ) = (( a × key + b )% P )% M，P需要选⼀个⾜够⼤的质数，a可以随机选[1,P-1]之间的 任意整数，b可以随机选[0,P-1]之间的任意整数，这些函数构成了⼀个P*(P-1)组全域散列函数组。 假设P=17，M=6，a = 3， b = 4, 则 。 h ab ( key ) = (( a × key + b )% P )% M
h 34 (8) = ((3 × 8 + 4)%17)%6 = 5
• 需要注意的是每次初始化哈希表时，随机选取全域散列函数组中的⼀个散列函数使⽤，后续增删查 改都固定使⽤这个散列函数，否则每次哈希都是随机选⼀个散列函数，那么插⼊是⼀个散列函数， 查找⼜是另⼀个散列函数，就会导致找不到插⼊的key了。
• 这是 乘法散列法的一个变形，本质还是除留余数法的一个哈希函数 ，这是这里是key经过一些运算之后再去取模。
2.4.4其他⽅法（了解）
• 上⾯的⼏种⽅法是《算法导论》书籍中讲解的⽅法。
• 《殷⼈昆 数据结构：⽤⾯向对象⽅法与C++语⾔描述 （第⼆版）》和 《[数据结构(C语⾔版)].严蔚 敏_吴伟⺠》等教材型书籍上⾯还给出了平⽅取中法、折叠法、随机数法、数学分析法等，这些⽅ 法相对更适⽤于⼀些局限的特定场景，有兴趣可以去看看这些书籍。
2.4.5 处理哈希冲突的方法选择
实践中 哈希表⼀般还是选择除法散列法作为哈希函数 (不是特殊情况不选择别的，例如为了防止别人攻击此时要选择全域散列法），但是哈希表⽆论选择什么哈希函数也避免不了冲突，那么插⼊数据时，如何解决冲突呢？这时候就要引入哈希表的实现方法，这里只讲主要有的两种⽅法， 开放定址法和链地址法 ，看看它们任何降低甚至解决哈希冲突。
2.5 哈希表的实现方法二开放定址法
2.5.1 开放定址法的概念
在开放定址法中所有的元素都放到哈希表⾥，当⼀个关键字key⽤哈希函数计算出的位置冲突了，则按照某种规则找到⼀个没有存储数据的位置进⾏存储， 开放定址法中负载因⼦⼀定是⼩于1 (注意 再实际中我们使用开发地址法实现哈希表时负载因子再0.7左右就要扩容，因为这样可以使得数据跟分散一些，再一定程度上化解了哈希冲突 )。这⾥的规 则有三种： 线性探测、⼆次探测、双重探测 。
2.5.2开放定址法处理函数冲突的方法
2.5.2.1 线性探测
2.5.2.1.1线性探测的规则(概念)
• 从发⽣冲突的位置开始，依次线性向后探测，直到寻找到下⼀个没有存储数据的位置为⽌，如果⾛到哈希表尾，则回绕到哈希表头的位置。
• h(key) = hash0 = key% M, hash0位置冲突了，则线性探测公式为：
hc(key,i) = hashi= (hash0 + i) % M， i= {1, 2, 3, ..., M− 1} ，因为负载因⼦⼩于1，
则最多探测M-1次，⼀定能找到⼀个存储key的位置。
• 线性探测的⽐较简单且容易实现，线性探测的问题假设，hash0位置连续冲突，hash0，hash1，hash2位置已经存储数据了，后续映射到hash0，hash1，hash2，hash3的值都会争夺hash3位置，这种现象叫做群集/堆积。为了一定程度改善这个问题而引入 ⼆次探测。
• 这种方法的缺陷就是存在群集/堆积现象
2.5.2.1.2 线性探测的实例
下⾯演⽰ {19,30,5,36,13,20,21,12} 等这⼀组值映射到M=11的表中。
h(19) = 8 ， h(30) = 8 ， h(5) = 5 ， h(36) = 3 ， h(13) = 2 ， h(20) = 9 ， h(21) =10 ， h(12) = 1
先插入19，插入到下标为8的节点，在插入30，30的插入位置是下标为8的节点，由于下标为8的节点是已经储存数据，此时就要不断判断下标8之后的节点是否为空，为空就插入，如果到表未就绕回到标头继续判断，后面的数据依次执行这个逻辑即可。
【映射到哈希表中的数据图】
2.5.2.2 ⼆次探测
2.5.2.2.1 ⼆次探测规则(概念)
• 从发⽣冲突的位置开始，依次左右按⼆次⽅跳跃式探测，直到寻找到下⼀个没有存储数据的位置为⽌，如果往右⾛到哈希表尾，则回绕到哈希表头的位置；如果往左⾛到哈希表头，则回绕到哈希表尾的位置；
•h(key) = hash0 = key% M ,hash0位置冲突了，则⼆次探测公式为：hc(key,i) = hashi= (hash0 ± i^2 ) % M， i= {1, 2, 3, ..., }。这里是+或者-i^2所以其分布更广，有的地方是先+i^2再-i^2不断重复。所以这里相比一线性探测再缓解哈希冲突上更优一些。
•⼆次探测当hashi= (hash0 − i2 )%M时，当hashi<0时，需要hashi += M
2.5.2.2.2 ⼆次探测的实例
下⾯演⽰ {19,30,52,63,11,22} 等这⼀组值映射到M=11的表中。
h(19) = 8, h(30) = 8, h(52) = 8, h(63) = 8, h(11) = 0, h(22) = 0
【映射到哈希表中的数据图】
2.5.2.3 双重散列（了解）
2.5.2.3.1双重散列的规则(概念)
• 第⼀个哈希函数计算出的值发⽣冲突，使⽤第⼆个哈希函数计算出⼀个跟key相关的偏移量值，不断往后探测，直到寻找到下⼀个没有存储数据的位置为⽌。
• h1 (key) = hash0 = key% M,hash0位置冲突了，则双重探测公式为：
hc(key,i) = hashi= (hash0 + i∗ h2 (key)) % M， i= {1, 2, 3, ..., M}。
• 要求h2 (key) < M 且 h2 (key)和M互为质数，有两种简单的取值⽅法：
1、当M为2整数幂时，h2 (key)从从[0，M-1]任选⼀个奇数；
2、当M为质数时，h2 (key) = key% (M− 1) + 1
**• 保证h2 (key ) 与M互质是因为根据固定的偏移量所寻址的所有位置将形成⼀个群，若最⼤公约数p= gcd(M, h1 (key )) > 1，那么所能寻址的位置的个数为M/P< M，使得对于⼀个关键字来 说⽆法充分利⽤整个散列表。• 其本质是使用两个哈希函数
2.5.3开放定址法实现哈希表的代码
cpp
//解决M表的大小是质数，因为我们是两倍扩容，所以要同时保证其两倍扩容后的M也是质数
//这里还有一个很难的问题，就是我们取的表的大小，要不是2和10的幂，并且是要为质数
//并且我们的扩容是两倍增长，就算满足上面的条件其扩容后其表的大小也可能不是质数。
//那怎么解决这个问题呢？
//这里我们可以建立一个近似两倍增长的质数表即可
inline 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 = lower_bound(first, last, n);
return pos == last ? *(last - 1) : *pos;
}
//这里还有一个问题，哈希中对于key的要求是可以取模(即可以转化为整形)
//而在生活中string对象经常作为key，那怎么解决这个问题呢？
//这里我们可以学红黑树中获取key的方法，实现一个仿函数(因为要将可以其整和不能取整的进行分类)，使用一种方法将其转化取模
//这里常见的方法是计算string中每个字母的scall码值之和，但是如果字母顺序不同等不同情况都可能导致string中每个字母的scall码值之和相等
//这个问题我们可以先加string对象中一个字母的scall码值在将结果*一个数，不断重复对string对象中的每个字母进行相同操作即可
//可以取整
template<class K>
struct HashFunc
{
size_t operator()(const K& key) const
{
return (size_t)key;
}
};
//这里将string类型转化为整形，单独封装一种方法，的方法不好
// 这里只是参数类型不同，这里我们可以对于将对象转化为可以取整的方法，进行特化，特化出string对象的即可
//对于string类型对象我们可以求string对象中每个字母的ascall码之和，
// 但是string对象的字母实现不同、字母个数不同等等原因可能导致string对象中每个字母的ascall码之和相等
//所以为了防止这种情况的发生，这里我们对string对象的每个字母相加的同时，再乘一个数(这个数大佬经过验证给的是131)
template<>
struct HashFunc<string>
{
size_t operator()(const string& key) const
{
size_t hash = 0;
for (auto ch : key)
{
hash += ch;
hash *= 131;
}
return hash;
}
};
//将string类型转化为整形，单独封装一种方法
//struct StringHashFunc
//{
// size_t operator()(const string& key) const
// {
// size_t hash = 0;
// for (auto ch : key)
// {
// hash += ch;
// hash *= 131;
// }
// return hash;
// }
//};
//上面这种方法很好，再实际中我们经常使用这种方法，例如再结构体中我们可能取其中的一两项进行区分
//例如储存r信息的一个结构体，我们可以取其身份证的出生日期+名字进行区分等等
//例如下面的pair类型
struct pairHash
{
size_t operator()(const pair<int, int>& kv) const
{
size_t hash = 0;
hash += kv.first;
hash *= 131;
hash += kv.second;
hash *= 131;
cout << hash << endl;
return hash;
}
};
//开放地址法
//因为后面要顺序别的方法，可能会其冲突，所以这里我们使用命名空间进行封装
namespace open_adrress
{
//定义节点的状态
//这里接节点的状态不仅有存在、空；还有删除。
//因为由于存在哈希冲突，可能导致一些节点储存位置的改变，如果只有存在和空两种状态
//节点删除之后，节点的状态改成空时会影响查找，可能查找的值在其中，但是因为删除节点之后变成空
//而未找到
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 Hash = HashFunc<K>>
class HashTable
{
public:
HashTable(size_t n = 11)
:_tables(n)
, _n(0)
{
}
//插入
bool Insert(const pair<K, V>& kv)
{
//查找去重
if (Find(kv.first))
return false;
//负载因子>0.7是要扩容
//这里有一个问题就是，由于空间的扩大，之前数据的映射关系可能也会改变
//所以这里要对数据进行重新映射，那怎么解决呢？这里有两种方法
if ((double)_n / (double)_tables.size() >= 0.7)
{
//方法一：
//这里我们创建一个容量是之前两倍大小的vector容器，在将旧哈希表中节点状态是存在的节点
//进行重新映射到新表中
//vector<HashData<K, V>> newtables;
//newtables.resize(_tables.size * 2);
////遍历旧表将旧表中的数据全部映射到新表中
//for (size_t i = 0; i < _tables.size(); i++)
//{
// if (_tables[i]._state == EXIST)
// {
// //重复插入操作
// }
//}
////在用现代写法交换一下新旧表即可
//_tables.swap(newtables);
//由于上面方法并不好，因为在将旧表中的数据重新映射到新表中的步骤和插入一样，所以这里我们不用方法一。
//方法二
//我们建立一个空间大小是之前两倍大小的新的哈希表，在遍历旧表中的数据，将其插入到新表中
//方法一的重新映射插入要自己实现，而方法二是将旧表中得到的数据插入到新表中(自己调用insert一种复用)
//HashTable<K, V> newht(_tables.size() * 2);
HashTable<K, V, Hash> 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);
}
//插入按除法散列法插入
Hash hs;
//1找到要映射的位置
size_t hash0 = hs(kv.first) % _tables.size();
size_t hashi = hash0;
size_t i = 1;
//找到要映射的位置,后进行线性探测，直到找到节点的状态不是存在时就插入
while (_tables[hashi]._state == EXIST)
{
hashi = hashi + i;
i++;
hashi %= _tables.size();
}
_tables[hashi]._kv = kv;
_tables[hashi]._state = EXIST;
++_n;
return true;
}
//查找
HashData<K, V>* Find(const K& key)
{
Hash hs;
//查找和插入一样，走相同步骤
size_t hash0 = key % _tables.size();
size_t hashi = hash0;
size_t i = 1;
//找到映射位置，从映射位置的节点开始，只要节点位置的状态不是空
//如果此时key不相等要不断相互找，因为可能因为还想冲突，导致其储存位置向后变了
while (_tables[hashi]._state != EMPTY)
{
if (_tables[hashi]._state == EXIST && _tables[hashi]._kv.first == key)
{
return &_tables[hashi];
}
//线性探测
hashi = hashi + i;
i++;
hashi %= _tables.size();
}
}
//删除
//删除很简单，找到对应节点，在把其节点的存在状态改为删除
//注意这里不能改成空，因为由于哈希冲突导致一些值插入在后面，为了不影响查找这里把节点的状态改成删除
bool Erase(const K& key)
{
HashData<K, V>* ret = Find(key);
if (ret)
{
ret->_state = DELETE;
--_n;
return true;
}
else
{
return false;
}
}
private:
vector<HashData<K, V>> _tables;
size_t _n;//实际储存的实际个数
};
}2.6 哈希表的实现方法三链地址法
开发地址法虽然再一定程度上缓解了哈希冲突，但是其有一个致命缺陷就是一直再表中抢别人的位置(无法真正解决哈希冲突，只能缓解)。为了彻底解决哈希冲突而引入链地址法。
2.6.1链地址法解决冲突的思路
开放定址法 中所有的元素都 放到哈希表⾥ ， 链地址法 中所有的数据不再直接存储在哈希表中， 哈希表中存储⼀个指针，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成⼀个链表，挂在哈希表这个位置下⾯ ，链地址法也叫做拉链法或者哈希桶(挂起来很像桶)。
2.6.2扩容和怎么解决极端情况(一个哈希表的位置(一个桶很长))
2.6.2.1扩容
开放定址法负载因⼦必须⼩于1，链地址法的负载因⼦就没有限制了(无哈希冲突)，可以⼤于1。负载因⼦越⼤，哈希冲突的概率越⾼，空间利⽤率越⾼；负载因⼦越⼩，哈希冲突的概率越低，空间利⽤率越低；stl中 unordered_xxx的最⼤负载因⼦基本控制在1，⼤于1就扩容，所以我们下⾯实现也使⽤这个⽅式。 当负载因子大于1就扩容。
2.6.2.2解决极端情况(一个哈希表的位置(一个桶很长))
其实我们可以考虑使⽤全域散列法，这样就不容易被针对了。但是假设不是被针对了，⽤了全域散列法，但是偶然情况下，某个桶很⻓，查找效率很低怎么 办？这⾥我们可以参考在Java8的HashMap中 当桶的⻓度超过⼀定阀值(8)时就把链表转换成红⿊树 。
2.6.3链地址法的代码实现
cpp
//解决M表的大小是质数，因为我们是两倍扩容，所以要同时保证其两倍扩容后的M也是质数
//这里还有一个很难的问题，就是我们取的表的大小，要不是2和10的幂，并且是要为质数
//并且我们的扩容是两倍增长，就算满足上面的条件其扩容后其表的大小也可能不是质数。
//那怎么解决这个问题呢？
//这里我们可以建立一个近似两倍增长的质数表即可
inline 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 = lower_bound(first, last, n);
return pos == last ? *(last - 1) : *pos;
}
//这里还有一个问题，哈希中对于key的要求是可以取模(即可以转化为整形)
//而在生活中string对象经常作为key，那怎么解决这个问题呢？
//这里我们可以学红黑树中获取key的方法，实现一个仿函数(因为要将可以其整和不能取整的进行分类)，使用一种方法将其转化取模
//这里常见的方法是计算string中每个字母的scall码值之和，但是如果字母顺序不同等不同情况都可能导致string中每个字母的scall码值之和相等
//这个问题我们可以先加string对象中一个字母的scall码值在将结果*一个数，不断重复对string对象中的每个字母进行相同操作即可
//可以取整
template<class K>
struct HashFunc
{
size_t operator()(const K& key) const
{
return (size_t)key;
}
};
//这里将string类型转化为整形，单独封装一种方法，的方法不好
// 这里只是参数类型不同，这里我们可以对于将对象转化为可以取整的方法，进行特化，特化出string对象的即可
//对于string类型对象我们可以求string对象中每个字母的ascall码之和，
// 但是string对象的字母实现不同、字母个数不同等等原因可能导致string对象中每个字母的ascall码之和相等
//所以为了防止这种情况的发生，这里我们对string对象的每个字母相加的同时，再乘一个数(这个数大佬经过验证给的是131)
template<>
struct HashFunc<string>
{
size_t operator()(const string& key) const
{
size_t hash = 0;
for (auto ch : key)
{
hash += ch;
hash *= 131;
}
return hash;
}
};
//将string类型转化为整形，单独封装一种方法
//struct StringHashFunc
//{
// size_t operator()(const string& key) const
// {
// size_t hash = 0;
// for (auto ch : key)
// {
// hash += ch;
// hash *= 131;
// }
// return hash;
// }
//};
//上面这种方法很好，再实际中我们经常使用这种方法，例如再结构体中我们可能取其中的一两项进行区分
//例如储存r信息的一个结构体，我们可以取其身份证的出生日期+名字进行区分等等
//例如下面的pair类型
struct pairHash
{
size_t operator()(const pair<int, int>& kv) const
{
size_t hash = 0;
hash += kv.first;
hash *= 131;
hash += kv.second;
hash *= 131;
cout << hash << endl;
return hash;
}
};
//链地址法-这种方法更好，所以我们封装顺序unordered_set/unordered_map
//因为不管上面。。。。三种探测
namespace hash_bucket
{
//定义哈希节点
template<class K,class V>
struct HashNode
{
pair<K, V> _kv;
HashNode<K, V>* _next;
HashNode(const 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 = __stl_next_prime(0))
:_tables(n,nullptr)
,_n(0)
{ }*/
HashTable(size_t n = 11)
:_tables(n, nullptr)
, _n(0)
{
}
//插入
bool Insert(const pair<K, V>& kv)
{
//1查找去重
if (Find(kv.first))
return false;
Hash hs;
//2扩容
//根据负载因子来判断，但是这里和开发地址法不一样
//这里是负载因子到1时才扩容
//这里的结构和开发地址法的结构不一样，所以细节和开发地址法也不一样。
//虽然大思路也是两种，但是每种思路的细节是先找哈希表中是否有数据，有就遍历哈希桶(链表)将数据插入到新的哈希表中
//走完一个哈希桶，中间的哈希桶可能为空，所以要遍历判断哈希桶，遇到哈希桶不为空，就将其中的数据到人到新的哈希表中
//这里还有一个问题，交换后的新旧哈希表，因为哈希表是用vector实现，所以旧的哈希表会自动调用对应的析构函数
//但是定义哈希表中vector容器中储存的链式结构(链表)是一个自定义类型，此时不会自动调用对应的析构函数
//所以这里我们要中间写析构函数，这里有人想把哈希表用vector<forwand_list<pair<k,v>>不就好了
//注意虽然这种方法在这里很方便，但是在迭代器的实现上就难以实现了。所以这里我们要自己写析构函数。
if (_n == _tables.size())
{
//HashTable<K, V> newht(__stl_next_prime(_tables.size() + 1));
//// 遍历旧表，将旧表的数据全部重新映射到新表
//for (size_t i = 0; i < _tables.size(); i++)
//{
// Node* cur = _tables[i];
// while (cur)
// {
// newht.Insert(cur->_kv);
// cur = cur->_next;
// }
//}
//_tables.swap(newht._tables);
// 扩容
vector<Node*> newtables(__stl_next_prime(_tables.size() + 1), nullptr);
// 遍历旧表，将旧表的数据全部重新映射到新表
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
// cur头插到新表
size_t hashi = hs(cur->_kv.first) % newtables.size();
cur->_next = newtables[hashi];
newtables[hashi] = cur;
cur = next;
}
_tables[i] = nullptr;
}
_tables.swap(newtables);
}
//3找到数据要插入哈希表中对应的位置
//然后头插进哈希桶-这里可以是头插也可以尾插，两者都可以肯定选头插
size_t hashi = hs(kv.first) % _tables.size();
Node* newnode = new Node(kv);
newnode->_next = _tables[hashi];
_tables[hashi] = newnode;
++_n;
return true;
}
//查找
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;
}
}
//删除-这里就不能像直接地址法一样，先查找在删除
//因为我们这里要改变前后指针的指向，所以要找到当前节点和当前节点的前一个
//（因为这里是单向迭代器，所以无法得到一个节点，根据该节点得到上一个节点，这也是无法通过先查找在删除的原因)
bool Erase(const K& key)
{
Hash hs;
size_t hashi = hs(key) % _tables.size();
Node* prev = nullptr;
Node* cur = _tables[hashi];
while (cur)
{
//这里有一种情况如果_tables[hashi]就是要删的节点时，不会进行改变prev和cur的指向操作（不断向后遍历查找）
//此时prev==nullptr，此时就会出错，所以这里要分类讨论
/*if (cur->_kv.first == key)
{
prev->_next = cur->_next;
--_n;
delete cur;
return true;
}*/
if (cur->_kv.first == key)
{
if (prev == nullptr)
{
_tables[hashi] = cur->_next;
}
else
{
prev->_next = cur->_next;
}
--_n;
delete cur;
return true;
}
prev = cur;//将上一个节点指向cur，不断向后遍历查找
cur = cur->_next;
}
return false;
}
private:
vector<Node*> _tables;//用于储存顺序哈希表，可以自己写一个数组，这里有现成的vector
//所以这里用vector来储存.
size_t _n;//实际储存的数据个数
};
}三 封装哈希表实现unordered_set/unordered_map
这里和封装红黑树实现set/map的步骤差不多，可能出现的错误也差不多，可能因为对于key的要求不同为了满足这些要求可能要实现一些仿函数等等，导致模板参数不同。例如这里为了key可以取整所以要实现一个仿函数实现不同对象可以取整这不就比封装红黑树实现set/map的模板参数多一个。
【代码】
HashTable.h
cpp
#pragma once
#include<iostream>
#include<vector>
using namespace std;
//解决M表的大小是质数，因为我们是两倍扩容，所以要同时保证其两倍扩容后的M也是质数
//这里还有一个很难的问题，就是我们取的表的大小，要不是2和10的幂，并且是要为质数
//并且我们的扩容是两倍增长，就算满足上面的条件其扩容后其表的大小也可能不是质数。
//那怎么解决这个问题呢？
//这里我们可以建立一个近似两倍增长的质数表即可
inline 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 = lower_bound(first, last, n);
return pos == last ? *(last - 1) : *pos;
}
//这里还有一个问题，哈希中对于key的要求是可以取模(即可以转化为整形)
//而在生活中string对象经常作为key，那怎么解决这个问题呢？
//这里我们可以学红黑树中获取key的方法，实现一个仿函数(因为要将可以其整和不能取整的进行分类)，使用一种方法将其转化取模
//这里常见的方法是计算string中每个字母的scall码值之和，但是如果字母顺序不同等不同情况都可能导致string中每个字母的scall码值之和相等
//这个问题我们可以先加string对象中一个字母的scall码值在将结果*一个数，不断重复对string对象中的每个字母进行相同操作即可
//可以取整
template<class K>
struct HashFunc
{
size_t operator()(const K& key) const
{
return (size_t)key;
}
};
//这里将string类型转化为整形，单独封装一种方法，的方法不好
// 这里只是参数类型不同，这里我们可以对于将对象转化为可以取整的方法，进行特化，特化出string对象的即可
//对于string类型对象我们可以求string对象中每个字母的ascall码之和，
// 但是string对象的字母实现不同、字母个数不同等等原因可能导致string对象中每个字母的ascall码之和相等
//所以为了防止这种情况的发生，这里我们对string对象的每个字母相加的同时，再乘一个数(这个数大佬经过验证给的是131)
template<>
struct HashFunc<string>
{
size_t operator()(const string& key) const
{
size_t hash = 0;
for (auto ch : key)
{
hash += ch;
hash *= 131;
}
return hash;
}
};
//将string类型转化为整形，单独封装一种方法
//struct StringHashFunc
//{
// size_t operator()(const string& key) const
// {
// size_t hash = 0;
// for (auto ch : key)
// {
// hash += ch;
// hash *= 131;
// }
// return hash;
// }
//};
//上面这种方法很好，再实际中我们经常使用这种方法，例如再结构体中我们可能取其中的一两项进行区分
//例如储存r信息的一个结构体，我们可以取其身份证的出生日期+名字进行区分等等
//例如下面的pair类型
struct pairHash
{
size_t operator()(const pair<int, int>& kv) const
{
size_t hash = 0;
hash += kv.first;
hash *= 131;
hash += kv.second;
hash *= 131;
cout << hash << endl;
return hash;
}
};
//链地址法-这种方法更好，所以我们封装顺序unordered_set/unordered_map
//因为不管上面。。。。三种探测
namespace hash_bucket
{
//定义哈希节点
template<class T>
struct HashNode
{
T _data;
HashNode<T>* _next;
HashNode(const T& data)
:_data(data)
,_next(nullptr)
{ }
};
//前置声名-因为编译器只能至上而下找，而迭代器和哈希表直接绑定了，
//不管两者顺序怎么样，总有一个识别不了一个，所以这里加一个前置声名
template<class K,class T,class KeyOft,class Hash>
class HashTable;
//定义迭代器
template<class K,class T,class Ref,class Ptr, class KeyOft,class Hash>
struct HTIterator
{
typedef HashNode<T> Node;
typedef HashTable<K, T, KeyOft, Hash> HT;
typedef HTIterator<K, T, Ref, Ptr, KeyOft, Hash> Self;
Node* _node;
const HT* _pht;
//这里用const修饰时因为再const迭代器中的this指针应该也要const修饰，如果没用则会权限放大，
//反之普通的迭代器的this指针时普通指针,而这里是const指针权限缩小，因为权限可以缩小不能放大，所以这里用const修饰
HTIterator(Node* node, const HT* pht)
:_node(node)
,_pht(pht)
{
}
//难点++
Self& operator++()
{
if (_node->_next)
{
_node = _node->_next;
}
else
{
KeyOft kot;
Hash hs;
size_t hashi = hs(kot(_node->_data)) % _pht->_tables.size();
//先hasi++后进入循环，因为当前哈希桶遇到不为空
hashi++;
while (hashi < _pht->_tables.size())
{
if (_pht->_tables[hashi])
{
_node = _pht->_tables[hashi];
break;
}
++hashi;
}
if (hashi == _pht->_tables.size())
{
//当所以走完时返回End空
_node = nullptr;
}
}
return *this;
}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
bool operator==(const Self& s)const
{
return _node == s._node;
}
bool operator!=(const Self& s)const
{
return _node != s._node;
}
};
//定义哈希表
template<class K,class T, class KeyOft, class Hash>
class HashTable
{
typedef HashNode<T> Node;
//永远声名-因为迭代器要访问私有成员_tables。
template<class K,class T,class Ref,class Ptr,class KeyOft,class Hash>
friend struct HTIterator;
public:
typedef HTIterator<K, T, T&, T*, KeyOft, Hash> Iterator;
typedef HTIterator<K, T, const T&, const T*, KeyOft, Hash> ConstIterator;
HashTable(size_t n = __stl_next_prime(0))
:_tables(n,nullptr)
,_n(0)
{ }
~HashTable()
{
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_tables[i] = nullptr;
}
}
//HashTable(size_t n = 11)
// :_tables(n, nullptr)
// , _n(0)
//{
//}//测试是否正确
//迭代器
Iterator Begin()
{
if (_n == 0)
return End();
for (size_t i = 0; i < _tables.size(); i++)
{
if (_tables[i])
{
return Iterator(_tables[i], this);
}
}
return End();
}
Iterator End()
{
return Iterator(nullptr, this);
}
//const迭代器
ConstIterator Begin() const
{
if (_n == 0)
return End();
for (size_t i = 0; i < _tables.size(); i++)
{
if (_tables[i])
{
return ConstIterator(_tables[i], this);
}
}
return End();
}
ConstIterator End() const
{
return ConstIterator(nullptr, this);
}
//插入
pair<Iterator,bool> Insert(const T& data)
{
KeyOft kot;
//1查找去重
Iterator it = Find(kot(data));
if(it != End())
return { it,false };
Hash hs;
//2扩容
//根据负载因子来判断，但是这里和开发地址法不一样
//这里是负载因子到1时才扩容
//这里的结构和开发地址法的结构不一样，所以细节和开发地址法也不一样。
//虽然大思路也是两种，但是每种思路的细节是先找哈希表中是否有数据，有就遍历哈希桶(链表)将数据插入到新的哈希表中
//走完一个哈希桶，中间的哈希桶可能为空，所以要遍历判断哈希桶，遇到哈希桶不为空，就将其中的数据到人到新的哈希表中
//这里还有一个问题，交换后的新旧哈希表，因为哈希表是用vector实现，所以旧的哈希表会自动调用对应的析构函数
//但是定义哈希表中vector容器中储存的链式结构(链表)是一个自定义类型，此时不会自动调用对应的析构函数
//所以这里我们要中间写析构函数，这里有人想把哈希表用vector<forwand_list<pair<k,v>>不就好了
//注意虽然这种方法在这里很方便，但是在迭代器的实现上就难以实现了。所以这里我们要自己写析构函数。
if (_n == _tables.size())
{
//HashTable<K, V> newht(__stl_next_prime(_tables.size() + 1));
//// 遍历旧表，将旧表的数据全部重新映射到新表
//for (size_t i = 0; i < _tables.size(); i++)
//{
// Node* cur = _tables[i];
// while (cur)
// {
// newht.Insert(cur->_kv);
// cur = cur->_next;
// }
//}
//_tables.swap(newht._tables);
// 扩容
vector<Node*> newtables(__stl_next_prime(_tables.size() + 1), nullptr);
// 遍历旧表，将旧表的数据全部重新映射到新表
for (size_t i = 0; i < _tables.size(); i++)
{
Node* cur = _tables[i];
while (cur)
{
Node* next = cur->_next;
// cur头插到新表
size_t hashi = hs(kot(cur->_data)) % newtables.size();
cur->_next = newtables[hashi];
newtables[hashi] = cur;
cur = next;
}
_tables[i] = nullptr;
}
_tables.swap(newtables);
}
//3找到数据要插入哈希表中对应的位置
//然后头插进哈希桶-这里可以是头插也可以尾插，两者都可以肯定选头插
size_t hashi = hs(kot(data)) % _tables.size();
Node* newnode = new Node(data);
newnode->_next = _tables[hashi];
_tables[hashi] = newnode;
++_n;
return { Iterator(newnode,this),true };
}
//查找
Iterator Find(const K& key)
{
Hash hs;
KeyOft kot;
size_t hashi = hs(key) % _tables.size();
Node* cur = _tables[hashi];
while (cur)
{
if (kot(cur->_data) == key)
return Iterator(cur,this);
cur = cur->_next;
}
return End();
}
//删除-这里就不能像直接地址法一样，先查找在删除
//因为我们这里要改变前后指针的指向，所以要找到当前节点和当前节点的前一个
//（因为这里是单向迭代器，所以无法得到一个节点，根据该节点得到上一个节点，这也是无法通过先查找在删除的原因)
bool Erase(const K& key)
{
Hash hs;
KeyOft kot;
size_t hashi = hs(key) % _tables.size();
Node* prev = nullptr;
Node* cur = _tables[hashi];
while (cur)
{
//这里有一种情况如果_tables[hashi]就是要删的节点时，不会进行改变prev和cur的指向操作（不断向后遍历查找）
//此时prev==nullptr，此时就会出错，所以这里要分类讨论
/*if (cur->_kv.first == key)
{
prev->_next = cur->_next;
--_n;
delete cur;
return true;
}*/
if (kot(cur->_data) == key)
{
if (prev == nullptr)
{
_tables[hashi] = cur->_next;
}
else
{
prev->_next = cur->_next;
}
--_n;
delete cur;
return true;
}
prev = cur;//将上一个节点指向cur，不断向后遍历查找
cur = cur->_next;
}
return false;
}
private:
vector<Node*> _tables;//用于储存顺序哈希表，可以自己写一个数组，这里有现成的vector
//所以这里用vector来储存.
size_t _n;//实际储存的数据个数
};
}unordered_set
cpp
#pragma once
#include"HashTable.h"
namespace wzy
{
template<class K,class Hash = HashFunc<K>>
class unordered_set
{
//实现一个仿函数，获取储存数据中的key
struct SetKeyOft
{
const K& operator()(const K& key)
{
return key;
}
};
public:
typedef typename hash_bucket::HashTable<K, const K, SetKeyOft, Hash>::Iterator iterator;
typedef typename hash_bucket::HashTable<K, const K, SetKeyOft, Hash>::ConstIterator const_iterator;
//普通迭代器
iterator begin()
{
return _ht.Begin();
}
iterator end()
{
return _ht.End();
}
//const迭代器
const_iterator begin() const
{
return _ht.Begin();
}
const_iterator end() const
{
return _ht.End();
}
pair<iterator,bool> insert(const K& key)
{
return _ht.Insert(key);
}
iterator find(const K& key)
{
return _ht.Find(key);
}
bool erase(const K& key)
{
return _ht.Erase(key);
}
private:
hash_bucket::HashTable<K, const K, SetKeyOft,Hash> _ht;
};
void Print(const unordered_set<int>& s)
{
unordered_set<int>::const_iterator it = s.begin();
while (it != s.end())
{
// *it = 1;
cout << *it << " ";
++it;
}
cout << endl;
}
}unordered_map
cpp
#pragma once
#include"HashTable.h"
namespace wzy
{
template<class K,class V,class Hash = HashFunc<K>>
class unordered_map
{
//写一个放函数，获取储存数据中的key
struct MapKeyOft
{
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
public:
typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOft, Hash>::Iterator iterator;
typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOft, Hash>::ConstIterator const_iterator;
iterator begin()
{
return _ht.Begin();
}
iterator end()
{
return _ht.End();
}
const_iterator begin() const
{
return _ht.Begin();
}
const_iterator end() const
{
return _ht.End();
}
pair<iterator, bool> insert(const pair<K, V>& kv)
{
return _ht.Insert(kv);
}
iterator find(const K& key)
{
return _ht.Find(key);
}
bool erase(const K& key)
{
return _ht.Erase(key);
}
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert({ key, V() });
return ret.first->second;
}
private:
hash_bucket::HashTable<K, pair<const K, V>, MapKeyOft,Hash> _ht;
};
}本篇文章就到此结束，欢迎大家订阅我的专栏，欢迎大家指正，希望有所能帮到读者更好了解C++STL知识 ，STL的解决就到此为此，后面我将更新C++11相关知识。觉得有帮助的还请三联支持一下~后续会不断更新算法与数据结构相关知识，我们下期再见。