【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;
	}
}