哈希、C++中的unordered系列关联式容器，模拟hashtable，用模拟实现的hashtable，封装unordered_set 和 unordered_map,

最新推荐文章于 2024-09-11 11:31:11 发布

孟婆的cappucino

最新推荐文章于 2024-09-11 11:31:11 发布

阅读量244

点赞数

文章标签：哈希算法 c++ 散列表数据结构算法开发语言

本文链接：https://blog.csdn.net/weixin_59093392/article/details/132299798

版权

三、封装 unordered_set 和 unordered_map

1、unordered_set

2、unordered_map

一、前言

续，之前再说set和map的时候，说的C++中的关联式容器还有另外的两种，分别为unordered_set和unordered_map,他们之间的区别呢，就是底层实现上，set和map的底层使用红黑树实现的，而unordered_set 和unordered_map的底层使用哈希表实现的，在前面几篇文章中呢，我也对红黑树的个别功能进行了模拟实现，而且给出了封装set和map的大致架子，今天我打算对哈希进行一个探究，也可以对hashtable进行实现，也可以用我们自己模拟实现的哈希对 unordered_set 和 unordered_map进行封装。希望呢，各位看到本篇文章的大佬可以指出我文章中的一些错误。

二、hash

1、哈希的原理

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

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

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

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

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。这样就可以让存入的数据随机分散到哈希表中，也可以用相同的方法取出元素

2、哈希冲突

不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

哈希冲突是很难解决的，所以，就要在存储的时候去解决冲突带来的影响：就有了闭散列，和开散列两种常见方法

3、闭散列

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

对于“下一个”空位置，该怎么寻找，又有多种方式，其中比较常用的有：线性探测和二次探测

（1）线性探测

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

那么这样的话，再插入元素的时候就可以通过哈希函数算出的地址去插入，如果发生了哈希冲突，就使用线性探测去寻找下一个空位置，再插入，再插入的话，类似的如果当前地址被占有，就再去找下一个空位置，去插入。

但是呢，这样就出现了一个新的问题，设想一个场景：一个位置发生了哈希冲突，使用线性探测找到下一个空位置离哈希函数算出的地址之间有一段距离，在这两个地址之间，有一个数据被删除了，那在查找冲突的那个数据的时候，怎么判断他是否存在？

所以，还需要在每一个位置设置一个标记位，标记为为空，或者被删除的时候，是可以插入的，在查找的时候，这个位置为空就不要再查找了，这个表中没有要查找的数据，如果这个位置是被删除的话，那就要继续往后查找，这样就解决了刚才的问题。

（2）二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：每间隔i^2（i = 1,2,3,4……）去探测，相同的方法去查找，

（3）对闭散列进行模拟实现（使用线性探测）

namespace close_hash
{
	enum State { EMPTY, EXIST, DELETE };

	template<class K, class V>
	class HashTable
	{
		struct Elem
		{
			pair<K, V> _val;
			State _state;
			//Elem(const pair<K, V>& val = pair<K, V>(), State state = State()) : _val(val), _state(state){}
		};

	public:
		HashTable(size_t capacity = 10)
			: _ht(capacity), _size(0), _totalSize(capacity)
		{
			/*for (size_t i = 0; i < capacity; ++i)
				_ht[i]._state = EMPTY;*/
		}
		// 插入
		bool Insert(const pair<K, V>& val) {

			//如果表中已有这个元素，那就不再进行插入
			if (Find(val.first) != (size_t)-1) return false;

			//如果hashtable中的元素达到了一定量，就要让其进行扩容
			if (_size * 10 / _totalSize >= 7) {
				//进行扩容
				size_t newsize = _totalSize * 2;
				HashTable<K, V> newht(newsize);
				
				for (auto elem : _ht) {
					newht.Insert(elem._val);
				}
				Swap(newht);
			}

			size_t hashi = HashFunc(val.first);
			if (_ht[hashi]._state == EMPTY || _ht[hashi]._state == DELETE) {
				_ht[hashi]._val = val;
				_ht[hashi]._state = EXIST;
				++_size;
				return true;
			}
			else { 
				int i = 1;
				while (_ht[HashFunc(hashi + i)]._state == EXIST) {
					++i;
				}
				_ht[HashFunc(hashi + i)]._val = val;
				_ht[HashFunc(hashi + i)]._state = EXIST;
				++_size;
				return true;
			}
		}

		// 查找
		size_t Find(const K& key) {
			size_t hashi = HashFunc(key);
			size_t tag = hashi;
			while (_ht[hashi]._state != EMPTY && _ht[hashi]._val.first != key) {
				hashi = HashFunc(++hashi);
				if (hashi == tag) {
					return -1;
				}
			}
			if (_ht[hashi]._state == EMPTY) return -1;
			return hashi;
		}

		// 删除
		bool Erase(const K& key) {
			size_t hashi = Find(key);
			if (hashi != (size_t)-1) {
				_ht[hashi]._state = DELETE;
				_size--;
				return true;
			}
			return false;
		}

		size_t Size()const
		{
			return _size;
		}

		bool Empty() const
		{
			return _size == 0;
		}

		void Swap(HashTable<K, V>& ht)
		{
			swap(_size, ht._size);
			swap(_totalSize, ht._totalSize);
			_ht.swap(ht._ht);
		}

	private:
		size_t HashFunc(const K& key)
		{
			return key % _ht.capacity();
		}

	private:
		vector<Elem> _ht;
		size_t _size;
		size_t _totalSize;  // 哈希表中的所有元素：有效和已删除, 扩容时候要用到
	};
}

4、开散列

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

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

开散列的实现：