哈希表，哈希桶的实现

哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( )，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。、
向该结构当中：
插入元素： 根据待插入元素的关键码，用此函数计算出该元素的存储位置，并将元素存放到此位置。
搜索元素： 对元素的关键码进行同样的计算，把求得的函数值当作元素的存储位置，在结构中按此位置取元素进行比较，若关键码相等，则搜索成功。
该方式即为哈希（散列）方法， 哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表（散列表）。

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快 问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

哈希冲突

不同关键字通过相同哈希函数计算出相同的哈希地址，这种现象称为哈希冲突或哈希碰撞。我们把关键码不同而具有相同哈希地址的数据元素称为“同义词”。

哈希函数

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。 哈希函数设计原则：
1.哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
2.哈希函数计算出来的地址能均匀分布在整个空间中，哈希函数应该比较简单

常见哈希函数

直接定址法
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况
除留余数法
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。
平方取中法
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况**（了解即可）**
折叠法
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况。（了解即可）
随机数法
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。（了解即可）
数字分析法
设有n个d位数，每一位可能有r种不同的符号，这r中不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，而在某些位上分布不均匀，只有几种符号经常出现。此时，我们可根据哈希表的大小，选择其中各种符号分布均匀的若干位作为哈希地址。（了解即可）
注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

哈希冲突解决

解决哈希冲突两种常见的方法是：闭散列和开散列
一、线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
插入
1.通过哈希函数获取待插入元素在哈希表中的位置
2.如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探
3.测找到下一个空位置，插入新元素

删除
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。
线性探测的优点：实现非常简单。
线性探测的缺点：一旦发生冲突，所有的冲突连在一起，容易产生数据“堆积”，即不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要多次比较（踩踏效应），导致搜索效率降低。
二、二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： = ( + )% m,或者： = ( - )% m。其中：i = 1,2,3…， 是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。 对于2.1中如果要插入44，产生冲突，使用解决后的情况为：

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

开散列 —— 链地址法（拉链法、哈希桶）

开散列，又叫链地址法（拉链法），首先对关键码集合用哈希函数计算哈希地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在实际中，开散列的哈希桶结构比闭散列更实用，主要原因有两点：
1.哈希桶的负载因子可以更大，空间利用率高。
2.哈希桶在极端情况下还有可用的解决方案。

哈希表的闭散列实现

在这里我们为了不影响删除导致的后果，我们使用仿删除的方法，标记法定义空来表示删除。
EMPTY（无数据的空位置）。
EXIST（已存储数据）。
DELETE（原本有数据，但现在被删除了）。

//枚举：标识每个位置的状态
enum State
{
	EMPTY,
	EXIST,
	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>> _table; //哈希表
	size_t _n = 0; //哈希表中的有效元素个数
};

哈希表的插入

步骤：
1、查看哈希表中是否存在该键值的键值对，如果有就不插入，因为哈希表不允许数据冗余。
2、判断是否需要调整哈希表的大小，哈希表大小为0的话设置哈希表初始值。
3.负载因子大于0.7需要增容，首先创建一个新的哈希表，新哈希表的大小设置为原哈希表的2倍，将原哈希表当中的数据插入到新哈希表，交换这两个哈希表。
3、将键值对插入哈希表，首先通过哈希函数计算哈希地址，找到一个状态为EMPTY或DELETE的位置，将数据插入该位置，并将该位置的状态设置为EXIST。
4、哈希表中的有效元素个数加一。

//插入函数
bool Insert(const pair<K, V>& kv)
{
	//1、查看哈希表中是否存在该键值的键值对
	HashData<K, V>* ret = Find(kv.first);
	if (ret)
	{
		return false; //插入失败
	}

	//2、判断是否需要调整哈希表的大小
	if (_table.size() == 0) 
	{
		_table.resize(10); 
	}
	else if ((double)_n / (double)_table.size() > 0.7) //负载因子大于0.7需要增容
	{
		
		HashTable<K, V> newHT;
		newHT._table.resize(2 * _table.size());
		
		for (auto& e : _table)
		{
			if (e._state == EXIST)
			{
				newHT.Insert(e._kv);
			}
		}
		//c、交换这两个哈希表
		_table.swap(newHT._table);
	}

	//3、将键值对插入哈希表
	//通过哈希函数计算哈希地址
	size_t start = kv.first%_table.size(); 
	size_t index = start;
	size_t i = 1;
	int base = index;
	//找到一个状态为EMPTY或DELETE的位置
	while (_table[index]._state == EXIST)
	{
		index = start + i; //线性探测
		//index = start + i*i; //二次探测
		index %= _table.size(); 
		i++;
	}
	//将数据插入该位置，并将该位置的状态设置为EXIST
	_table[index]._kv = kv;
	_table[index]._state = EXIST;
	
	//4、哈希表中的有效元素个数加一
	_n++;
	return true;
}

哈希表的查找

步骤：
1.通过哈希函数计算哈希地址
2.若该位置的状态为EXIST，并且key值匹配，则查找成功，直到找到空位置还没有找到目标元素，查找失败。

//查找函数
HashData<K, V>* Find(const K& key)
{
	if (_table.size() == 0) //哈希表大小为0，查找失败
	{
		return nullptr;
	}

	size_t start = key % _table.size(); //通过哈希函数计算哈希地址（除数不能是capacity）
	size_t index = start;
	size_t i = 1;
	//直到找到空位置为止
	while (_table[index]._state != EMPTY)
	{
		//若该位置的状态为EXIST，并且key值匹配，则查找成功
		if (_table[index]._state == EXIST&&_table[index]._kv.first == key)
		{
			return &_table[index];
		}
		index = start + i; //线性探测
		//index = start + i*i; //二次探测
		index %= _table.size(); //防止下标超出哈希表范围
		i++;
	}
	return nullptr; //直到找到空位置还没有找到目标元素，查找失败
}

注意： 在查找过程中，必须找到位置状态为EXIST，并且key值匹配的元素，才算查找成功。若仅仅是key值匹配，但该位置当前状态为DELETE，则还需继续进行查找，因为该位置的元素已经被删除了。

哈希表的删除

步骤：
1.查看哈希表中是否存在该键值的键值对，若不存在则删除失败。
2.若存在，则将该键值对所在位置的状态改为DELETE即可。
3.哈希表中的有效元素个数减一。
注意： 虽然删除元素时没有将该位置的数据清0，只是将该元素所在状态设为了DELETE，但是并不会造成空间的浪费，因为我们在插入数据时是可以将数据插入到状态为DELETE的位置的，此时插入的数据就会把该数据覆盖。

//删除函数
bool Erase(const K& key)
{
	//1、查看哈希表中是否存在该键值的键值对
	HashData<K, V>* ret = Find(key);
	if (ret)
	{
		//2、若存在，则将该键值对所在位置的状态改为DELETE即可
		ret->_state = DELETE;
		//3、哈希表中的有效元素个数减一
		_n--;
		return true;
	}
	return false;
}

哈希桶的实现

哈希表的结构

在开散列的哈希表中，哈希表的每个位置存储的实际上是某个单链表的头结点，即每个哈希桶中存储的数据实际上是一个结点类型，该结点类型除了存储所给数据之外，还需要存储一个结点指针用于指向下一个结点。

//每个哈希桶中存储数据的结构
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
{
public:
	//...
private:
	vector<Node*> _table; //哈希表
	size_t _n = 0; //哈希表中的有效元素个数
};

哈希表的插入

步骤：
1.查看哈希表中是否存在该键值的键值对，若已存在则插入失败。
2.判断是否需要调整哈希表的大小，若哈希表的大小为0，或负载因子过大都需要对哈希表的大小进行调整。
3.将键值对插入哈希表。
4.哈希表中的有效元素个数加一。

//插入函数
bool Insert(const pair<K, V>& kv)
{
	//1、查看哈希表中是否存在该键值的键值对
	Node* ret = Find(kv.first);
	if (ret) //哈希表中已经存在该键值的键值对（不允许数据冗余）
	{
		return false; //插入失败
	}

	//2、判断是否需要调整哈希表的大小
	if (_n == _table.size()) //哈希表的大小为0，或负载因子超过1
	{
		//增容
		//a、创建一个新的哈希表，新哈希表的大小设置为原哈希表的2倍（若哈希表大小为0，则将哈希表的初始大小设置为10）
		vector<Node*> newtable;
		size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
		newtable.resize(newsize);

		//newtable.resize(GetNextPrime(_table.size()));
		
		//b、将原哈希表当中的结点插入到新哈希表
		for (size_t i = 0; i < _table.size(); i++)
		{
			if (_table[i]) //桶不为空
			{
				Node* cur = _table[i];
				while (cur) //将该桶的结点取完为止
				{
					Node* next = cur->_next; //记录cur的下一个结点
					size_t index = cur->_kv.first%newtable.size(); //通过哈希函数计算出对应的哈希桶编号index（除数不能是capacity）
					//将该结点头插到新哈希表中编号为index的哈希桶中
					cur->_next = newtable[index];
					newtable[index] = cur;

					cur = next; //取原哈希表中该桶的下一个结点
				}
				_table[i] = nullptr; //该桶取完后将该桶置空
			}
		}
		//c、交换这两个哈希表
		_table.swap(newtable);
	}

	//3、将键值对插入哈希表
	size_t index = kv.first % _table.size(); //通过哈希函数计算出对应的哈希桶编号index（除数不能是capacity）
	Node* newnode = new Node(kv); //根据所给数据创建一个待插入结点
	//将该结点头插到新哈希表中编号为index的哈希桶中
	newnode->_next = _table[index];
	_table[index] = newnode;

	//4、哈希表中的有效元素个数加一
	_n++;
	return true;
}

哈希表的查找

1.先判断哈希表的大小是否为0，若为0则查找失败。
2.通过哈希函数计算出对应的哈希地址。
3.通过哈希地址找到对应的哈希桶中的单链表，遍历单链表进行查找即可。

//查找函数
HashNode<K, V>* Find(const K& key)
{
	if (_table.size() == 0) //哈希表大小为0，查找失败
	{
		return nullptr;
	}

	size_t index = key % _table.size(); //通过哈希函数计算出对应的哈希桶编号index（除数不能是capacity）
	//遍历编号为index的哈希桶
	HashNode<K, V>* cur = _table[index];
	while (cur) //直到将该桶遍历完为止
	{
		if (cur->_kv.first == key) //key值匹配，则查找成功
		{
			return cur;
		}
		cur = cur->_next;
	}
	return nullptr; //直到该桶全部遍历完毕还没有找到目标元素，查找失败
}

哈希表的删除

步骤：
1.通过哈希函数计算出对应的哈希桶编号。
2.遍历对应的哈希桶，寻找待删除结点。
3.若找到了待删除结点，则将该结点从单链表中移除并释放。
4.删除结点后，将哈希表中的有效元素个数减一。

//删除函数
bool Erase(const K& key)
{
	//1、通过哈希函数计算出对应的哈希桶编号index（除数不能是capacity）
	size_t index = key % _table.size();
	//2、在编号为index的哈希桶中寻找待删除结点
	Node* prev = nullptr;
	Node* cur = _table[index];
	while (cur) //直到将该桶遍历完为止
	{
		if (cur->_kv.first == key) //key值匹配，则查找成功
		{
			//3、若找到了待删除结点，则删除该结点
			if (prev == nullptr) //待删除结点是哈希桶中的第一个结点
			{
				_table[index] = cur->_next; //将第一个结点从该哈希桶中移除
			}
			else //待删除结点不是哈希桶的第一个结点
			{
				prev->_next = cur->_next; //将该结点从哈希桶中移除
			}
			delete cur; //释放该结点
			//4、删除结点后，将哈希表中的有效元素个数减一
			_n--;
			return true; //删除成功
		}
		prev = cur;
		cur = cur->_next;
	}
	return false; //直到该桶全部遍历完毕还没有找到待删除元素，删除失败
}