手撕哈希表

🌈感谢阅读East-sunrise学习分享——[进阶数据结构]哈希表
博主水平有限，如有差错，欢迎斧正🙏感谢有你
码字不易，若有收获，期待你的点赞关注💙我们一起进步🚀

---

🌈我们上一篇博客分享了优异的数据结构——红黑树
✏️利用红黑树可封装容器set/map，但是由于一些需求，还有一个牛逼的数据结构——哈希表
🚩那就来掌握它吧
开始起飞🚀

一、unordered map/set

以红黑树作为底层实现的map和set已经十分优秀了🎈但是还是诞生了以哈希表作为底层实现的unordered map/set

两者在使用的接口上大致相同，但是也有一些不同的性质

• map和set遍历是有序的，unordered map/set是无序的
• map和set是双向迭代器，而unordered map/set只是单向迭代器

上面列举了这两个不同性质，看上去好像是map和set比较优秀，那为什么还需要提供unordered map/set呢💭

因为当面对大量数据时，增删查改的效率unordered系列更优秀；尤其是查找🚀
因为以搜索树为底层的map和set，在查找时是需要通过比较值的大小去一层层遍历的，而底层使用哈希结构的unordered系列的关联式容器，能够通过映射去快速查找✨✨

---

二、哈希概念

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

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素

如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素

当向该结构插入和搜索时：

• 插入元素：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
• 搜索元素：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

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

🧮🧮🧮🧮🧮

例如：数据集合{1，7，6，4，5，9}；

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

若我们按照哈希函数将元素存储在capacity为10的哈希表中，则各个元素存储位置如下：

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快

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

三、哈希冲突

不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。比如上面我们举例的再插入44，44通过哈希函数计算后，其存储地址和数据4是一样的，这时就产生了哈希冲突

SO what can we do?

---

四、哈希函数

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。

哈希函数设计原则：

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

常见哈希函数

1. 直接定址法–(常用)
   取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B

优点：简单，均匀

缺点：需要事先知道关键字的分布情况

使用场景：适合查找比较小且连续的情况（假如存储元素间隔过大或数值过大，会导致浪费大量空间）

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

优点：不受场景限制

缺点：需要解决哈希冲突，冲突越多，效率越低

3. 平方取中法–(了解)
   假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址

平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

4. 折叠法–(了解)
   折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址

折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

5. 随机数法–(了解)
   选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数

通常应用于关键字长度不等时

6. 数学分析法–(了解)
   设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散 列地址。例如：
   

假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

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

---

五、解决哈希冲突

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

5.1 闭散列

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

1️⃣线性探测
比如上文的情形中，在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

• 插入
  🚩通过哈希函数获取待插入元素在哈希表中的位置

  🚩如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
  

• 删除
  哈希表的查找是出了名的快，查找时根据哈希函数的规则找到位置，而由于使用线性探测，所以可能有的元素并不在其根据哈希函数计算出来的位置上（入上图的元素44）因此当我们删除时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。假如删除元素5，如果直接删掉，查找44时在44本该存在的位置~未到44的位置中途，存在空元素，则会停止遍历；如此一来则影响了查找的正确性。因此线性探测采用标记的伪删除法来删除一个元素

    // 哈希表每个空间给个标记
    // EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
    enum State{EMPTY, EXIST, DELETE};

通过对线性探测法的了解，我们可能也会不自觉地觉得这貌似不是一个很好的方法💭此方法，自己的位置被别人占了就去抢占别人的位置，哈希表中的数据一旦增多，产生的哈希冲突的可能性也会增大📈而哈希冲突一多，很可能会导致连续冲突的情况，如上图，插入44时连续出现了4次哈希冲突💢

📌📌总结

线性探测的优点：结构简单，代码实现难度不大

线性探测的缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。如何缓解呢？

2️⃣二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：以2的i次方进行向后探测

📌📌二次探测对比线性探测来说，降低了发生连续冲突的可能性，但是并没有从本质上解决问题

🌏以上的两个方法，都有其较为明显的局限性，那能如何再加以改善呢？而哈希表又需要在什么时候扩容呢？

为了在扩容时能再次降低冲突的可能性，此时引入了负载因子：
负载因子 = 表中有效数据个数/空间的大小

• 负载因子越大：表中的空位置越少，发生冲突的可能性越大，增删查改的效率越低
• 负载因子越小：表中的空位置越多，发生冲突的可能性越大，增删查改效率越高，但是空间利用率越低（浪费空间）

因此我们在闭散列（开放定址法）中对负载因子的标准定在了0.7~0.8，一旦超过0.8查表时缓存未命中率呈曲线上升。因此，一些采用开放定址法的hash库，如Java的系统库限制了负载因子为0.75，超过此值则扩容

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。

⭕因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

5.2 闭散列实现

✏️结构设计

哈希表搜索的高效得益于其搜索遍历能够通过映射（哈希函数）快速定位到数据所在位置；但是从上文对哈希表闭散列的了解，我们知道，由于存在哈希冲突，所以有的数据并不是存在他本该存在的位置；在存储元素时，若其位置被别人占了，则顺位往后存储（遇到空位置则存入），也就意味着，元素在其本该存放的位置到其最后存放的位置之间不会存在空位置📌

所以，我们在遍历查找某个元素时，便可以先通过哈希函数计算哈希地址，若元素不在其哈希地址上则向后遍历，遍历到空则结束；因此当我们删除元素时不能真的物理删除它，否则在查找元素时会出错，因此我们可以给每个节点设置一个状态

状态分为三种：

1. EXIST：存在
2. EMPTY：空
3. DELETE：删除

对此我们可以用枚举实现：

//枚举标记状态
enum State
{
	EMPTY,
	EXIST,
	DELETE,
};

🚩如此一来，我们在每个节点初始化时就给为EMPTY,当元素被删除时，由于不能真的物理删除其节点，所以我们给其状态变为DELETE；这样我们在查找时，遇到节点是EXIST或DELETE的都要继续往后找，直到遇到EMPTY位置；而当我们插入元素时，可以将元素插入到状态为EMPTY或DELETE的位置上

---

所以哈希表的节点，不仅仅要包括数据，还要包括其节点的状态

//哈希表节点
template<class K, class V >
struct HashData
{
	pair<K, V> _kv;
	State _state = EMPTY;//给一个缺省值为空，不然就需要写一个构造函数给为空，否则是随机给值
};

---

对于哈希表，我们可以利用数组来实现闭散列，数组中的每个位置都存放着一个哈希节点，另外，为了在插入时便于计算负载因子，判断是否需要扩容，我们还要记录下哈希表中的有效数据

template<class K, class V>
class HashTable
{
public:
    //构造函数
    HashTable()
		:_n(0)
	{
		_tables.resize(10);
	}
	//...
		
private:
	vector<Data> _tables;//哈希表
	size_t _n;//有效数据个数
};

✏️仿函数

在开始插入数据之前，有一个问题——如果我们统计的是字符串的出现次数呢？kv.first还能取模吗？

为此我们可以写一个仿函数Hashfunc（这也正是库的实现方法）

• 将key数据强制类型转换成size_t，若key是string类型则写一个string的特化版本（这样就可以不用显式地传要调用哪个Hashfunc）

这里的仿函数我们模仿库的实现，设计到了BKDR算法（不展开细讲）简单来说就是大佬们通过大量的运算和推理，总结出了此算法能够使得不同的string计算转换后相同的概率较小，使得出现哈希冲突的概率降低

//仿函数
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

//特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash *= 131;
			hash += ch;
		}
		return hash;
	}
};

如此一来，我们的哈希表模板就需要再传一个仿函数对象

template<class K, class V, class Hash = HashFunc<K>>

✏️数据插入

步骤如下：

1. 查找该键值对是否存在，若存在则插入失败
2. 判断是否需要扩容
3. 插入键值对，有效元素个数++

扩容时，我们需要将旧表的数据重新映射到新表，因为新表的容量不一样，所以每个数据的哈希地址也不同，因此不能将旧表的数据原封不动地搬过去。所以这里我们可以采用新建一个哈希表对象，然后复用插入函数进行插入，最后再将两个哈希表互换🌏

bool Insert(const pair<K, V>& kv)
{
	if (Find(kv.first))
	return false;

	//如果大于标定的负载因子，就需要扩容
	if (_n * 10 / _tables.size() >= 7)
	{
		//旧表的数据需要重新计算映射到新表
		//直接构造一个新的哈希对象，循环调用其insert函数，然后再交换就好（工具人）
		HashTable<K, V, Hash> newHT;
		newHT._tables.resize(_tables.size() * 2);
		for (auto& e : _tables)//引用减少拷贝代价
		{
			if (e._state == EXIST)
				newHT.Insert(e._kv);
		}

		//交换
		_tables.swap(newHT._tables);
	}

	Hash hf;
	size_t hashi = hf(kv.first) % _tables.size();
	//这里要模size不能模capacity
	//假如vector里面size是11，capacity是20，你模完是15，在物理上是可以存的
	//但是我们存值是用vector的[]进行操作，它插入的时候会检查那个下标是小于size才能存
	while (_tables[hashi]._state == EXIST)
	{
		hashi++;
		//循环检索
		hashi %= _tables.size();
	}

	//插入
	_tables[hashi]._kv = kv;
	_tables[hashi]._state = EXIST;
	_n++;

	return true;
}

✏️数据查找

步骤如下：

1. 通过哈希函数算出对应的哈希地址
2. 从哈希地址开始向后线性探测，直到遇到EMPTY则停止查找（说明数据不存在）

⭕注意：在查找判断时不能只判断key值，还要判断状态；若key相同但是状态为DELETE则也不算查找成功

Data* Find(const K& key)
{
	Hash hf;
	size_t hashi = hf(key) % _tables.size();
	while (_tables[hashi]._state != EMPTY)
	{
		//记得加个状态判断，因为删除并没有删除节点，而是改变状态而已
		if (_tables[hashi]._kv.first == key && _tables[hashi]._state == EXIST)
		{
			return &_tables[hashi];
		}
		hashi++;
		hashi %= _tables.size();
	}
	return nullptr;
}

✏️数据删除

步骤如下：

1. 检查哈希表是否存在该元素
2. 若存在，则将其状态改为DELETE，哈希表有效元素-1

这样的删除方式也即是我们上文提到的伪删除法，即不是真正地物理删除节点，而是将状态改成DELETE，在插入新数据时可以将其覆盖

bool Erase(const K& key)
{
	Data* ret = Find(key);
	if (ret)
	{
		ret->_state == DELETE;
		_n--;
		return true;
	}
	else
	{
		return false;
	}
}

5.3 开散列

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

如上文的例子中，当发生哈希冲突时就不再占用别人的位置，因此，开散列的每个桶中放的都是发生哈希冲突的元素

📌开散列增容

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。

📌开散列与闭散列的比较

• 开散列更节省空间
  开散列需要增设单链表，看似空间消耗更大，但是由于开散列不会影响到其他位置，因此开散列的哈希桶负载因子可以超过1，远远超过闭散列；而表项所占空间比指针大得多，所以使用链地址法比开地址法更节省空间
• 极端情况处理更优
  哈希桶的极端情况就是：所有元素都冲突到了一个位置，此时效率为O(N)，此时我们可以考虑用红黑树结构代替单链表，将红黑树的根存储在哈希表中

总而言之，开散列各方面都会比闭散列优异，而STL库中unordered系列容器也正是用开散列作为底层结构实现的🚩

5.4 开散列实现

🚩结构设计

在开散列的哈希表中，哈希表的每个位置存储的都是单链表的头节点的位置，所以哈希表其实是一个 指针数组
而由于发生哈希冲突时，是要以单链表的形式链接上，所以每个哈希节点都要存储一个节点指针用于指向下一节点

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()
		:_n(0)
	{
		_tables.resize(10);
	}
	//...
	
private:
	vector<Node*> _tables;//指针数组
	size_t _n = 0;
};

⭕注：开散列同样需要用到仿函数，与闭散列同用即可

🚩数据插入

步骤如下：

1. 查找该键值对是否存在，若存在则插入失败
2. 判断是否需要扩容
3. 插入键值对，有效元素个数++

扩容：如果哈希表中负载因子等于1则扩容；扩容方式为创建一个新表，遍历旧表，把节点依次头插到新表上，最后交换两个表

⭕这里没有向闭散列一样采用复用插入函数的原因：若复用插入函数，则每个节点都要重新new，旧节点要销毁，如此一来消耗过大

bool Insert(const pair<K, V>& kv)
{
	if (Find(kv.first))
		return false;

	//负载因子控制在1，超过就扩容
	if (_tables.size() == _n)
	{
		vector<Node*> newTables;
		newTables.resize(2 * _tables.size(), nullptr);//创建一个新表
		//将旧节点头插到新表
		for (auto cur : _tables)
		{
			while(cur)
			{
				Node* next = cur->_next;
				size_t hashi = Hash()(cur->_kv.first) % newTables.size();
				cur->_next = newTables[hashi];
				newTables[hashi] = cur;
				cur = next;
			}
		}
				
		_tables.swap(newTables);
	}

	size_t hashi = Hash()(kv.first) % _tables.size();//匿名对象
	Node* newnode = new Node(kv);
	//头插
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;

	return true;
}

🚩数据查找

步骤如下：

1. 根据哈希函数计算出哈希桶地址
2. 遍历哈希地址对应的单链表

Node* Find(const K& key)
{
	size_t hashi = Hash()(key) % _tables.size();
	Node* cur = _tables[hashi];
	while (cur)
	{
		if (cur->_kv.first == key)
			return cur;
		else
			cur = cur->_next;
	}
	return nullptr;
}

🚩数据删除

步骤如下：

1. 通过哈希函数计算出哈希桶地址
2. 遍历哈希桶，寻找待删除结点
3. 删除结点：头删 or 中间删
4. 有效元素-1

bool Erase(const K& key)
{
	size_t hashi = Hash()(key) % _tables.size();
	Node* prev = nullptr;
	Node* cur = _tables[hashi];
	while (cur)
	{
		if (cur->_kv.first == key)//准备删除
		{
			//节点是头节点
			if (cur == _tables[hashi])
				_tables[hashi] = cur->_next;
			else
			{
				prev->_next = cur->_next;
			}
					
			delete cur;
			--_n;
			return true;
		}
		else
		{
			prev = cur;
			cur = cur->_next;
		}
	}
	return false;
}