文章目录
一、unordered系列的使用
unordered_set类的介绍
• unordered_set的声明如下，Key就是unordered_set底层关键字的类型
• unordered_set默认要求Key⽀持转换为整形，如果不⽀持或者想按⾃⼰的需求⾛可以⾃⾏实现⽀持将Key转成整形的仿函数传给第⼆个模板参数
• unordered_set默认要求Key⽀持⽐较相等，如果不⽀持或者想按⾃⼰的需求⾛可以⾃⾏实现⽀持将Key⽐较相等的仿函数传给第三个模板参数
• unordered_set底层存储数据的内存是从空间配置器申请的，如果需要可以⾃⼰实现内存池，传给第四个参数。
• ⼀般情况下，我们都不需要传后三个模板参数 • unordered_set底层是⽤哈希桶实现，增删查平均效率是O(1)，迭代器遍历不再有序，为了跟set区分，所以取名unordered_set。
• 前⾯部分我们已经学习了set容器的使⽤，set和unordered_set的功能⾼度相似，只是底层结构不同，有⼀些性能和使⽤的差异，这⾥我们只讲他们的差异部分。
unordered_set和set的使⽤差异
查看⽂档我们会发现unordered_set的⽀持增删查且跟set的使⽤⼀模⼀样，关于使⽤我们这⾥就不再赘述和演⽰了。文档链接
• unordered_set和set的第⼀个差异是对key的要求不同，set要求Key⽀持⼩于⽐较，⽽
unordered_set要求Key⽀持转成整形且⽀持等于⽐较，要理解unordered_set的这个两点要求得后续我们结合哈希表底层实现才能真正理解，也就是说这本质是哈希表的要求。
• unordered_set和set的第⼆个差异是迭代器的差异，set的iterator是双向迭代器，unordered_set是单向迭代器，其次set底层是红⿊树，红⿊树是⼆叉搜索树，⾛中序遍历是有序的，所以set迭代器遍历是有序+去重。⽽unordered_set底层是哈希表，迭代器遍历是⽆序+去重。(去重原理是遇到重复值不再插入)
• unordered_set和set的第三个差异是性能的差异，整体⽽⾔⼤多数场景下unordered_set的增删查改更快⼀些，因为红⿊树增删查改效率是O(logN)，⽽哈希表增删查平均效率是 O(1)，具体可以参看下⾯代码的演⽰的对⽐差异。
cpp
#include<unordered_set>
#include<unordered_map>
#include<set>
#include<iostream>
using namespace std;
int test_set2()
{
const size_t N = 1000000;
unordered_set<int> us;
set<int> s;
vector<int> v;
v.reserve(N);
srand(time(0));
for (size_t i = 0; i < N; ++i)
{
//v.push_back(rand()); N⽐较⼤时，重复值⽐较多，因为rand最多生成3万多种数据
v.push_back(rand() + i); // 重复值相对少
//v.push_back(i); // 没有重复，有序
}
size_t begin1 = clock();
for (auto e : v)
{
s.insert(e);
}
size_t end1 = clock();
cout << "set insert:" << end1 - begin1 << endl;
size_t begin2 = clock();
us.reserve(N);
for (auto e : v)
{
us.insert(e);
}
size_t end2 = clock();
cout << "unordered_set insert:" << end2 - begin2 << endl;
int m1 = 0;
size_t begin3 = clock();
for (auto e : v)
{
auto ret = s.find(e);
if (ret != s.end())
{
++m1;
}
}
size_t end3 = clock();
cout << "set find:" << end3 - begin3 << "->" << m1 << endl;
int m2 = 0;
size_t begin4 = clock();
for (auto e : v)
{
auto ret = us.find(e);
if (ret != us.end())
{
++m2;
}
}
size_t end4 = clock();
cout << "unorered_set find:" << end4 - begin4 << "->" << m2 << endl;
cout << "插入数据个数：" << s.size() << endl;
cout << "插入数据个数：" << us.size() << endl << endl;
size_t begin5 = clock();
for (auto e : v)
{
s.erase(e);
}
size_t end5 = clock();
cout << "set erase:" << end5 - begin5 << endl;
size_t begin6 = clock();
for (auto e : v)
{
us.erase(e);
}
size_t end6 = clock();
cout << "unordered_set erase:" << end6 - begin6 << endl << endl;
return 0;
}
int main()
{
test_set2();
return 0;
}运行结果：
结果分析：
1、所有情况都是unorder_set的find效率比set效率高很多，insert和erase也是unorder_set更高，但是差距不明显。
2、当数据重复值较多时，unorder_set和set的效率差距更明显，因为insert不是重复值时unorder_set和set都要new结点，new结点的开销不小所以当数据重复值较少时insert操作两者差不多，但是当重复值多时insert基本就不会插入新节点了，只要find到了有重复的值就过，所以insert主要就看find的效率了，而unorder_set的find效率比set效率高很多，所以当数据重复值较多时，unorder_set和set的效率差距更明显。erase还是unorder_set更块。
3、当数据有序时set的insert和erase效率甚至比unorder_set还高，因为有序时set底层红黑树一直朝一个方向旋转，左右子树高度相差不大，更均匀。
unordered_map和map的使⽤差异
• 查看⽂档我们会发现unordered_map的⽀持增删查改且跟map的使⽤⼀模⼀样，关于使⽤我们这⾥就不再赘述和演⽰了。
• unordered_map和map的第⼀个差异是对key的要求不同，map要求Key⽀持⼩于⽐较，⽽unordered_map要求Key⽀持转成整形且⽀持等于⽐较，要理解unordered_map的这个两点要求
得后续我们结合哈希表底层实现才能真正理解，也就是说这本质是哈希表的要求。
• unordered_map和map的第⼆个差异是迭代器的差异，map的iterator是双向迭代器，
unordered_map是单向迭代器，其次map底层是红⿊树，红⿊树是⼆叉搜索树，⾛中序遍历是有序的，所以map迭代器遍历是Key有序+去重。⽽unordered_map底层是哈希表，迭代器遍历是Key⽆序+去重。
• unordered_map和map的第三个差异是性能的差异，整体⽽⾔⼤多数场景下，unordered_map的增删查改更快⼀些，因为红⿊树增删查改效率是，⽽哈希表增删查平均效率是 ，具体可以参看下⾯代码的演⽰的对⽐差异。
unordered_xxx的哈希相关接⼝
Buckets和Hash policy系列的接⼝分别是跟哈希桶和负载因⼦相关的接⼝，⽇常使⽤的⻆度我们不需要太关注，后⾯掌握了哈希表底层，我们再来看这个系列的接⼝，⼀⽬了然。
二、哈希表实现
哈希概念
哈希(hash)⼜称散列，是⼀种组织数据的⽅式。从名字来看，有散乱排列的意思。本质就是通过哈希函数把关键字Key跟存储位置建⽴⼀个映射关系，查找时通过这个哈希函数计算出Key存储的位置，进⾏快速查找。
直接定址法
当关键字的范围⽐较集中时，直接定址法就是⾮常简单⾼效的⽅法，⽐如⼀组关键字都在[0,99]之间，那么我们开⼀个100个数的数组，每个关键字的值直接就是存储位置的下标。再⽐如⼀组关键字值都在[a,z]的⼩写字⺟，那么我们开⼀个26个数的数组，每个关键字acsii码-a
ascii码就是存储位置的下标。也就是说直接定址法本质就是⽤关键字计算出⼀个绝对位置或者相对位置。所以直接定址法只适用于范围集中的整数。
哈希冲突
直接定址法的缺点也⾮常明显，当关键字的范围⽐较分散时，就很浪费内存甚⾄内存不够⽤。假设我们只有数据范围是[0, 9999]的N个值，我们要映射到⼀个M个空间的数组中(⼀般情况下M >= N)，那么就要借助哈希函数(hash function)hf，关键字key被放到数组的h(key)位置，这⾥要注意的是h(key)计算出的值必须在[0, M)之间。
这⾥存在的⼀个问题就是，两个不同的key可能会映射到同⼀个位置去，这种问题我们叫做哈希冲突，或者哈希碰撞。理想情况是找出⼀个好的哈希函数避免冲突，但是实际场景中，冲突是不可避免的，所以我们尽可能设计出优秀的哈希函数，减少冲突的次数，同时也要去设计出解决冲突的⽅案。
负载因⼦
假设哈希表中已经映射存储了N个值，哈希表的⼤⼩为M，那么 ，负载因⼦有些地⽅ 也翻译为载荷因⼦/装载因⼦等，他的英⽂为load factor。负载因⼦越⼤，哈希冲突的概率越⾼，空间利⽤率越⾼；负载因⼦越⼩，哈希冲突的概率越低，空间利⽤率越低。
将关键字转为整数
我们将关键字映射到数组中位置，⼀般是整数好做映射计算，如果不是整数，我们要想办法转换成整数，这个细节我们后⾯代码实现中再进⾏细节展⽰。下⾯哈希函数部分我们讨论时，如果关键字不是整数，那么我们讨论的Key是关键字转换成的整数。
哈希函数
⼀个好的哈希函数应该让N个关键字被等概率的均匀的散列分布到哈希表的M个空间中，但是实际中却很难做到，但是我们要尽量往这个⽅向去考量设计。
除法散列法/除留余数法
- 除法散列法也叫做除留余数法，顾名思义，假设哈希表的⼤⼩为M，那么通过key除以M的余数作为映射位置的下标，也就是哈希函数为：h(key) = key % M。 • 当使⽤除法散列法时，要尽量避免M为某些值，如2的幂，10的幂等。如果是 2^X，那么key %2^X本质相当于保留key的二进制后X位，(只有二进制的后x位参与了运算)那么后x位相同的值，计算出的哈希值都是⼀样的，就冲突了。如：{63 , 31}看起来没有关联的值，如果M是16，也就是 2^4，那么计算出的哈希值都是15，(63%16==15,31%16==15)因为63的⼆进制后8位是 00111111，31的⼆进制后8位是 00011111。如果是 10^X，就更明显了，保留的都是10进值的后x位，(只有十进制的后x位参与了运算)如：{112, 12312}，如果M是100，也就是10^2 ，那么计算出的哈希值都是12。再比如M = 10(10^1)，十进制末尾 1 位，key1 = 25（末尾 1 位 5），25 % 10 = 5。key2 = 115（末尾 1 位 5），115 % 10 = 5，计算出的哈希值都是5。
- 当使⽤除法散列法时，建议M取不太接近2的整数次幂的⼀个质数(素数)。比如11，13。
- 需要说明的是，实践中也是⼋仙过海，各显神通，Java的HashMap采⽤除法散列法时就是2的整数次幂做哈希表的⼤⼩M，这样玩的话，就不⽤取模，⽽可以直接位运算，相对⽽⾔位运算⽐模更⾼效⼀些。但是他不是单纯的去取模，⽐如M是2^16次⽅，本质是取后16位，那么⽤key' =key>>16，(key'是key的二进制右移16位的结果，相当于去掉后16位，保留前面)然后把key和key' 异或的结果作为哈希值。也就是说我们映射出的值还是在[0,M)范围内，但是尽量让key所有的位都参与计算，这样映射出的哈希值更均匀⼀些即可。所以我们上⾯建议M取不太接近2的整数次幂的⼀个质数的理论也只是一个可以参考的理论，在实践中，需要我们灵活运⽤，抓住本质。
乘法散列法
- 乘法散列法对哈希表⼤⼩M没有要求，他的⼤思路第⼀步：⽤关键字 K 乘上常数 A (0<A<1)，并抽取出 kA 的⼩数部分。第⼆步：后再⽤M乘以kA 的⼩数部分，再向下取整。
- h(key) = floor(M × ((A × key)%1.0))，其中floor表⽰对表达式进⾏下取整，A∈(0,1)，这⾥最重要的是A的值应该如何设定，Knuth认为
(⻩⾦分割点])⽐较好。h(key) = floor(M × ((A × key)%1.0))A = ( 5 − 1)/2 =
0.6180339887...- 乘法散列法对哈希表⼤⼩M是没有要求的，假设M为1024，key为1234，A = 0.6180339887, Akey= 762.6539420558，取⼩数部分为0.6539420558, M×((A×key)%1.0) = 0.65394205581024 =669.6366651392，那么h(1234) = 669。
处理哈希冲突
实践中哈希表⼀般还是选择除法散列法作为哈希函数，当然哈希表⽆论选择什么哈希函数也避免不了冲突，那么插⼊数据时，如何解决冲突呢？主要有两种两种⽅法，开放定址法和链地址法。
开放定址法
在开放定址法中所有的元素都放到哈希表⾥，当⼀个关键字key⽤哈希函数计算出的位置冲突了，则按照某种规则找到⼀个没有存储数据的位置进⾏存储，开放定址法中负载因⼦⼀定是⼩于的。这⾥的规则有三种：线性探测、⼆次探测、双重探测。（开放定址法的哈希函数我们用除法散列法来实现）
线性探测
- 从发⽣冲突的位置开始，依次线性向后探测，直到寻找到下⼀个没有存储数据的位置为⽌，如果⾛到哈希表尾，则回绕到哈希表头的位置。
- 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位置，这种现象叫做群集/堆积。后面介绍的⼆次探测可以⼀定程度改善这个问题。
- 下⾯演⽰ {19,30,5,36,13,20,21,12} 等这⼀组值映射到M=11的表中。
开放定址法代码实现
开放定址法在实践中，不如下⾯讲的链地址法，因为开放定址法解决冲突不管使⽤哪种⽅法，占⽤的都是哈希表中的空间，始终存在互相影响的问题。所以开放定址法，我们简单选择线性探测实现即可。
这里有一个坑，查找逻辑是从发生冲突的位置依次向后找，找到空位置表示找不到了就停止查找，但是这个查找逻辑只有哈希表没有删除过数据时有效。所以这⾥需要给每个存储值的位置加⼀个状态标识，否则删除⼀些值以后，会影响后⾯冲突的值的查找。比如一开始的示意图，我们删除30，会导致查找20失败，当我们给每个位置加⼀个状态标识{EXIST,EMPTY,DELETE}
，删除30就可以不⽤删除值，⽽是把状态改为 DELETE ，那么查找20时是遇到 EMPTY 才能终止，就可以找到20。
开放定址法的哈希表结构
cpp
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
{
public:
private:
vector<HashData<K, V>> _tables;
size_t _n = 0; // 表中散列存储数据个数
};插入
插入有两个点需要注意，第一是在计算插入位置时key应该模底层vector的size而不是capacity，因为模capacity后得到的位置可能越界，插入操作要调用operator[]，而operator[]有严格的越界检查。所以我们实现哈希表时尽量让底层vector的size和capacity相差不要太大。
第二是插入的扩容操作不能单纯扩容，除了扩容之外还需要把数据重新映射一遍，因为扩容后除留余数的那个除数要随着空间的变化而变化，这里重新映射有一个偷鸡思路，就是复用插入的非扩容部分代码，(新表重新映射调用insert时不会触发扩容)先创建一个扩容后的新表，然后遍历旧表依次把旧表的数据插入到新表，最后交换新表和旧表就完成了扩容操作。
插入思路是先计算插入位置hash0，如果插入位置为EXIST需要线性探测找到不为EXIST的位置hash1，把值插入到hash1，再把hash1置为EXIST，最后_n++。
cpp
bool Insert(const pair<K, V>& kv)
{
//扩容
if ((double)_n / (double)_tables.size() >= 0.7)
{
HashTable<int, int> newht(2 * _tables.size());
//遍历旧表重新映射到新表
for (int i = 0; i < _tables.size(); i++)
{
newht.Insert(_tables[i]._kv);
}
_tables.swap(newht._tables); //现代写法
}
size_t hash0 = kv.first % _tables.size();
size_t hashi = hash0;
size_t i = 0;
//线性探测
while (_tables[hashi]._state == EXIST) //为EXIST继续探测找空位
{
hashi = (hash0 + i) % _tables.size();
i++;
}
_tables[hashi]._kv = kv;
_tables[hashi]._state = EXIST;
_n++;
return true;
}上面的扩容方法存在一个问题，就是我们还是按照2倍扩容，但是同时我们要保持哈希表⼤⼩是⼀个质数，第⼀个是质数，2倍后就不是质数了。那么如何解决呢，⼀种⽅案是sgi版本的哈希表使⽤的⽅法，给了⼀个近似2倍的质数表，每次去质数表获取扩容后的⼤⼩。
lower_bound是算法库里的一个函数，作用是在一段迭代器区间内找大于等于n的值。
cpp
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
};
inline unsigned long __stl_next_prime(unsigned long n)
{
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);
//当pos等于last也就是end()时返回数组最后一个值也就是429...
return pos == last ? *(last - 1) : *pos;
}
HashTable(size_t size = __stl_next_prime(0))
:_tables(size)
, _n(0)
{}
bool Insert(const pair<K, V>& kv)
{
//扩容
if ((double)_n / (double)_tables.size() >= 0.7)
{
HashTable<int, int> newht(__stl_next_prime(_tables.size() + 1));
//遍历旧表重新映射到新表
for (int i = 0; i < _tables.size(); i++)
{
newht.Insert(_tables[i]._kv);
}
_tables.swap(newht._tables); //现代写法
}
size_t hash0 = kv.first % _tables.size();
size_t hashi = hash0;
size_t i = 0;
//线性探测
while (_tables[hashi]._state == EXIST) //为EXIST继续探测找空位
{
hashi = (hash0 + i) % _tables.size();
i++;
}
_tables[hashi]._kv = kv;
_tables[hashi]._state = EXIST;
_n++;
return true;
}查找
查找操作返回的是DashData的指针，所以查找还可以充当修改的功能。
查找思路是先计算出待找值的位置，如果该位置值和待找值不同，需要继续往后线性探测，找到空为止，如果找到了就返回该位置的地址，如果找到空都没找到就返回nullptr。
cpp
HashData<K, V>* Find(const K& key)
{
size_t hash0 = key % _tables.size();
size_t hashi = hash0;
size_t i = 0;
//线性探测
while (_tables[hashi]._state != EMPTY) //不为空继续往后找
{
//若hash1值等于key且状态为EXIAT则找到了
if (_tables[hashi]._kv.first == key && _tables[hashi]._state != DELETE)
{
return &_tables[hashi];
}
hashi = (hash0 + i) % _tables.size();
i++;
}
return nullptr;
}删除
删除操作很简单，直接复用find，如果没找到直接返回false，找到了把该位置状态置为DELETE再返回true。
cpp
bool Erase(const K& key)
{
HashData<K, V>* ret = Find(key);
if (ret) //找到了，就把状态置为DELETE
{
ret->_state = DELETE;
return true;
}
else
{
return false;
}
}key不能取模的问题
当key是string/Date等类型时，key不能取模，那么我们需要给HashTable增加⼀个仿函数，这个仿函数⽀持把key转换成⼀个可以取模的整形，如果key可以转换为整形并且不容易冲突，比如浮点数，指针，负数，那么这个仿函数就⽤默认参数强转为size_t即可，如果这个Key不能转换为整形，我们就需要⾃⼰实现⼀个仿函数传给这个参数，实现这个仿函数的要求就是尽量key的每个值都参与到计算中，让不同的key转换出的整形值不同。string做哈希表的key⾮常常⻅，所以我们可以考虑把string特化一下，仿函数特化版思路是把string每个字符的ASCII码累加起来参与除留余数的计算。这里我们不考虑累加后结果会溢出的情况，因为我们只是想要一个对应参数的无符号整型值参与哈希映射计算，只要insert和find这个参数通过仿函数计算出的都是同一个无符号整型值就可以达到哈希表的功能。
有了仿函数后需要更改hashtable里insert和find的除法计算hash0位置的代码，把除数套一个仿函数。
cpp
template<class K>
struct HashFunc
{
size_t operator()(const K& k)
{
return size_t(k);
}
};
template<>
struct HashFunc<string>
{
size_t operator()(const string& str)
{
size_t hashi = 0;
for (auto e : str)
{
hashi += e;
}
return hashi;
}
};上面的srring计算哈希值还存在一定问题，当遇到例如"abcd"和"dcba"这样的只是顺序不同的字符串时就会冲突，这个问题前辈们研究出了BKDRhash算法来解决，我们也借用前辈的智慧，思路是每加一个新字符值之前都先把之前算出的结果hashi乘一个基数例如131、1313、13131，这样就可以最大程度的避免冲突。
cpp
size_t operator()(const string& str)
{
size_t hashi = 0;
for (auto e : str)
{
hashi *= 131;
hashi += e;
}
return hashi;
}开发定址法代码
cpp
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
};
inline unsigned long __stl_next_prime(unsigned long n)
{
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; //当pos取end()时返回数组最后一个值也就是429...
}
enum State
{
EXIST,
EMPTY,
DELETE
};
template<class K, class V>
struct HashData
{
pair<K, V> _kv;
State _state = EMPTY;
};
template<class K>
struct HashFunc
{
size_t operator()(const K& k)
{
return size_t(k);
}
};
template<>
struct HashFunc<string>
{
size_t operator()(const string& str)
{
size_t hashi = 0;
for (auto e : str)
{
hashi *= 131;
hashi += e;
}
return hashi;
}
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
public:
HashTable(size_t size = __stl_next_prime(0))
:_tables(size)
{}
bool Insert(const pair<K, V>& kv)
{
//扩容
if ((double)_n / (double)_tables.size() >= 0.7)
{
HashTable<K, V, Hash> newht(__stl_next_prime(_tables.size() + 1));
//遍历旧表重新映射到新表
for (size_t i = 0; i < _tables.size(); i++)
{
newht.Insert(_tables[i]._kv);
}
_tables.swap(newht._tables); //现代写法
}
Hash hs;
size_t hash0 = hs(kv.first) % _tables.size();
size_t hashi = hash0;
size_t i = 1;
//线性探测
while (_tables[hashi]._state == EXIST) //为EXIST继续探测找空位
{
hashi = (hash0 + i) % _tables.size();
i++;
}
_tables[hashi]._kv = kv;
_tables[hashi]._state = EXIST;
_n++;
return true;
}
HashData<K, V>* Find(const K& key)
{
Hash hs;
size_t hash0 = hs(key) % _tables.size();
size_t hashi = hash0;
size_t i = 1;
//线性探测
while (_tables[hashi]._state != EMPTY) //不为空继续往后找
{
//若hash1值等于key且状态为EXIAT则找到了
if (_tables[hashi]._kv.first == key && _tables[hashi]._state != DELETE)
{
return &_tables[hashi];
}
hashi = (hash0 + i) % _tables.size();
i++;
}
return nullptr;
}
bool Erase(const K& key)
{
HashData<K, V>* ret = Find(key);
if (ret) //找到了，就把状态置为DELETE
{
ret->_state = DELETE;
return true;
}
else
{
return false;
}
}
private:
vector<HashData<K, V>> _tables;
size_t _n = 0; // 表中散列存储的数据个数
};链地址法
解决冲突的思路
开放定址法中所有的元素都放到哈希表⾥，链地址法中所有的数据不再直接存储在哈希表中，哈希表中存储⼀个指针，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成⼀个链表，挂在哈希表这个位置下⾯，该位置指针指向这个链表，链地址法也叫做拉链法或者哈希桶。
链地址法的哈希表结构
我们创建哈希表结构时采用指针数组的方式vector<Node*>而不是vector< list >，虽然这两种方法都能实现，但是第一种方法利于后面我们用哈希表封装unordered_map和unordered_set。
cpp
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 HashTable
{
typedef HashNode<K, V> Node;
public:
//HashTable() //该默认构造也可以
// :_table(__stl_next_prime(0), nullptr)
//{}
HashTable(size_t size = __stl_next_prime(0))
:_table(size, nullptr)
{}
private:
vector<Node*> _table;
size_t _n = 0;
};析构
链地址法的哈希表因为每个结点都是自己new的，所以需要自己释放资源，把每个桶结点释放完毕后还要把vector对应位置置为空，vector不用自己显示写析构，因为自定义类型会去调用它的析构。
cpp
~HashTable()
{
for (int i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
while (cur)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_table[i] = nullptr;
}
}插入
插入也可以像开放定址法那样复用插入的代码，但是在这里不是最优的，开放定址法时因为地址开好后只用把数据拷贝到新表就行了，但是这里如果复用插入代码就会重新new结点，并且释放旧结点。所以这里的最优思路是遍历旧表依次把旧表结点拿下来映射到新表，这样就节省了重新new结点的开销，并且旧链表的资源都被挪到新链表了，交换后也不用释放旧链表的资源。
注意开放定址法时扩容因为要复用插入代码所以是新开的一个完整的hashtable,而这里只用开一个vector<Node*> 就行了。
cpp
bool Insert(const pair<K, V> kv)
{
if (Find(kv.first)) //不允许冗余
return false;
//扩容
if (_n == _table.size()) //负载因子为1时触发扩容
{
vector<Node*> newtable(__stl_next_prime(_table.size() + 1), nullptr);
for (size_t i = 0; i < _table.size(); i++) //遍历旧表
{
Node* cur = _table[i];
while (cur) //cur不会空时依次取该桶元素重新映射到新表
{
Node* next = cur->_next; //提前保存
size_t hashi = cur->_kv.first % newtable.size();
//将遍历到的值头插到新表
cur->_next = newtable[hashi];
newtable[hashi] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(newtable);
}
size_t hashi = kv.first % _table.size();
Node* newnode = new Node(kv);
//头插
newnode->_next = _table[hashi]; //_table[hashi]存的链表头结点指针
_table[hashi] = newnode;
++_n;
return true;
}查找
查找很简单，遍历key所对应的桶，如果找到了返回该结点指针，如果没找到返回nullptr。
cpp
Node* Find(const K& key)
{
size_t hashi = key % _table.size();
Node * cur = _table[hashi];
while (cur)
{
if (cur->_kv.first == key)
return cur;
cur = cur->_next;
}
return nullptr;
}删除
这里删除不能复用find，因为我们实现的哈希桶是单链表，删除结点时需要该结点的prev结点，所以我们只能把find的逻辑重写一遍，还需要创建一个prev指针记录cur的上一结点。若删除结点在链表的中间位置直接删就行了，如果删除结点是链表的头结点需要特殊处理，因为这时prev是空指针，处理思路是让_table[hashi]指向头结点的下一结点就行了。删除后注意还要--_n。
cpp
bool Erase(const K& key)
{
size_t hashi = key % _table.size();
Node* prev = nullptr;
Node* cur = _table[hashi];
while (cur)
{
if (cur->_kv.first == key)
{
//若key在桶的链表头结点
if (cur == _table[hashi])
{
_table[hashi] = cur->_next;
}
else
{
prev->_next = cur->_next;
}
delete cur;
--_n;
return true;
}
prev = cur;
cur = cur->_next;
}
return false;
}key不能取模的问题
这里解决思路和前面一样，取模哪里套一层仿函数就行了。
链地址法代码
cpp
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 size = __stl_next_prime(0))
:_tables(size)
{
}
bool Insert(const pair<K, V>& kv)
{
//扩容
if ((double)_n / (double)_tables.size() >= 0.7)
{
HashTable<K, V, Hash> newht(__stl_next_prime(_tables.size() + 1));
//遍历旧表重新映射到新表
for (size_t i = 0; i < _tables.size(); i++)
{
newht.Insert(_tables[i]._kv);
}
_tables.swap(newht._tables); //现代写法
}
Hash hs;
size_t hash0 = hs(kv.first) % _tables.size();
size_t hashi = hash0;
size_t i = 1;
//线性探测
while (_tables[hashi]._state == EXIST) //为EXIST继续探测找空位
{
hashi = (hash0 + i) % _tables.size();
i++;
}
_tables[hashi]._kv = kv;
_tables[hashi]._state = EXIST;
_n++;
return true;
}
HashData<K, V>* Find(const K& key)
{
Hash hs;
size_t hash0 = hs(key) % _tables.size();
size_t hashi = hash0;
size_t i = 1;
//线性探测
while (_tables[hashi]._state != EMPTY) //不为空继续往后找
{
//若hash1值等于key且状态为EXIAT则找到了
if (_tables[hashi]._kv.first == key && _tables[hashi]._state != DELETE)
{
return &_tables[hashi];
}
hashi = (hash0 + i) % _tables.size();
i++;
}
return nullptr;
}
bool Erase(const K& key)
{
HashData<K, V>* ret = Find(key);
if (ret) //找到了，就把状态置为DELETE
{
ret->_state = DELETE;
return true;
}
else
{
return false;
}
}
private:
vector<HashData<K, V>> _tables;
size_t _n = 0; // 表中散列存储的数据个数
};
}
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() //该默认构造也可以
// :_table(__stl_next_prime(0), nullptr)
//{}
HashTable(size_t size = __stl_next_prime(0))
:_table(size, nullptr)
{
}
~HashTable()
{
for (int i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
while (cur)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_table[i] = nullptr;
}
}
bool Insert(const pair<K, V>& kv)
{
if (Find(kv.first)) //不允许冗余
return false;
Hash hf;
//扩容
if (_n == _table.size()) //负载因子为1时触发扩容
{
vector<Node*> newtable(__stl_next_prime(_table.size() + 1), nullptr);
for (size_t i = 0; i < _table.size(); i++) //遍历旧表
{
Node* cur = _table[i];
while (cur) //cur不会空时依次取该桶元素重新映射到新表
{
Node* next = cur->_next; //提前保存
size_t hashi = hf(cur->_kv.first) % newtable.size();
//将遍历到的值头插到新表
cur->_next = newtable[hashi];
newtable[hashi] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(newtable);
}
size_t hashi = hf(kv.first) % _table.size();
Node* newnode = new Node(kv);
//头插
newnode->_next = _table[hashi]; //_table[hashi]存的链表头结点指针
_table[hashi] = newnode;
++_n;
return true;
}
Node* Find(const K& key)
{
Hash hf;
size_t hashi = hf(key) % _table.size();
Node * cur = _table[hashi];
while (cur)
{
if (cur->_kv.first == key)
return cur;
cur = cur->_next;
}
return nullptr;
}
bool Erase(const K& key)
{
Hash hf;
size_t hashi = hf(key) % _table.size();
Node* prev = nullptr;
Node* cur = _table[hashi];
while (cur)
{
if (cur->_kv.first == key)
{
//若key在桶的链表头结点
if (cur == _table[hashi])
{
_table[hashi] = cur->_next;
}
else
{
prev->_next = cur->_next;
}
delete cur;
--_n;
return true;
}
prev = cur;
cur = cur->_next;
}
return false;
}
private:
vector<Node*> _table;
size_t _n = 0;
};以上就是小编分享的全部内容了，如果觉得不错还请留下免费的关注和收藏
如果有建议欢迎通过评论区或私信留言，感谢您的大力支持。
一键三连好运连连哦~~
