1. unordered系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到$lo{g}_{2}N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map和unordered_set进行介绍，

1.1 unordered_set

1. unordered_set是以不特定顺序存储唯一元素的容器，并允许根据其值快速检索单个元素。
2. 在unordered_set中，元素的值同时是其键，它唯一地标识它。键是不可变的，因此，unordered_set中的元素在容器中不能被修改，但是它们可以入和删除。
3. 在内部，unordered_set中的元素不按任何特定顺序排序，而是根据其哈希值放到桶中，以便直接通过其值快速访问各个元素（平均平均时间复杂度恒定）。
4. unordered_set容器通过其键访问单个元素的速度比set容器更快，尽管它们在通过其元素子集进行范围迭代时通常效率较低。

1.2 unordered_map

1. unordered_map是存储<key, value>键值对的关联式容器，其允许通过key快速的索引到与其对应的value。
2. 在unordered_map中，键值通常用于唯一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
3. 在内部，unordered_map没有对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问value。

2. unordered_set/map的封装

2.1 基本接口

上一篇文章我们模拟实现了哈希表，在这里我们直接对其进行改造，将其封装为unordered_set/map。

由于我们的unordered_map与unordered_set使用的是一个哈希表，所以我们首先对哈希表的模板参数进行改造。
由于map是k、v模型，set是k，所以在哈希表那一层我们统一处理成T。

在哈希表内部使用key进行比较时，需要使用一个函数获得map与set的key。

所以，在哈希表中所有涉及使用T类型的data计算位置与比较的地方都得改。

unordered_map与unordered_set框架对比
由于一般key都是不允许修改的，所以这里set传递的是const K；map传的是pair<const K,V>

2.2 迭代器

2.2.1 迭代器的结构

对于哈希表而言，迭代器++应该指向当前桶的下一个元素，当前桶走完了就应该到下一个桶。
那如何弄清下一个桶在什么位置呢？
迭代器内部除了要有一个节点的指针，还应该有一个表的指针，在该表中可以找到桶的位置。

此时编译我们的代码，发现找不到node和table

Node和HashTable找不到是因为我们把它们的定义放在了HTIterator的后面，编译器只会向上找，所以我们可以把Node的定义放在它上面，但是HashTable的定义能放在它上面吗？

由于我们后期会在HashTable中使用HTIterator，它们两个是相互依赖的，谁定义在谁上面都不行。所以我们可以前置声明一下，同时注意声明与定义处的缺省参数不能同时有

1. operator++

迭代器++时，要知道当前桶中还有没有元素，如果有元素，则指向下一个元素；如果没有元素，则指向下一个桶的第一个元素。

由于HtIterator内部要访问哈希表成员_table，但由于哈希表的成员_table是私有的，在外部无法访问。所以我们可将HTIterator设置为HahTable的友元类

Self& operator++(){if (_node->_next)//当前桶还有元素{_node = _node->_next;}else{KeyOfT kot;Hash hs;size_t hashi = hs(kot(_node->_data)) % _pt->_table.size();hashi++;//指向下一个桶while (hashi < _pt->_table.size()){if (_pt->_table[hashi])//“下一个”桶有元素{break;}else{hashi++;}}if (hashi == _pt->_table.size())//若后面没有桶了{_node = nullptr;  //end()}else{_node = _pt->_table[hashi];}}return *this;}

2. -> 、*、!=

		T& operator*(){return _node->_data;}T* operator->(){return &_node->_data;}bool operator !=(const Self& s){_node != s._node;}

2.2.2 set迭代器的封装

1. 普通迭代器

先在哈希表内部封装迭代器

再封装set的迭代器

此时我们set的迭代器就可以跑起来了

由于我们对模板参数进行传递时，K都使用了const修饰，所以key是不允许修改的。

2. const迭代器

首先我们要明白，const迭代器是不允许修改的，无论是K还是V。所以我们只需对迭代器的 -> 与 * 操作做修改即可。

所以我们要给底层迭代器增加两个模板参数，使用普通迭代器时可以对V进行修改；使用const迭代器不允许修改V。

哈希表中的const迭代器

set的const迭代器

2.2.3 map迭代器的封装

由于我们已经实现了set，所有哈希表内迭代器的坑已经被我们跳过了，这里我们只需简单的封装map即可。

1. 普通迭代器

2. const迭代器

3. operator[ ]

对于map[key]而言，如果key已经存在，则插入失败，并且返回key所对应位置的迭代器。如果key不存在，则将key插入，value为类型的默认值，并返回其迭代器。

所以我们要改造find、insert函数，使其返回一个pair<iterator,bool>

map中operator的实现以及find和insert的更改

由于哈希表中的find与insert已经更改，所以我们set中的也得改

更改后的find与insert要这样使用：

3.完整代码

3.1HashTable

//原模板
template<class K>
struct HashFunc
{size_t operator()(const K& key){return key;}
};//特化
template<>
struct HashFunc<string>
{size_t operator()(const string& key){size_t sum = 0;for (auto& e : key){sum *= 31;//这里使用了直接地址法，避免字符串的key计算后相同sum += e;}return sum;}
};namespace hash_bucket
{template<class T>struct HashNode//节点{T _data;//数据域HashNode<T>* _next;//指针域HashNode(const T& data):_data(data), _next(nullptr){}};//前置声明template<class K, class T, class KeyOfT, class Hash = HashFunc<K>>class HashTable;//迭代器template<class K, class T, class Ref,class Ptr,class KeyOfT, class Hash = HashFunc<K>>struct HTIterator{typedef HTIterator<K, T,Ref,Ptr, KeyOfT, Hash> Self;//重命名typedef HashNode<T> Node;HashNode<T>* _node;//指向节点的指针const HashTable<K, T, KeyOfT, Hash>* _pt;//哈希表指针HTIterator( Node* node, const HashTable<K,T,KeyOfT,Hash>* table):_node(node),_pt(table){}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}Self& operator++(){if (_node->_next)//当前桶还有元素{_node = _node->_next;}else{KeyOfT kot;Hash hs;size_t hashi = hs(kot(_node->_data)) % _pt->_table.size();hashi++;//指向下一个桶while (hashi < _pt->_table.size()){if (_pt->_table[hashi])//“下一个”桶有元素{break;}else{hashi++;}}if (hashi == _pt->_table.size())//若后面没有桶了{_node = nullptr;  //end()}else{_node = _pt->_table[hashi];}}return *this;}bool operator !=(const Self& s){return _node != s._node;}};//哈希表template<class K, class T,class KeyOfT,class Hash>class HashTable{template<class K, class T,class Ref,class Ptr, class KeyOfT, class Hash>friend struct HTIterator;typedef HashNode<T> Node;public:typedef HTIterator<K, T,T&,T*, KeyOfT, Hash> Iterator;//普通迭代器typedef HTIterator<K, T,const T&,const T*, KeyOfT, Hash> ConstIterator;//const迭代器Iterator begin(){if (_n == 0)//没有元素return end();else{for (size_t i = 0; i < _table.size(); i++){if (_table[i])//找到第一个桶{return Iterator(_table[i], this);//使用当前节点和桶构造一个迭代器返回}}}return end();}Iterator end(){return Iterator(nullptr, this);}ConstIterator cbegin()const {if (_n == 0)//没有元素return cend();else{for (size_t i = 0; i < _table.size(); i++){if (_table[i])//找到第一个桶{return ConstIterator(_table[i], this);//使用当前节点和桶构造一个迭代器返回}}}return cend();}ConstIterator cend() const{return ConstIterator(nullptr, this);}HashTable(size_t N = 10){_table.resize(N,nullptr);}~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;}}pair<Iterator,bool> insert(const T& data){Hash hs;KeyOfT kot;Iterator it = find(kot(data));//如果已经存在if ( it!= end()){return make_pair(it, false);}size_t size = _table.size();//检查扩容if (_n == size)//节点个数等于桶的数量时，进行扩容{//为了节省开销，不再重新开辟新节点，直接映射原来的节点，将原来的映射取消vector<Node*> newtable(size * 2, nullptr);size_t newsize = newtable.size();for (size_t i = 0; i < size; i++){Node* cur = _table[i];while (cur){size_t hashi = hs(kot(cur->_data)) % newsize;//元素对应的新表中的位置Node* next = cur->_next;//记录当前桶的下一个元素//头插连接到新桶cur->_next = newtable[hashi];newtable[hashi] = cur;cur = next;}_table[i] = nullptr;}swap(_table, newtable);}size_t hashi = hs(kot(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){Hash hs;KeyOfT kot;size_t hashi = hs(key) % _table.size();Node* cur = _table[hashi];while (cur){if (kot(cur->_data) == key)return Iterator(cur,this);cur = cur->_next;}return end();}bool erase(const K& key){Hash hs;KeyOfT kot;size_t hashi = hs(key) % _table.size();Node* cur = _table[hashi];Node* prev = nullptr;while (cur){if (kot(cur->_data) == key){if (prev == nullptr)//桶中只有一个元素{_table[hashi] = nullptr;}else{prev->_next = cur->_next;}delete cur;_n--;return true;}else{prev = cur;cur = cur->_next;}}return false;}private:vector<Node*> _table;size_t _n;};
}

3.2unordered_set

namespace my
{template<class K,class Hash = HashFunc<K>>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename hash_bucket::HashTable<K,const K,SetKeyOfT, Hash>::Iterator iterator;typedef typename hash_bucket::HashTable<K,const K,SetKeyOfT, Hash>::ConstIterator const_iterator;const_iterator cbegin() const{return _ht.cbegin();}const_iterator cend() const{return _ht.cend();}iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}pair<iterator,bool> insert(const K& key){return _ht.insert(key);}iterator find(const K& key){return _ht.find(key);}bool erase(const K& key){return _ht.erase(key);}private:hash_bucket::HashTable<K, const K,SetKeyOfT, Hash>  _ht;};
}

3.3unordered_map

namespace my
{template<class K, class V,class Hash = HashFunc<K>>class unordered_map{struct MapKeyOfT{const K& operator()(const pair< K,V>& kv){return kv.first;}};public:typedef typename hash_bucket::HashTable<K, pair<const K,V>, MapKeyOfT, Hash>::Iterator iterator;typedef typename hash_bucket::HashTable<K, pair<const K,V>, MapKeyOfT, Hash>::ConstIterator const_iterator;const_iterator cbegin()const{return _ht.cbegin();}const_iterator cend()const{return _ht.cend();}iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}V& operator[](const K& key){pair<iterator, bool> ret = _ht.insert(make_pair(key, V()));//将其对应的值返回//如果插入前已经存在，则返回其值；否则则返回一个V()return ret.first->second;}pair<iterator,bool> insert(const pair<K,V>& kv){return _ht.insert(kv);}iterator find(const K& key){return _ht.find(key);}bool erase(const K& key){return _ht.erase(key);}private:hash_bucket::HashTable<K, pair<const K,V>, MapKeyOfT, Hash>  _ht;};
}