哈希 || unordered系列的关联式容器底层 | 哈希模拟实现 | HashTable代码实现

安心学编程

已于 2024-08-04 10:52:06 修改

阅读量457

点赞数 11

分类专栏： C++知识点文章标签：哈希算法算法 c++ 数据结构

于 2024-08-04 10:51:10 首次发布

本文链接：https://blog.csdn.net/2301_78131481/article/details/140901492

版权

C++知识点专栏收录该内容

17 篇文章 0 订阅

订阅专栏

底层结构

unordered系统的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。

哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须经过关键码的多次比较。

顺序查找的时间复杂度为 $O\left ( N \right )$
平衡树中为树的高度，即 $O\left ( log_{}N\right )$

搜索的效率取决于搜索过程中元素的比较次数。

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

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

当向该结构中：

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

该方式即为哈希（散列）方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表（HashTable）（或者称为散列列表）。

哈希思路实例

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

哈希函数设置为：hash ( key ) = key % capacity；

capacity为存储元素底层空间总的大小。

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

但是这时就会有一些问题，按照上述的哈希方式，向集合插入元素44，会出现什么问题？

哈希冲突

对于两个数据元素的关键字，两个关键字不同a与b，但是Hash(a) == Hash(b) ，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该现象称为哈希冲突或哈希碰撞。

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

哈希函数

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

哈希函数设计原则：

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

常见的哈希函数

直接定址法（常用）

取关键字的某个线性函数为散列地址：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种不同的符号在各位上出现在频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。
数学分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。

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

哈希冲突解决

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

闭散列

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

那如何寻找下一个空位置呢？

线性探测

比如，上述的示例，现在需要插入元素44，先通过哈希函数计算哈希地址，HashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

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

插入：
通过哈希函数获取待插入元素在哈希表中的位置；
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到了下一个空位置，插入新元素。
删除：
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来就可能会受到影响。因此线性探测采用标记的伪删除法来删除一个元素。
// 哈希表每个空间给个标记
// EMPTY 空位置
// EXIST 此位置已有元素
// DELETE 元素已删除

enum State
{
    EMPTY,
    EXIST,
    DELETE
};
线性探测优点：实现非常简单。
线性探测的缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。

二次探测

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

Hash(i) = Hash(0) + i^2
Hash(i-1) = Hash(0) + (i-1)^2
Hash(i) = Hash(i-1) + (2i-1)

其中：i = 1,2,3……，Hash(0) 是通过散列函数 Hash(x) 对元素的关键码 key 进行计算得到的位置，m是表的大小。

对于上述的示例，如果要插入44，产生冲突，使用解决后的情况为：

研究表明：

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

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

开散列

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

可以从下图中看出，开散列中每个桶中放的都是发生哈希冲突的元素。

开散列与闭散列比较

应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上：
由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a<=0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省了存储空间。

模拟实现

哈希表闭散列线性探测——open_address

open_address的HashTable的结构体以及待实现的函数

namespace openress {
	//枚举哈希数据的三种状态
	enum State
	{
		EXIST,
		DELETE,
		EMPTY
	};
	//定义一个存储键值对&&状态为空的数据
	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();
		bool Insert(const pair<K, V>& kv);
		HashData<K, V>* Find(const K& key);
		bool Erase(const K& key);

	private:
		vector<HashData<K, V>> _tables;
		size_t _n = 0;//存储的数据的个数
	};
}

构造函数HashTable()

先进行将哈希表初始化为，起初最多存储10个数据。

HashTable()
{
	_tables.resize(10);
}

插入数据Insert()

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

	// 扩容
	if (_n * 10 / _tables.size() >= 7)
	{
		//vector<HashData<K, V>> newTables(_tables.size() * 2);
		 遍历旧表， 将所有数据映射到新表
		 ...
		//_tables.swap(newTables);

		HashTable<K, V, Hash> newHT;
		newHT._tables.resize(_tables.size() * 2);
		for (size_t i = 0; i < _tables.size(); i++)
		{
			if (_tables[i]._state == EXIST)
			{
				newHT.Insert(_tables[i]._kv);
			}
		}

		_tables.swap(newHT._tables);
	}

	Hash hs;
	size_t hashi = hs(kv.first) % _tables.size();
	while (_tables[hashi]._state == EXIST)
	{
		++hashi;
		hashi %= _tables.size();
	}

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

	return true;
}

查找数据Find()

HashData<K, V>* Find(const K& key)
{
	Hash hs;
	size_t hashi = hs(key) % _tables.size();
	while (_tables[hashi]._state != EMPTY)
	{
		if (_tables[hashi]._state == EXIST
			&& _tables[hashi]._kv.first == key)
		{
			return &_tables[hashi];
		}

		++hashi;
		hashi %= _tables.size();
	}

	return nullptr;
}

删除数据Erase()

bool Erase(const K& key)
{
	HashData<K, V>* ret = Find(key);
	if (ret == nullptr)
	{
		return false;
	}
	else
	{
		ret->_state = DELETE;
		return true;
	}
}

完整代码

//openress开散列定址法
namespace open_address
{
	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()
		{
			_tables.resize(10);
		}

		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
			{
				return false;
			}
			if (_n * 10 / _tables.size() >= 7)
			{
				HashTable<K, V> newHT;
				newHT._tables.resize(_tables.size() * 2);
				for (size_t i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._state == EXIST)
					{
						newHT.Insert(_tables[i]._kv);
					}
				}
				_tables.swap(newHT._tables);
			}
			Hash hs;
			size_t hashi = hs(kv.first) % _tables.size();
			while (_tables[hashi]._state != EMPTY)
			{
				hashi++;
				hashi %= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			_n++;
			return true;
		}

		HashData<K, V>* Find(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._kv.first == key
					&& _tables[hashi]._state == EXIST)
				{
					return &_tables[hashi];
				}
				else
				{
					hashi++;
					hashi %= _tables.size();
				}
			}
			return nullptr;
		}

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

	private:
		vector<HashData<K, V>> _tables;
		size_t _n;
	};

	void Hash_open_address_Test1()
	{
		HashTable<int, int> ht;
		int a[] = { 6,23,13,4,2,32,43,56,4,1 };
		for (auto e : a)
		{
			ht.Insert({ e,e });
		}
		ht.Insert({ 9,9 });
		for (auto e : a)
		{
			ht.Erase(e);
		}
	}
	void Hash_open_address_Test2()
	{
		HashTable<int, int> ht;
		int a[] = { 11,21,4,14,24,15,9 };
		for (auto e : a)
		{
			ht.Insert({ e,e });
		}
		ht.Insert({ 34,34 });


		cout << ht.Find(24) << endl;
		cout << ht.Find(34) << endl;
	}

	void Hash_open_address_Test3()
	{
		HashTable<string, string> ht;
		ht.Insert({ "crush","喜欢" });
		ht.Insert({ "sheep","目前喜欢" });
		ht.Insert({ "iredq","目前喜欢" });
		ht.Insert({ "hsepe","目前喜欢" });
	}
}

哈希表开散列哈希桶——hash_bucket

hash_bucket的HashTable的结构体以及待实现的函数

namespace hash_bucket
{
	template<class K,class V>
	struct HashNode
	{
		HashNode<K, V>* _next;
		//存储的是为hashNode的节点
		pair<K, V> _kv;
		//就是存储的pair类型的数据

		HashNode(const pair<K, V>& kv)
			//哈希节点的构造函数，将这个生成为一个结构体
			:_kv(kv)
			,_next(nullptr)
		{}
	};

	template<class K,class V,class Hash = HashFunc<K>>
	//哈希表的实现
	//此时的模版类型有三个，因为有一个是解决string的映射问题
	class HashTable
	{
		typedef HashNode<K, V> Node;
		//本来节点的类型应该为HashNode<K,V>，但是为了方便
		//typedef重命名使其更为简单
	public:
		HashTable();//构造函数
		~HashTable();
		bool Insert(const pair<K, V>& kv);
		Node* Find(const K& key);
		bool Erase(const K& key);

	private:
		vector<Node*> _tables;
		size_t _n;
	};
}