1.1 unordered_map 介绍

• unordered_map 是存储 <key，value> 键值对的关联式容器，其允许通过 key 快速的索引到与其对应的 value。

• 在 unordered_map 中，键值通常用于唯一的标识元素，而映射值是一个对象，其内容与此键值关联。键和映射值的类型可能不同。

• 在内部，unordered_map 没有对 <key，value> 按照任何特定的顺序排序，为了能在常数范围内找到 key 所对应的 value，unordered_map 将相同哈希值的键值放在相同的桶中。

• unordered_map 容器通过 key 访问单个元素要比 map 快，但它通常在遍历元素子集的范围迭代方面效率较低。

• unordered_map 实现了直接访问操作符（operator[ ]），它允许使用 key 作为参数直接访问 value。

• 它的迭代器至少是前向迭代器（单向迭代器）。

1.2 unordered_map 的接口说明

1.2.2 unordered_map 的容量

1.2.3 unordered_map 的迭代器

1.2.4 unordered_map 的元素访问

小Tips：该函数中实际调用哈希桶的插入操作，用参数 key 与 V() 构造一个默认值往底层哈希桶中插入，如果 key 不在哈希桶中，插入成功，返回 V()。插入失败，说明 key 已经在哈希桶中，将 key 对应的 value 返回。

1.2.5 unordered_map 的查询

小Tips：unordered_map 中 key 是不能重复的，因此 count 函数的返回值最大为1。

1.2.7 unordered_map 的桶操作

三、底层结构

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

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

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

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

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

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

小Tips：用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。但是也会出现问题，以上图为例，再向集合中插入44，计算出来的哈希函数值是4，但是下标为4的位置已经存储的有值了。

对于两个数据元素的关键字 k_i 和 k_j （i != j），有 k_i != k_j，但有：Hash(k_i) == Hash(k_j)，即：不同的关键字通过相同的哈希函数计算出相同的哈希值，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。设计哈希函数应该遵循以下原则：

• 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有 m 个地址时，其值域必须在 0~m-1 之间。

• 哈希函数计算出来的地址能均匀分布在整个空间中。

• 哈希函数应该比较简单。

下面给大家列举一些常见的哈希函数。

取关键字的某个线性函数为散列地址：

小Tips：此方法的优点是简单、均匀。但是需要事先知道关键字的分布情况。适合查找比较小且连续的情况。

设散列表中允许的地址数为 m，取一个不大于 m，但最接近或者等于 m 的质数 p 作为除数，按照哈希函数：

3.3.3 平方取中法----(了解)

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它的平方就是18671041，抽取中间的3位671（或710）作为哈希地址。平方取中法适合于不知道关键字的分布，而位数又不是很大的情况。

折叠法是将关键字从左到右分割成位数相等的几部分（最后一部分位数可以短一些），然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。

3.3.5 随机数法----(了解)

选择一个随机数，取关键字的随机函数值为它的哈希地址，即：

小Tips：其中 random 为随机数函数。

设有 n 个d 位数，每一位可能有 r 种不同的符号在各个位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：

假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。

小Tips：数学分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。

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

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

闭散列也叫开放定址法，当发生哈希冲突时，如果哈希表未被填满，说明在哈希函数表中必然还有空位置，那么可以把 Key 对应的元素存放到冲突位置中的下一个空位置中去。那如何寻找下一个空位置呢？

这里我们使用开散列的方法来实现 unordered_set 和 unordered_map。

4.1.1 模板参数列表的改造

 //哈希表
template<class K, class T, class KeyOfT, class HashFunc = DefaultHasFunc<K>>//K的作用是为了方便查找和删除
class HashTable

小Tips：

• K：关键码类型。

• T：不同容器 T 的类型不同，如果是 unordered_map，T 代表一个键值对，如果是 unordered_set，V 为 K。

• KeyOfT：因为 T 的类型不同，通过 value 取 key 的方式就不同，详细代码参考下面 unordered_set/map 的实现。

• HashFunc：哈希函数仿函数对象类型，哈希函数使用除留余数法，需要将 key 转换为整形数字才能取模。

4.1.2 增加迭代器操作

//HashTable.h
//哈希桶的迭代器
 template<class K, class T, class Ptr, class Ref, class KeyOfT, class HashFunc>
 struct HTIterator
 {
	 typedef HashNode<T> Node;
	 typedef HTIterator<K, T, Ptr, Ref, KeyOfT, HashFunc> Self;
	 typedef HashTable<K, T, KeyOfT, HashFunc> Ht;
	 typedef HTIterator<K, T, T*, T&, KeyOfT, HashFunc> iterator;

	 Node* _node;
	 const Ht* _pht;

	 HTIterator(Node* node = nullptr, const Ht* pht = nullptr)
		 :_node(node)
		 ,_pht(pht)
	 {}

	 HTIterator(const iterator& it)//如果是普通迭代器，这里就是拷贝构造函数
		 :_node(it._node)		   //如果是 const 迭代器，这里就是用一个普通迭代器来构造一个 const 迭代器。
		 , _pht(it._pht)
	 {}

	 Self& operator++()
	 {
		 if (_node->_next)
		 {
			 _node = _node->_next;
		 }
		 else
		 {
			 //如果_node->_next == nullptr
			 //说明要到下一个桶去，因此迭代器类里面需要一个哈希表的指针，指向当前迭代器维护的哈希表
			 //这样才能找到下一个桶

			 //先找到我当前在那个桶
			 KeyOfT kot;
			 HashFunc hf;
			 size_t hashi = hf(kot(_node->_data)) % _pht->_table.size();

			 //从下一个位置开始查找下一个不为空的桶
			 ++hashi;
			 while (hashi < _pht->_table.size())
			 {
				 if (_pht->_table[hashi])
				 {
					 _node = _pht->_table[hashi];
					 return *this;
				 }
				 else
				 {
					 ++hashi;
				 }
			 }
		
			 _node = nullptr;
		 }

		 return *this;
	 }

	 bool operator != (const Self& s) const
	 {
		 return _node != s._node;
	 }

	 Ref operator*() const
	 {
		 return _node->_data;
	 }

	 Ptr operator->() const
	 {
		 return &(_node->_data);
	 }
 };

小Tips：因为哈希表本质上是由一个个哈希桶组成，迭代器走完当前桶，需要跳到下一个桶，迭代器要能指向下一个哈希桶，最简单的做法就是在迭代器里面存一份哈希表。实际代码中我们在迭代器中增加了一个哈希表类型的指针，指向当前迭代器维护的哈希表，又因为该指针会去访问哈希表里面的成员变量数组，所以该迭代器类必须是哈希表的友元类，关于友元类的具体声明参考下面修改后的哈希表。这里还有一个问题，迭代器里面使用了哈希表类型，哈希表里面又实用的迭代器类型，这里就会涉及到谁先谁后的问题，我这里的解决方法是将迭代器类定义在哈希表的前面，然后在迭代器的前面对哈希表的类做一个前置声明。其次，因为哈希桶在底层是单链表结构，所以哈希桶的迭代器不需要 - - 操作。

//HashTable.h
//哈希表
 template<class K, class T, class KeyOfT, class HashFunc = DefaultHasFunc<K>>//K的作用是为了方便查找和删除
 class HashTable
 {
	 //模板的友元
	 template<class K, class T, class Ptr, class Ref, class KeyOfT, class HashFunc>
	 friend struct HTIterator;

	 typedef HashNode<T> Node;
 private:
	 void swap(HashTable<K, T, HashFunc>& hbt)
	 {
		 std::swap(hbt._table, this->_table);
		 std::swap(hbt._n, this->_n);
	 }
 public:
	 typedef HTIterator<K, T, T*, T&, KeyOfT, HashFunc> iterator;
	 typedef HTIterator<K, T, const T*, const T&, KeyOfT, HashFunc> const_iterator;

	 iterator begin()
	 {
		 //找第一个桶
		 for (size_t i = 0; i < _table.size(); ++i)
		 {
			 if (_table[i])
			 {
				 return iterator(_table[i], this);
			 }
		 }

		 return iterator(nullptr, this);
	 }

	 iterator end()
	 {
		 return iterator(nullptr, this);
	 }

	 const_iterator begin() const
	 {
		 //找第一个桶
		 for (size_t i = 0; i < _table.size(); ++i)
		 {
			 if (_table[i])
			 {
				 return const_iterator(_table[i], this);
			 }
		 }

		 return const_iterator(nullptr, this);
	 }

	 const_iterator end() const
	 {
		 return const_iterator(nullptr, this);
	 }

	 HashTable(size_t size = 10)
	 {
		 _table.resize(size, nullptr);
	 }

	 //拷贝构造
	 HashTable(const HashTable<K, T, HashFunc>& htb)
	 {
		 _table.resize(htb._table.size());
		 for (size_t i = 0; i < htb._table.size(); ++i)
		 {
			 Node* cur = htb._table[i];
			 while (cur)
			 {
				 Insert(cur->_data);
				 cur = cur->_next;
			 }
		 }


		/* HashTable<K, T, HashFunc> tmp;
		 tmp._table = htb._table;//这里现代写法行不通，因为_table里面存的是指针，属于内置类型，进行的是浅拷贝。
		 tmp._n = htb._n;

		 swap(tmp);*/
	 }

	 pair<iterator, bool> Insert(const T& data)
	 {
		 HashFunc hf;
		 KeyOfT kt;
		 //HashFunc hf;
		 //先检查哈希桶中是否有这个元素，有就不能插入
		 if (Find(kt(data)) != end())
		 {

			 return make_pair(Find(kt(data)), false);
		 }

		 //扩容
		 if (_n == _table.size())
		 {
			 vector<Node*> newtable;
			 newtable.resize(_table.size() * 2, nullptr);
			 for (size_t i = 0; i < _table.size(); ++i)
			 {
					 Node* cur = _table[i];
					 while (cur)
					 {
						 Node* next = cur->_next;
						 size_t hashi = hf(kt(cur->_data)) % newtable.size();
						 cur->_next = newtable[hashi];
						 newtable[hashi] = cur;
						 cur = next;
					 }

					 _table[i] = nullptr;
			 }

			 _table.swap(newtable);
		 }

		 size_t hashi = hf(kt(data)) % _table.size();

		 //到这里说明当前桶里没有该元素，可以插入
		 Node* newnode = new Node(data);
		 newnode->_next = _table[hashi];
		 _table[hashi] = newnode;
		 ++_n;

		 return make_pair(iterator(newnode, this), true);
	 }

	 //查找
	 iterator Find(const K& key)const
	 {
		 HashFunc hf;
		 KeyOfT kt;
		 size_t hashi = hf(key) % _table.size();
		 Node* cur = _table[hashi];
		 while (cur)
		 {
			 if (kt(cur->_data) == key)
			 {
				 return iterator(cur, this);
			 }

			 cur = cur->_next;
		 }

		 return iterator(nullptr, this);
	 }

	 //删除
	 bool erase(const K& key)
	 {
		 HashFunc hf;
		 KeyOfT kt;
		 size_t hashi = hf(key) % _table.size();
		 Node* cur = _table[hashi];
		 Node* prev = nullptr;
		 while (cur)
		 {
			 
			 if (kt(cur->_data) == key)
			 {
				 if (prev == nullptr)
				 {
					 _table[hashi] = cur->_next;
				 }
				 else
				 {
					 prev->_next = cur->_next;
				 }

				 delete cur;
				 cur = nullptr;
				 --_n;
				 return true;
			 }
			 prev = cur;
			 cur = cur->_next;
		 }

		 return false;
	 }

	 ~HashTable()
	 {
		 for (size_t i = 0; i < _table.size(); ++i)
		 {
			 Node* cur = _table[i];

			 while (cur)
			 {
				 Node* next = cur->_next;
				 delete cur;
				 cur = next;
			 }

			 _table[i] = nullptr;
		 }
	 }
 private:
	 vector<Node*> _table;//指针数组
	 //这里的_table属于自定义类型，如果我们不写析构函数，编译器会去调用vector自己的析构函数
	 //对于vector的析构函数来说，Node* 是一个指针，属于内置类型
	 //因此vector的析构函数不会对 Node* 做任何处理
	 //因此这里我们需要自己写析构函数，去释放哈希桶中的结点
	 size_t _n = 0;//记录存储的有效数据个数
 };

小Tips：哈希表的修改主要体现在增加通过 key 获取 value 的操作。

//unorderedset.h
#include "HashTable.h"

template<class K, class HashFunc = DefaultHasFunc<K>>
class unordered_set
{
private:
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	typedef typename HashTable<K, K, SetKeyOfT, HashFunc>::const_iterator iterator;
	typedef typename HashTable<K, K, SetKeyOfT, HashFunc>::const_iterator const_iterator;

	iterator begin() const
	{
		return _ht.begin();
	}

	iterator end() const
	{
		return _ht.end();
	}

	pair<iterator, bool> insert(const K& key)
	{
		/*pair<typename HashTable<K, K, SetKeyOfT, HashFunc>::iterator, bool> ret = _ht.Insert(key);

		return make_pair(iterator(ret.first._node, ret.first._pht), ret.second);*/
		return _ht.Insert(key);//这种写法如果编译器检查的严格可能过不了

		//上面两种插入方法都可以，这一块是精华，好好品味
	}

	K& operator[](const K& key)
	{
		pair<typename HashTable<K, K, SetKeyOfT, HashFunc>::iterator, bool> ret = _ht.Insert(key);

		return *(ret.first);
	}

private:
	HashTable<K, K, SetKeyOfT, HashFunc> _ht;
};

小Tips：unordered_set 是一种 key 结构，所以它的普通迭代器和 const 迭代器都是不允许被修改的。因此 unordered_set 中的普通迭代器本质上还是 HashTable 中的 const 迭代器。此时就会出现一个问题，插入调用的是 HashTable 中的 Insert，其返回值是一个 pair，其中 first 是一个普通迭代器，而在 unordered_set 这一层，insert 的返回值也是一个 pair，它的 first 看起来是一个普通迭代器，但本质上是用 HashTable 中的 const 迭代器进行封装的，因此这里涉及到从普通迭代器转换成 const 迭代器，随然普通迭代器和 const 迭代器共用同一个类模板，但是它们的模板参数不同，所以普通迭代器和 const 迭代器本质上属于两种不同类型。因此要将一个普通迭代器转化成 const 迭代器本质上涉及类型转换。要用一个 A 类型的对象去创建一个 B 类型的对象 ，可以在 A 类里面增加一个构造函数，该构造函数的参数是 B 类型。因此，这里我们需要在迭代器类里面增加一个用普通迭代器构造 const 迭代器的构造函数。除了这种方法外，上面我还提供了一种方法，即先用 HashTable 中的普通迭代器创建一个 pair 对象 ret 接收 HashTable 中 Insert 的返回值，然后再去取出 pair 里面迭代器中的成员变量，用取出来的成员变量去构造一个 const 迭代器，然后再用这个 const 迭代器去构建一个 pair，最后返回这个 pair。这种方法的前提是迭代器类中的成员变量是 public，否则就不能再迭代器类的外面拿到其成员变量。

template<class K, class V, class HashFunc = DefaultHasFunc<K>>
class unordered_map
{
private:
	struct MapKeyOfT
	{
		const K& operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};
public:
	typedef typename HashTable<K, pair<const K, V>, MapKeyOfT, HashFunc>::iterator iterator;
	typedef typename HashTable<K, pair<const K, V>, MapKeyOfT, HashFunc>::const_iterator const_iterator;

	iterator begin()
	{
		return _ht.begin();
	}

	iterator end()
	{
		return _ht.end();
	}

	const_iterator begin() const
	{
		return _ht.begin();
	}

	const_iterator end() const
	{
		return _ht.end();
	}

	pair<iterator, bool> insert(const pair<K, V>& kv)
	{
		return _ht.Insert(kv);
	}

	V& operator[](const K& key)
	{
		pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));

		return ret.first->second;
	}
private:
	HashTable<K, pair<const K, V>, MapKeyOfT, HashFunc> _ht;
};

小Tips：对 unordered_map 结构来说无论是普通迭代器还是 const 迭代器，它的 key 永远都不能被修改。这里的解决方案是在 unordered_map 中用 pair<cons K, V> 去实例化出一个哈希表的模板，此时哈希表的节点中存的就是 pair<const K, V> _data;，此时无论是普通迭代器还是 const 迭代器去解引用该结点，返回的 _data，它里面的 key 是 const K 类型，是不支持修改的，这样以来问题就解决了。由于这里我们是用 pair<cons K, V> 去实例化的模板，所以 unordered_map 中的哈希表本质上存的就是 pair<cons K, V>，但是在用户层我们插入的是 pair<K, V>，这是两种不同的类型，和上面的普通迭代去创建 const 迭代器一样，这里还是需要通过构造函数来解决，但是这里不需要我们自己来解决，因为 pair 是库中的内容，库中已经帮我们实现好啦，所以这里我们无需做任何处理。这里本质上会去调用下面这个构造函数。