【C++ 第十六章】哈希
1. unordered系列关联式容器
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 ，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好 的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个 unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是 其底层结构不同，本文中只对unordered_map和unordered_set进行介绍， unordered_multimap和unordered_multiset学生可查看文档介绍
⭐小结：之前学的 map 和 set 底层是 红黑树，查找效率 O(logN)， 下面即将学的 unordered_map和unordered_set 底层是 哈希，查找效率 O(1)
1.1 unordered_map
1.1.1 unordered_map的文档介绍
unordered_map在线文档说明
1. unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与 其对应的value。
2. 在unordered_map中，键值通常用于唯一地标识元素，而映射值是一个对象，其内容与此 键关联。键和映射值的类型可能不同。
3. 在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内 找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问 value。
6. 它的迭代器至少是前向迭代器
⭐小结：unordered_map 没有排序，查询元素效率 O(1)，遍历元素效率较低
1.2 unordered_set
这个没有什么特别的地方，如有需要自行查询文档，进一步了解
参见 unordered_set在线文档说明
2. 底层结构
unordered 系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。
2.1 哈希概念
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素 时，必须要经过关键码的多次比较。顺序查找时间复杂度为 O(N)，平衡树中为树的高度，即 O(logN)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立 一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
- 插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
- 搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置 取元素比较，若关键码相等，则搜索成功
⭐小结：通过 哈希函数 将数据的 key 值计算成某一数值，作为存储在哈希表中的位置，以确定插入位置；同理，通过哈希函数，计算出目标元素所在位置，以搜索元素
⭐该方式即为哈希（散列）方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表（Hash Table）（或者称散列表）
例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity 为存储元素底层空间总的大小。
通过哈希函数，将数据变成另一个值，该值即为存储位置下标
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快（因为搜索元素也是直接通过哈希函数计算 数据的存储位置下标直接可以取到 数据）
问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？
会产生 哈希冲突
2.2 哈希冲突
概念：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突 或哈希碰撞
⭐即：数据 23，33 通过哈希函数 hash(key) = key % capacity（capacity==10）算出来的下标都是 3，因此两个数据会抢同一个位置
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
发生哈希冲突该如何处理呢？
2.3 哈希函数
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。
2.3.1 哈希函数设计原则：
1、哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值 域必须在0到m-1之间
2、哈希函数计算出来的地址能均匀分布在整个空间中
3、哈希函数应该比较简单
2.3.2 常见哈希函数
⭐1. 直接定址法--(常用)
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
优点：简单、均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况
⭐2. 除留余数法--(常用)
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数， 按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址
意思是：数据的 key 值 除于 哈希表的 size，得出来的即为 下标
3. 平方取中法--(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址
平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
4. 折叠法--(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这 几部分叠加求和，并按散列表表长，取后几位作为散列地址。 折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
5. 随机数法--(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中 random为随机数函数。
通常应用于关键字长度不等时采用此法
⭐注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突
2.4 除留余数法的缺陷解决
哈希函数采用 除留余数法，被模的 key 必须要为整形才可以进行，非整形数据必须想方法转换成整型或创造一个整型数据
都写成仿函数
（1）非 size_t 的内置类型
如果是非 size_t 的内置类型，可以直接强制类型转换
template<class K>
class HashFunc
{
public:
size_t operator()(const K& key) {
return (size_t)key; // 强转后返回
}
};（2）string 类型
如果是 string 字符串类型，无法强转类型
将字符串的每个字符的 ASCLII 码值相加起来，但这样还是不可完全避免冲突
如 abc 和 cba 的 ASCII码值总和是相等的，则 n 相等，取模之后也就冲突
缓解冲突的一个方法：每一个字符都相乘一个 31（使最后的总数不同）
因为 string 的类型特殊，我们直接 特化模板
// 针对 string 特化一个 哈希函数：特化模板也算作 HashFunc模板，则使用string时，不用显式传仿函数参数，因为默认 HashFunc<K>
template<>
class HashFunc<string>
{
public:
size_t operator()(const string& s) {
size_t n = 0;
for (auto& ch : s) {
n += ch; // 将字符串的每个字符的ASCLII码值相加起来
n *= 31; // 每一个字符都相乘一个 31
}
return n;
}
};
（3）自定义的类型
如果是自定义的类型，也无法强转
如果 key 是一个自定义类型，就需要你自己写一个仿函数，且使自定义类型具有唯一标识性，如key == 一个人名，可以转换成：人名+岁数+生日日期+... 使该数值唯一性提高
2.5 哈希冲突解决
解决哈希冲突两种常见的方法是：闭散列和开散列
闭散列：开放定址法（位置被占了，寻找下一个位置）
寻找方法：线性探测 / 二次探测
开散列：哈希桶 / 拉链法
2.5.1 闭散列
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有 空位置，那么可以把 key 存放到冲突位置中的 “ 下一个” 空位置中去。
那如何寻找下一个空位置 呢？
（1） 线性探测：插入元素
比如 现在需要插入元素 44，先通过哈希函数计算哈希地址，下标地址 为 4， 因此 44 理论上应该插在该位置，但是该位置已经放了值为 4 的元素，即发生哈希冲突。
线性探测：从发生冲突的位置开始，依次向后 + 1 探测，直到寻找到下一个空位置为止
（2）线性探测：删除 或 查找数据
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素 会影响其他元素的搜索。比如删除元素 5，如果直接删除掉，会使 44 查找起来可能会受影响。因为查找逻辑是：先通过哈希函数得出下标位置 4，该位置上为 元素 4，则继续向后寻找 44，遇到 空 停止（位置 5 为空），导致在此停下，而不会继续往后搜索；
因此线性探测采用标记的伪删除法来删除一个元素：将删除位置标记成 DELETE、空位置标记成 EMPTY
// 哈希表每个空间给个标记
// EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE};（3） 闭散列方法下，哈希表的 扩容时机
定义 负载因子！（也叫载荷因子）
考虑扩容：当 负载因子 大于等于 70% 时，哈希冲突会增加（科学研究），因此选择此时扩容
if (_n / _table.size() >= 0.7)
_n 是填入表中的元素个数，_table.size() 是表的长度，相除得 载荷因子
因为两个 size_t 相除的结果不会是浮点数，因此可以强转成 double，或者巧妙解决
if (_n*10 / _tables.size() >= 7)伪代码：具体代码在后面 【线性探测法具体代码】的 insert 函数中
// if (_n / _table.size() >= 0.7)
if (_n * 10 / _tables.size() >= 7) {
定义两倍空间大小的新哈希表：直接定义新对象
循环遍历旧表，将旧表的每个元素重新映射到新表：newTable.Insert(旧表元素)
直接将旧表和新表 swap 互换
}线性探测优点：实现非常简单
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同 关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。
如何缓解呢？
（4） 二次探测
线性探测是每次 +1、+2、+3.....， 二次探测是每次 +1^2 、+2^2 、+3^2 、..... i ^ 2
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法：大跨步往后走
2.5.2 开散列
（1）开散列概念
开散列法又叫链地址法(拉链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
⭐小结：拉链法顾名思义，每一个数组元素位置都链接一个 单链表，每一个经过哈希函数转化后位置相同的数据，可以直接链接在 单链表上，这样就避免了像 闭散列 那样数据拥堵往后挤的现象
如元素 4 和 元素44 本来会 “抢”一个位置，导致冲突，而拉链法是两者得以 “共享” 同一位置
（2）拉链法：扩容
桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希 表进行增容，那该条件怎么确认呢？
开散列最好的情况是：每个哈希桶中刚好挂一个节点， 再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容， 即载荷因子 == 1。
⭐伪代码：
// 考虑扩容：当负载比率为 1 时，扩容（即 n == size）
// 甚至可以大于 1，即理想情况下，就是平均每个桶有 1个以上
if (_n == _table.size()) {
创建两倍旧表 size 的新表对象
遍历旧表，将每个有效的链表节点，重新映射到 新表（直接将旧表节点 移接到新表，而不是 Insert新值）
交换旧表和新表
}（注意：这里要直接将旧表节点直接摘下来，移位到新表，而不是将节点数据直接 Insert 进新表，直接 Insert进新表需要重新 new 和 delete 新节点，多少影响效率）
2.5.3 开散列与闭散列比较
闭散列应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。
事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。
3. 【实现哈希结构】开放定址法：线性探测法+除留余数法
namespace open_address { enum State { EXIST, EMPTY, DELETE }; // 定义数据信息：数值+状态 template<class K, class V> struct HashData { pair<K, V>_data; State _state = EMPTY; // 一个节点默认为空状态 }; // 哈希函数：为了将 key 值转换为整型，适配除留余数法 template<class K> class HashFunc { public: size_t operator()(const K& key){ return (size_t)key; } }; // 哈希函数特化：针对 string 特化一个 哈希函数 template<> class HashFunc<string> { public: size_t operator()(const string& s) { size_t n = 0; for (auto& ch : s) { n += ch; // 将字符串的每个字符的ASCLII码值相加起来，但这样还是不可完全避免冲突，如 abc 和 cba 的 ASCII码值总和是相等的，则 n 相等，取模之后也就冲突 // 缓解冲突的一个方法：每一个字符都相乘一个 31 n *= 31; } return n; } }; // 哈希表：接收数据类型和哈希函数 Hash template<class K, class V, class Hash = HashFunc<K>> class HashTable { public: // 先开 10 个元素空间 HashTable() { _tables.resize(10); // 使用 resize 是为了尽量将 size 和 capacity 保持一致 } bool Insert(const pair<K, V>& data) { // 考虑冗余 if (Find(data.first)) { cout << "该节点已存在" << '\n'; return false; } // 考虑扩容：当负载因子个数在表中占比大于等于 70% 时，哈希冲突会增加，因此选择此时扩容 // if (_n / _table.size() >= 0.7) if (_n*10 / _tables.size() >= 7) { // 扩容：因为将旧数据重新映射，就是重新执行插入操作，需要再次写一遍 插入操作逻辑，比较重复，因此我们下面直接使用 复用思想：直接定义新对象（编译器底层重开新模板） // 思路： //vector<HashData> newTable(_table.size() * 2); 将旧表数据重新映射到新表：因为 size 变了，映射关系也变了 //_table.swap(newTable); HashTable<K, V> newTable; newTable._tables.resize(_tables.size() * 2); for (size_t i = 0; i < _tables.size(); ++i) { if (_tables[i]._state == EXIST) { newTable.Insert(_tables[i]._data); // 将旧表数据 insert 插入新表 } } _tables.swap(newTable._tables); } // 找一个空位置 size_t hashi = hash(data.first) % _tables.size(); // 除留余数法计数数据存储位置 while (_tables[hashi]._state == EXIST) { hashi++; // 线性探测：找下一个位置 hashi %= _tables.size(); // 限制在一个范围内 } // 插入 _tables[hashi]._data = data; _tables[hashi]._state = EXIST; _n++; return true; } HashData<K, V>* Find(const K& key) { // 看有没有元素的 _data.first == key size_t hashi = hash(key) % _tables.size(); // 除留余数法 while (_tables[hashi]._state != EMPTY) { if (_tables[hashi]._state != DELETE && _tables[hashi]._data.first == key) { return &(_tables[hashi]); } hashi++; hashi %= _tables.size(); } return nullptr; } bool Erase(const K& key) { HashData<K, V>* p = Find(key); if (p == nullptr) { cout << "该节点不存在" << '\n'; return false; } else { p->_state = DELETE; // 删除一个元素：直接将该元素的状态设置成 DELETE，不用抹除数值都可以 return true; } } private: vector<HashData<K, V>>_tables; size_t _n = 0; // 负载因子中的：元素个数 // 先创建一个哈希函数类对象：可以通用 Hash hash; }; // 测试整体 void Test_open1() { HashTable<int, int> ht; int a[] = { 11,21,4,14,24,15,9 }; for (auto e : a) { ht.Insert({ e,e }); } ht.Insert({ 19,19 }); /* ht.Insert({ 19,190 }); ht.Insert({ 19,1900 });*/ ht.Insert({ 39,1900 }); cout << ht.Find(24) << endl; ht.Erase(4); cout << ht.Find(24) << endl; cout << ht.Find(4) << endl; } // 测试 string void Test_open2() { HashTable<string, string> ht; ht.Insert({ "sort", "排序" }); ht.Insert({ "tros", "排序 的字母相反" }); ht.Insert({ "left", "左边" }); //string s1("sort"); //string s2("sort"); cout << HashFunc<string>()("bacd") << endl; cout << HashFunc<string>()("abcd") << endl; cout << HashFunc<string>()("aadd") << endl; } }
4. 【实现哈希结构】开散列：拉链法
节点类 + 哈希函数类 + 哈希表类 + 两个测试函数
namespace hash_bucket
{
template<class K, class V>
struct HashNode {
typedef HashNode<K, V> Node;
pair<K, V> _kv;
Node* _next;
HashNode(const pair<K, V>& kv)
:_kv(kv)
, _next(nullptr)
{}
};
template<class K>
class HashFunc
{
public:
size_t operator()(const K& key) {
return (size_t)key;
}
};
template<>
class HashFunc<string>
{
public:
size_t operator()(const string& s) {
size_t n = 0;
for (auto& ch : s) {
n += ch; // 将字符串的每个字符的ASCLII码值相加起来，但这样还是不可完全避免冲突，如 abc 和 cba 的 ASCII码值总和是相等的，则 n 相等，取模之后也就冲突
// 缓解冲突的一个方法：每一个字符都相乘一个 31
n *= 31;
}
return n;
}
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
typedef HashNode<K, V> Node;
public:
HashTable() {
// 一开始vector里面是随机值，不是 nullptr!! 要自己初始化成 nullptr
_table.resize(10, nullptr);
}
// 本哈希桶需要显式写析构：因为 Node* 是内置类型，只会默认析构成 nullptr，链表节点不会被处理
~HashTable() {
Node* cur = nullptr;
Node* next = nullptr;
for (size_t i = 0; i < _table.size(); ++i) {
cur = _table[i];
while (cur) {
next = cur->_next;
delete cur;
cur = next;
}
}
}
Node* find(const K& key) {
size_t hashi = hash(key) % _table.size(); // 除留余数法 定位
// 定位哈希桶后，遍历这个桶中单链表
Node* cur = _table[hashi];
while (cur) {
if (cur->_kv.first == key) return cur;
cur = cur->_next;
}
return nullptr;
}
bool insert(const pair<K, V>& kv) {
// 考虑冗余
if (find(kv.first)) {
cout << "该数据已存在" << '\n';
return false;
}
// 考虑扩容：当负载比率为 1 时，扩容
if (_n == _table.size()) {
HashTable<K, V> newTable;
newTable._table.resize(2 * _table.size());
// 若直接遍历每个节点，取数值 kv insert 插入新表，会导致频繁的 new 节点，造成一定消耗
// 我们可以直接将旧表的节点 直接转接到 新表，省去new节点的消耗
for (size_t i = 0; i < _table.size(); ++i) {
Node* cur = _table[i];
//
/*while (cur) {
newTable.insert(cur->_kv);
cur = cur->_next;
}*/
while (cur) {
Node* Next = cur->_next;
size_t hashi = hash(cur->_kv.first) % newTable._table.size(); // 除留余数法 重新定位桶的位置
// 将节点转接到新哈希表
cur->_next = newTable._table[hashi];
newTable._table[hashi] = cur;
cur = Next;
}
_table[i] = nullptr;
}
_table.swap(newTable._table);
}
size_t hashi = hash(kv.first) % _table.size();
// 链表头插和尾插都行：头插最方便，尾插还要找尾
Node* newNode = new Node(kv);
newNode->_next = _table[hashi];
_table[hashi] = newNode;
_n++;
return true;
}
bool erase(const K& key) {
if (find(key) == nullptr) {
cout << "该节点不存在" << '\n';
return false;
}
// 删除函数需要自己找目标节点，因为底层是单链表，没有prev，删除不好搞
// 先除留余数法定位桶位置，再遍历链表，删除节点即可
size_t hashi = hash(key) % _table.size();
Node* cur = _table[hashi];
Node* prev = nullptr;
while (cur) {
if (cur->_kv.first == key) {
if (prev == nullptr) _table[hashi] = cur->_next;
else prev->_next = cur->_next;
delete cur;
cur = nullptr;
--_n;
return true;
}
prev = cur;
cur = cur->_next;
}
return false;
}
private:
//也可以使用 list：双向带头循环链表
//vector<list<pair<K, V>>> _table;
vector<Node*> _table;
size_t _n = 0; // 负载因子
Hash hash;
};
void Test_hash_bucket1() {
HashTable<int, int> ht;
int a[] = { 11,21,4,14,24,15,9, 19, 22, 23, 25 };
for (auto e : a)
{
if (e == 23)
int i = 0;
ht.insert({ e,e });
}
// 删除全部
for (auto& e : a) {
if (e == 15)
int i = 0;
ht.erase(e);
}
}
// 测试 string
void Test_hash_bucket2()
{
HashTable<string, string> ht;
ht.insert({ "sort", "排序" });
ht.insert({ "tros", "排序 的字母相反" });
ht.insert({ "left", "左边" });
//string s1("sort");
//string s2("sort");
cout << HashFunc<string>()("bacd") << endl;
cout << HashFunc<string>()("abcd") << endl;
cout << HashFunc<string>()("aadd") << endl;
}
}