哈希用法及其底层详解+实现

最新推荐文章于 2024-08-29 15:32:55 发布

tpoog

最新推荐文章于 2024-08-29 15:32:55 发布

阅读量929

点赞数 18

分类专栏： C++进阶文章标签：哈希算法算法 c++ 开发语言 java jvm

本文链接：https://blog.csdn.net/m0_73802195/article/details/138169312

版权

C++进阶专栏收录该内容

9 篇文章 0 订阅

订阅专栏

troop主页
前面几章我们已经讲完了map和set的使用，及其底层，相信你已经会使用map和set了，今天我们学习hash，他可以说是map和set的亲兄弟

一 hash初步了解

首先，哈希的用法方面，我们先来看看hash的英文名
在这里插入图片描述

unordered这个单词就是无序的意思，哈希就是一个无序的map和set。所以使用方面，可以说是一模一样。
下面两个链接就是哈希的详细介绍。

unordered_map
unordered_set

既然map和set和hash几乎没区别，为什么会出现这个关联式容器呢？
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 $log_2 N$ ，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好
的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个
unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是
其底层结构不同，其中两个就是我们今天要说的哈希。

二 hash的底层结构

2.1hash概念

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

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
1.插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
2.搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。

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

我们举个例子；如数组[1，7，6，4，5，9]，放入hash表中。
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

在这里插入图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。
如果数据很多呢？，比如在加一个 14，那他要放的位置跟4重合了。这就是哈希冲突。

2.2 解决哈希冲突

闭散列（开放定址法）
i=key%表的大小
如果i的位置已经有了数字，那就线性的向后走到空的位置插入

三，开放定址法模拟实现哈希表

enum State
	{
		EMPTY,//空
		EXIST,//在
		DELETE//删除
	};
	template<class K,class V>
	struct HashData
	{
		State _state = EMPTY;
		pair<K, V> _kv;
	};
	template<class K, class V,class Hash=HashFunc<K>>
	class HashTable
	{
	private:
		vector<HashData> _tables;
	}

这就是基本框架

find（）

i=key%表的大小，
如果i不是查找的值，就线性的向后找，遇到空就可以结束了；到了表的结尾位置要往回绕。
补充：冲突越多，效率就会越多，这里还引入了新的概念负载因子/荷载因子=实际存的数据个数/表的大小这个值要控制在0.7左右。

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

insert（）

insert包含了两个内容扩容+插入（线性探测）
扩容问题：
如果已经大于0.7就需要进行扩容，扩容——重新开一个大的空间，旧表的数据交给新表。

bool Insert(const pair<K, V> kv)
		{
			if (Find(kv.first))
			{
				return false;
			}
			if (_n * 10 / _tables.size() == 7)
			{
				HashTable<K, V> newHT(_tables.size()*2);
				for (auto& e : _tables)
				{
					if (_tables[e]._state == EXIST)
					{
						newHT.Insert(e._kv);
					}
				}
				_tables.swap(newHT._tables);
			}
			//线性探测
			size_t hashi = kv.first % _tables.size();
			while (_tables[hashi]._state != EMPTY)
			{
				++hashi;
				hashi%= _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_n;
		}

Erase（）

删除的重点就是在于状态的修改，（数据不用真的删除，把状态修改成删除即可）

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

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/d11526a53c96454e8
为什么要设一个删除状态？，如果没有，假设我们这里删除了15，要找6就会发现找不到了，因为find走到空就结束了，多加一个删除状态就可完美的解决这个问题了。

转换整型

相信你发现了上面我们模拟实现的hash表有很大的缺陷，作为类模板上面的只能是当key为整型时才可以使用的，因为我们的hashi是用%出来的，而%只能作为整型才可以用，所以我们就要对其他的数据类型进行转换。这里就要分成种情况

能直接强转成整型的
不能直接强转成整型的，例如：string和Date（我们自己定义的类型）

我们可以写仿函数来解决这里的问题。

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& e : key)
			{
				hash += e;
				hash = hash * 131;
			}
			return hash;
		}
	};

完整代码

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
namespace open_address
{
	enum State
	{
		EMPTY,//空
		EXIST,//在
		DELETE//删除
	};
	template<class K,class V>
	struct HashData
	{
		State _state = EMPTY;
		pair<K, V> _kv;
	};
	//特化
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& key)
		{
			size_t hash = 0;
			for (auto& e : key)
			{
				hash += e;
				hash = hash * 131;
			}
			return hash;
		}
	};
	template<class K, class V,class Hash=HashFunc<K>>
	class HashTable
	{
	public:
		HashData<K, V>* Find(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			while (_tables[hashi]._state != EMPTY)
			{
				if (key==_tables[hashi]._kv.first && _tables[hashi]._state == EXIST)
				{
					return &_tables[hashi];
				}
				else
				{
					++hashi;
					hashi %= _tables.size();
				}
			}
			return nullptr;
		}
		bool Insert(const pair<K, V> kv)
		{
			if (Find(kv.first))
			{
				return false;
			}
			if (_n * 10 / _tables.size() == 7)
			{
				HashTable<K, V,Hash> newHT(_tables.size()*2);
				for (auto& e : _tables)
				{
					if (_tables[e]._state == EXIST)
					{
						newHT.Insert(e._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;
		}

		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				_n--;
				ret->_state = DELETE;
				return true;
			}
			else
			{
				return false;
			}
		}
	private:
		vector<HashData<K,V>> _tables;
		size_t _n = 0;//记录有多少个元素
	};
}

这里的string就是把字符全加起来的时候还乘上一个权值。因为string用的比较多所以我们可以给他特化。
然后就是改造上面我们写的代码，只要是有出现%就都要改。

四，哈希桶（开散列拉链法）模拟实现哈希表

4.1概念

一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同
关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。这就是闭散列的缺陷，那么如何缓解呢？
就要用到哈希桶的思想。
定义：
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
在这里插入图片描述
这个就是借助链表来完成的，每个有冲突的数不是向下寻找，而是链接在当前数子的下面。

4.2框架

template<class K, class V>
	struct HashNode
	{
		HashNode<K,V>* _next;
		pair<K, V> _kv;

		HashNode(const pair<K,V>& kv)
			:_next(nullptr)
			,_kv(kv)
		{}
	};
	template<class K, class V>
	class HashTable
	{
	private:
	vector<HashNode<K,V>*>_tables;
	size_t _n;
	};

Insert（）

插入还是两个问题，扩容和插入
插入比较简单

			size_t hashi = hs(kv.first) % _tables.size();
			Node* newnode = new Node(kv);
			//头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;

扩容问题，跟上面的闭散列类似，创建新表，把原来的旧表插入到新表当中。
这里的插入是负载因子到1的时候才需要扩容。

			//扩容：负载因子到1就进行扩容
			if (_n == _tables.size())
			{
				//创建新表
				vector<Node*> newtable(_tables.size() * 2, nullptr);
				//遍历旧表
				for (int i = 0; i < _tables.size(); i++)
				{
					//取出旧表中的数据，插入到新表当中
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hs(cur->_kv.first) % newtable.size();
						cur->_next = newtable[hashi];
						newtable[hashi] = cur;

						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newtable);
			}

Erase（）

bool Erase(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//两种情况，有前一个or没有前一个
					if (prev)
					{
						prev->_next = cur->_next;
					}
					else
					{
						_tables[hashi]->_next= cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

Find()

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

完整代码

namespace hash_bucket
{
	template<class K, class V>
	struct HashNode
	{
		HashNode<K,V>* _next;
		pair<K, V> _kv;

		HashNode(const pair<K,V>& kv)
			:_next(nullptr)
			,_kv(kv)
		{}
	};
	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K,V> Node;
	public:
		~HashTable()
		{
			for (int i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;

					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		HashTable()
		{
			_tables.resize(10, nullptr);
			_n = 0;
		}
		bool Insert(const pair<K,V>& kv)
		{
			if (Find(kv.first))
				return false;
			Hash hs;
			//扩容：负载因子到1就进行扩容
			if (_n == _tables.size())
			{
				//创建新表
				vector<Node*> newtable(_tables.size() * 2, nullptr);
				//遍历旧表
				for (int i = 0; i < _tables.size(); i++)
				{
					//取出旧表中的数据，插入到新表当中
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hs(cur->_kv.first) % newtable.size();
						cur->_next = newtable[hashi];
						newtable[hashi] = cur;

						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newtable);
			}

			size_t hashi = hs(kv.first) % _tables.size();
			Node* newnode = new Node(kv);
			//头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			return true;
		}
		Node* Find(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//两种情况，有前一个or没有前一个
					if (prev)
					{
						prev->_next = cur->_next;
					}
					else
					{
						_tables[hashi]->_next= cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
	private:
		vector<Node*> _tables;
		size_t _n;
	};
	
}