HashTable（哈希表）

        哈希表底层实现了unordered_map和unordered_set，是在C++11中新加入的头文件

目录

 一、哈希的概念

二、哈希函数

三、解决哈希冲突

1.闭散列

        使用线性探测的方法

 2.开散列

---

 一、哈希的概念

        Hash，翻译汉语为散列。用中文音译，即哈希。     

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

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

        

        当向该结构中：

        插入元素

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

        搜索元素

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

---

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

        

二、哈希函数

        哈希函数有很多种设计。我们要实现的，也是最为常见的一种哈希函数：除留余数法。即存储在哈希表中的位置是关键字的余数。

        

        虽然，这样实现哈希的查找效率是O(1)，但是，有许多数它们的余数相同，因此会造成哈希冲突。

三、解决哈希冲突

        解决哈希冲突有两种办法：闭散列和开散列。 

1.闭散列

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

        使用线性探测的方法

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

        比如在上述哈希表中插入44

         每一个哈希值都有标记。

    enum state
    {
		EMPTY,
		EXIST,
		DELETE
	};
	template <class K, class V>
	struct HashData
	{
		enum state _state = EMPTY;
		pair<K, V> _kv;
	};

        哈希表的结构

    template <class K,class V>
	class HashTable
	{
    private:
		vector<HashData<K,V>> _table;
		size_t _n = 0;
	};

        由于哈希冲突，当哈希表中的元素较多时，发生哈希冲突的概率越大，因此，引入"负载因子"概念，表示哈希表的填充量。当负载因子 >= 0.7，即刻对哈希空间扩容。

            if (_n * 10 / _table.size() >= 7)
			{
				HashTable<K, V> newHT(_table.size() * 2);
				for (auto& e : _table)
				{
					if (e._state == EXIST)
						newHT.Insert(e._kv);
				}
				_table.swap(newHT._table);
			}

        因为哈希表插入时是根据余数来获取插入位置的，但是有些关键字并不是整型，因此使用仿函数解决类型转换的问题，对于string，要尽可能的让string类的关键字不冲突，基于“字符串的哈希算法”，实现string -> size_t 的“类型转换”。

        

    //将key转换为size_t
	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 i = 0;
			for (auto e : key)
			{
				i += e;
				i *= 31;
			}
			return i;
		}
	};

        哈希表的查找

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

        哈希表的插入

        bool Insert(const pair<K,V> kv)
		{
			//查找是否存在，如果已经存在则不插入
			if (Find(kv.first))
				return false;
			//负载因子 > 0.7就扩容，换一张表
			if (_n * 10 / _table.size() >= 7)
			{
				HashTable<K, V> newHT(_table.size() * 2);
				for (auto& e : _table)
				{
					if (e._state == EXIST)
						newHT.Insert(e._kv);
				}
				_table.swap(newHT._table);
			}
			//线性探测
			Hash hs;
			size_t hashi = hs(kv.first) % _table.size();
			while (_table[hashi]._state == EXIST)
			{
				++hashi;
				hashi %= _table.size();
			}

			_table[hashi]._kv = kv;
			_table[hashi]._state = EXIST;
			++_n;
			return true;
		}

        哈希表的删除

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

         gitee哈希表线性探测的实现，为命名空间utocoo中的代码

 2.开散列

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

 

        开散列方法的哈希结点（用map举例）

    template <class K,class V>
	struct HashTableNode
	{
		typedef HashTableNode<K, V> Node;
		Node* _next;
		pair<K, V> _kv;
		HashTableNode(const pair<K, V>& kv)
			:_kv(kv)
			, _next(nullptr)
		{
		}
	};

        此时哈希表的vector参数可以是list，但是有点复杂，可以直接用链表的指针做参数，由我们自己控制。

    template <class K,class V,class Hash = HashFunc<K>>    
    class HashTable
	{
	public:
		typedef HashTableNode<K, V> Node;
    private:
		vector<Node*> _table;
		size_t _n;
	};

 

先实现查找

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

插入

        bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
				return false;
			Hash hs;
			//负载因子到1就扩容
			if (_n == _table.size())
			{
				vector<Node*> newTable(_table.size() * 2);
				
				for (size_t i = 0; i < _table.size(); ++i)
				{
					Node* cur = _table[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;
					}
					_table[i] = nullptr;
				}

				_table.swap(newTable);
			}

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

			++_n;
			return true;
		}

         这里当负载因子为1时就扩容，负载因子是指个数_n和size()的比较。当负载因子为1时，由于哈希桶的结构，此时的vector并没有被填充满，但是还是要扩容，因为可能某一个哈希桶出现了较长的长度。

        扩容时，原来vector的每一个哈希结点要释放，而新的vector又要new，故结点不作释放的消耗，遍历原来vector，修改指针的值即可。

 gitee哈希桶实现的完整代码，从165行开始为哈希桶的实现