【C++】Unordered_map Unordered_set

        在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，例如map、set等。它们在搜索数据时效率可达到O(logN)，但最糟糕的情况下搜索需要比较红黑树的高度次，若此时树中的节点非常之多，那么搜索效率就非常不理想。

        最理想的搜索是，进行较少的比较次数就能够将元素找到。于是，在C++11中，STL又提供了4个unordered系列的关联式容器，即unordered_map 、unordered_set、unordered_multimap和unordered_multiset。这四个容器与红黑树结构的关联式容器的使用方式基本类似，但不同的是，它们的底层结构为哈希桶。

        本篇博客unordered_map和unordered_set的特性和常见用法，并搭配对STL源码的模拟实现，旨在更好地帮助读者理解容器的功能。

目录

一、无序的关联式容器

1.Unordered_map 

2.Unordered_set

二、同一种底层数据结构支持两种不同的容器

1.底层哈希桶的实现

2.上层的初步封装

· unordered_map

· unordered_set

3.普通迭代器

· 基本结构

 · 相关功能

· 上层的进一步封装

4.const迭代器

· 基本结构

 · 上层的进一步封装

5.insert() 的返回值与operator[ ]

6.键值不匹配的解决方案

7.模拟实现的完整代码

· HashTable.h

· unordered_map.h

· unordered_set.h

一、无序的关联式容器

1.Unordered_map 

        Unordered_map（无序映像）是一种存储<key，value>键值对的关联式容器，使用时需包含该容器的头文件“#include<unordered_map>”，底层为哈希桶，支持通过key快速地索引到与之对应的value（为了能在常数范围内找到key所对应的value，它将具有相同哈希地址的键值对放在相同的桶中）。

        对于unordered_map中的元素，键值key通常用于惟一地标识它，实值value则表示它本身的值。键值key和实值value是一一对应的，它们的类型可以不同。它们在容器内没有对按照任何特定的顺序来排序，所以unordered_map相当于是map的”不排序但去重“版本。

        Unordered_map通过key访问单个元素要比map快（这是因为其底层是哈希桶），但在遍历迭代方面效率通常较低。它支持下标访问符[ ]，允许使用key作为参数直接访问value。

        Unordered_map的迭代器一般为正向迭代器。

#include<unordered_map>void test_unordered_map()
{unordered_map<string, string> up;               //调用默认构造定义一个空的容器unordered_map<string, string> up2(up);//调用拷贝构造创建并初始化一个容器//emplace()构造并插入元素up.emplace("1", "apple");up.emplace("2", "banana");up.emplace("3", "orange");up.emplace("4", "pear");up.emplace("5", "watermelon");//迭代器遍历for ( auto it = up.begin(); it != up.end(); ++it ){cout << " " << it->first << ":" << it->second << endl;}//insert()插入元素up2.insert ( {{"sugar",0.8},{"salt",0.1}} );       //默认构造插入pair<string,double> myshopping ("baking powder",0.3);up2.insert (myshopping);                           //拷贝构造插入                       up2.insert (make_pair<string,double>("eggs",6.0)); //移动构造插入up2.insert (up.begin(), up.end());                 //迭代器范围插入//范围for遍历容器for (auto& kv : up2){cout << kv.first << ":" << kv.second << endl;}//通过[]也可以插入元素unordered_map<string, string> dict;dict["sort"] = "排序";dict["insert"] = "插入";dict["string"] = "字符串";dict["left"];for (auto& kv : dict){cout << kv.first << ":" << kv.second << endl;}//查找auto it = dict.find(sort); if ( it == dict.end() ) {cout << "not found" << endl;}else {cout << it->first << " is " << it->second << endl;}string s="insert";if (dict.count(s)>0){cout << "dict has " << s << endl;}//删除up.erase ( up.begin() );             //迭代器指定删除up.erase ("2");                      //key指定删除up.erase ( up.find("3"), up.end() ); //迭代器范围删除//验空+查大小if( up.empty() ){cout << up.size() << endl;}
}

2.Unordered_set

        Unordered_set（无序集合）是一种只存储键值key的关联式容器，使用时需包含该容器的头文件“#include<unordered_set>”，底层为哈希桶，支持对键值key的快速检索。

        对于unordered_set中的元素，它们的实值同时也是唯一标识它的键值。键值key在设置上是不可变的，因此，容器中的元素不可修改，只可插入和删除。容器中的元素没有对按照任何特定的顺序来排序，所以unordered_set相当于是set的”不排序但去重“版本。

        Unordered_set访问单个元素要比set快（这是因为其底层是哈希桶），但在遍历迭代方面效率通常较低。

        Unordered_set的迭代器一般为正向迭代器。

void test_unordered_set()
{//unordered_set仅能去重unordered_set<int> us;     //调用默认构造定义一个空的容器unordered_set<int> us2(us);//调用拷贝构造创建并初始化一个容器//插入us.insert(3);us.insert(1);us.insert(3);us.insert(4);us.insert(5);//迭代器遍历unordered_set<int>::iterator it = us.begin(); while (it != us.end()){cout << *it << "";//3 1 4 5 ++it;}cout << endl;//查找for (auto& x: us) {if (myset.count(x)>0) cout << "us has " << x << endl;else cout << "us has no " << x << endl;}unordered_set<int>::const_iterator got = us.find (6);if ( got == myset.end() ) cout << "not found in us";else cout << *got << " is in us";//删除us.erase ( us.begin() );                    us.erase (4);                        us.erase (us.find(1), us.end() ); }

二、同一种底层数据结构支持两种不同的容器

 (这一小节在【C++】map 和 set 中有逻辑相似的、更加详细的STL源码解析）

1.底层哈希桶的实现

（关于哈希桶的更多解析详见：【数据结构】哈希）

//HashTable.h#include<vector>template<class K>
struct DefaultHashFunc
{size_t operator()(const K& key){return (size_t)key;}
};
template<>
struct DefaultHashFunc<string>
{size_t operator()(const string& str){size_t hash = 0;for (auto ch : str){hash *= 131;hash += ch;}return hash;}
};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 HashFunc = DefaultHashFunc<K>>class HashTable{typedef HashNode<T> Node;public:HashTable(){_table.resize(10, 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;}}bool Insert(const T& data){KeyOfT kot;if(Find(kot(data))){return false;}HashFunc hf;if (_n == _table.size()){size_t newSize = _table.size()*2;vector<Node*> newTable;newTable.resize(newSize, nullptr);for (size_t i = 0; i < _table.size(); i++){Node* cur = _table[i];while (cur){Node* next = cur->_next;size_t hashi = hf(kot(cur->_data)) % newSize;cur->_next = newTable[hashi];newTable[hashi] = cur;cur = next;}_table[i] = nullptr;}_table.swap(newTable);}size_t hashi = hf(kot(data)) % _table.size();Node* newnode = new Node(data);newnode->_next = _table[hashi];_table[hashi] = newnode;++_n;return true;}Node* Find(const K& key){HashFunc hf;KeyOfT kot;size_t hashi = hf(key) % _table.size();Node* cur = _table[hashi];while (cur){if (kot(cur->_data) == key){return cur;}cur = cur->_next;}return nullptr;}bool Erase(const K& key){HashFunc hf;KeyOfT kot;size_t hashi = hf(key) % _table.size();Node* prev = nullptr;Node* cur = _table[hashi];while (cur){if (kot(cur->_data) == key){if (prev == nullptr){_table[hashi] = cur->_next;}else{prev->_next = cur->_next;}--_n;delete cur;	return true;}prev = cur;cur = cur->_next;}return false;}private:vector<Node*> _table; // 挂满链表的指针数组size_t _n = 0;        // 有效数据个数};
}

2.上层的初步封装

· unordered_map

//unordered_map.h#include"HashTable.h"namespace CVE
{template<class K, class V>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};private:hash_bucket::HashTable<K, pair<K, V>, MapKeyOfT> _ht;};
}// unordered_map -> hash_bucket::HashTable<K, pair<K, V>> _ht;
// unordered_set -> hash_bucket::HashTable<K, K> _ht;

· unordered_set

//unordered_set.h#include"HashTable.h"namespace CVE
{template<class K>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};private:hash_bucket::HashTable<K, K, SetKeyOfT> _ht;};
}// unordered_map -> hash_bucket::HashTable<K, pair<K, V>> _ht;
// unordered_set -> hash_bucket::HashTable<K, K> _ht;

3.普通迭代器

· 基本结构

//HashTable.hnamespace 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 HashFunc>class HashTable;//普通迭代器template<class K, class T, class KeyOfT, class HashFunc>struct HTIterator{typedef HashNode<T> Node;typedef HTIterator<K, T, KeyOfT, HashFunc> Self;Node* _node;                             //哈希桶的当前节点HashTable<K, T, KeyOfT, HashFunc>* _pht; //哈希桶的指针//构造函数HTIterator(Node* node, HashTable<K, T, KeyOfT, HashFunc>* pht):_node(node),_pht(pht){}//...//哈希桶（哈希表）template<class K, class T, class KeyOfT, class HashFunc = DefaultHashFunc<K>>class HashTable{//...public:typedef HTIterator<K, T, KeyOfT, HashFunc> iterator;//...};}

 · 相关功能

//HashTable.hnamespace hash_bucket
{//...template<class K, class T, class KeyOfT, class HashFunc>struct HTIterator{typedef HashNode<T> Node;typedef HTIterator<K, T, KeyOfT, HashFunc> Self;Node* _node;                             //哈希桶的当前节点HashTable<K, T, KeyOfT, HashFunc>* _pht; //哈希桶的指针HTIterator(Node* node, HashTable<K, T, KeyOfT, HashFunc>* pht):_node(node),_pht(pht){}//*重载T& operator*(){return _node->_data; }//->重载T* operator->(){return &_node->_data;}//++重载Self& operator++(){//_node是某一个桶中的当前节点的指针// 当前桶中链表还没完，就遍历到下一个链表节点if (_node->_next){_node = _node->_next;}// 当前桶中链表走完了，就去找下一个挂了链表的桶（即不为空的桶）else{// 取当前桶的哈希地址KeyOfT kot;HashFunc hf;size_t hashi = hf(kot(_node->_data)) % _pht->_table.size();// 去下一个相邻的哈希地址查找下一个不为空的桶++hashi;while (hashi < _pht->_table.size()){//找到了，将_node（当前节点的指针）置为找到的桶的指针，并返回if (_pht->_table[hashi]){_node = _pht->_table[hashi];return *this;}//没找到就再去下一个相邻的哈希地址找else{++hashi; }}_node = nullptr;}//遍历到桶中的下一个节点，或哈希表遍历完了，都返回当前节点（的指针）return *this;}//!=重载bool operator!=(const Self& s){return _node != s._node;}};template<class K, class T, class KeyOfT, class HashFunc = DefaultHashFunc<K>>class HashTable{typedef HashNode<T> Node;// 友元声明// 否则HTIterator的对象无法访问HashTable的私有成员template<class K, class T, class KeyOfT, class HashFunc>friend struct HTIterator;public:typedef HTIterator<K, T, KeyOfT, HashFunc> iterator;iterator begin(){// 找第一个桶for (size_t i = 0; i < _table.size(); i++){Node* cur = _table[i];if (cur){return iterator(cur, this);}}return iterator(nullptr, this);}iterator end(){return iterator(nullptr, this);}//...}}

· 上层的进一步封装

  · unordered_map

//unordered_map.h#include"HashTable.h"namespace CVE
{template<class K, class V>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename hash_bucket::HashTable<K, pair<K, V>, MapKeyOfT>::iterator iterator;iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}private:hash_bucket::HashTable<K, pair<K, V>, MapKeyOfT> _ht;};
}

 · unordered_set

//unordered_set.h#include"HashTable.h"namespace CVE
{template<class K>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename hash_bucket::HashTable<K, K, SetKeyOfT>::iterator iterator;iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}private:hash_bucket::HashTable<K, K, SetKeyOfT> _ht;};
}

4.const迭代器

· 基本结构

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 HashFunc>class HashTable;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 HTIterator<K, T, T*, T&, KeyOfT, HashFunc> Iterator;Node* _node;const HashTable<K, T, KeyOfT, HashFunc>* _pht;HTIterator(Node* node, const HashTable<K, T, KeyOfT, HashFunc>* pht):_node(node), _pht(pht){}// 对于普通迭代器对象，这是拷贝构造// 对于const迭代器对象，这是构造，同时也支持普通迭代器去构造const迭代器HTIterator(const Iterator& it):_node(it._node), _pht(it._pht){}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}Self& operator++(){if (_node->_next){_node = _node->_next;}else{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){return _node != s._node;}bool operator==(const Self& s){return _node == s._node;}};template<class K, class T, class KeyOfT, class HashFunc = DefaultHashFunc<K>>class HashTable{typedef HashNode<T> Node;// 友元声明template<class K, class T, class Ptr, class Ref, class KeyOfT, class HashFunc>friend struct HTIterator;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++){Node* cur = _table[i];if (cur){return iterator(cur, this);}}return iterator(nullptr, this);}iterator end(){return iterator(nullptr, this);}const_iterator begin() const{for (size_t i = 0; i < _table.size(); i++){Node* cur = _table[i];if (cur){return const_iterator(cur, this);}}return const_iterator(nullptr, this);}const_iterator end() const{return const_iterator(nullptr, this);}//...private:vector<Node*> _table; size_t _n = 0; };
}

 · 上层的进一步封装

 · unordered_map

#include"HashTable.h"namespace CVE
{template<class K, class V>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<const K, V>& kv){return kv.first;}};public:typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT>::iterator iterator;typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT>::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();}//...private:hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT> _ht;};
}

 · unordered_set

#pragma once#include"HashTable.h"namespace CVE
{template<class K>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename hash_bucket::HashTable<K, K, SetKeyOfT>::const_iterator iterator;typedef typename hash_bucket::HashTable<K, K, SetKeyOfT>::const_iterator const_iterator;const_iterator begin() const{return _ht.begin();}const_iterator end() const{return _ht.end();}//...private:hash_bucket::HashTable<K, K, SetKeyOfT> _ht;};
}

5.insert() 的返回值与operator[ ]

//HashTable.hnamespace hash_bucket
{//...template<class K, class T, class KeyOfT, class HashFunc = DefaultHashFunc<K>>class HashTable{typedef HashNode<T> Node;template<class K, class T, class Ptr, class Ref, class KeyOfT, class HashFunc>friend struct HTIterator;public:typedef HTIterator<K, T, T*, T&, KeyOfT, HashFunc> iterator;typedef HTIterator<K, T, const T*, const T&, KeyOfT, HashFunc> const_iterator;//...pair<iterator, bool> Insert(const T& data){KeyOfT kot;iterator it = Find(kot(data));if(it != end()){return make_pair(it, false);}HashFunc hf;if (_n == _table.size()){//size_t newSize = _table.size() * 2;size_t newSize = GetNextPrime(_table.size());vector<Node*> newTable;newTable.resize(newSize, nullptr);for (size_t i = 0; i < _table.size(); i++){Node* cur = _table[i];while (cur){Node* next = cur->_next;size_t hashi = hf(kot(cur->_data)) % newSize;cur->_next = newTable[hashi];newTable[hashi] = cur;cur = next;}_table[i] = nullptr;}_table.swap(newTable);}size_t hashi = hf(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){HashFunc hf;KeyOfT kot;size_t hashi = hf(key) % _table.size();Node* cur = _table[hashi];while (cur){if (kot(cur->_data) == key){return iterator(cur, this);}cur = cur->_next;}return end();}//...private:vector<Node*> _table; size_t _n = 0; };
}
//unordered_map.h#include"HashTable.h"namespace CVE
{template<class K, class V>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<const K, V>& kv){return kv.first;}};public:typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT>::iterator iterator;typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT>::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:hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT> _ht;};
}

6.键值不匹配的解决方案

//unordered_set.h#include"HashTable.h"namespace CVE
{template<class K>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename hash_bucket::HashTable<K, K, SetKeyOfT>::const_iterator iterator;typedef typename hash_bucket::HashTable<K, K, SetKeyOfT>::const_iterator const_iterator;const_iterator begin() const{return _ht.begin();}const_iterator end() const{return _ht.end();}pair<const_iterator, bool> insert(const K& key){pair<typename hash_bucket::HashTable<K, K, SetKeyOfT>::iterator, bool> ret = _ht.Insert(key);//先用一个<普通迭代器,布尔值>的对象接收插入方法的返回值return pair<const_iterator, bool>(ret.first, ret.second);//再将对象中的普通迭代器通过构造函数构造为const迭代器}private:hash_bucket::HashTable<K, K, SetKeyOfT> _ht;};
}

7.模拟实现的完整代码

· HashTable.h

#include<vector>template<class K>
struct DefaultHashFunc
{size_t operator()(const K& key){return (size_t)key;}
};
template<>
struct DefaultHashFunc<string>
{size_t operator()(const string& str){size_t hash = 0;for (auto ch : str){hash *= 131;hash += ch;}return hash;}
};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 HashFunc>class HashTable;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 HTIterator<K, T, T*, T&, KeyOfT, HashFunc> Iterator;Node* _node;const HashTable<K, T, KeyOfT, HashFunc>* _pht;HTIterator(Node* node, const HashTable<K, T, KeyOfT, HashFunc>* pht):_node(node), _pht(pht){}HTIterator(const Iterator& it):_node(it._node), _pht(it._pht){}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}Self& operator++(){if (_node->_next){_node = _node->_next;}else{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){return _node != s._node;}bool operator==(const Self& s){return _node == s._node;}};template<class K, class T, class KeyOfT, class HashFunc = DefaultHashFunc<K>>class HashTable{typedef HashNode<T> Node;template<class K, class T, class Ptr, class Ref, class KeyOfT, class HashFunc>friend struct HTIterator;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++){Node* cur = _table[i];if (cur){return iterator(cur, this);}}return iterator(nullptr, this);}iterator end(){return iterator(nullptr, this);}const_iterator begin() const{for (size_t i = 0; i < _table.size(); i++){Node* cur = _table[i];if (cur){return const_iterator(cur, this);}}return const_iterator(nullptr, this);}const_iterator end() const{return const_iterator(nullptr, this);}//每次快速取模的是一个类似两倍关系的素数，可以更好地支持除留余数法寻址和扩容//但这个方法并没有明确的理论依据//C++的STL库中用了这样的方法，而Java库中没有用size_t GetNextPrime(size_t prime){static const int __stl_num_primes = 28;static const unsigned long __stl_prime_list[__stl_num_primes] ={53,         97,         193,       389,       769,1543,       3079,       6151,      12289,     24593,49157,      98317,      196613,    393241,    786433,1572869,    3145739,    6291469,   12582917,  25165843,50331653,   100663319,  201326611, 402653189, 805306457,1610612741, 3221225473, 4294967291};size_t i = 0;for (; i < PRIMECOUNT; ++i){if (primeList[i] > prime)return primeList[i];}return primeList[i];}HashTable(){_table.resize(GetNextPrime(1), 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){KeyOfT kot;iterator it = Find(kot(data));if(it != end()){return make_pair(it, false);}HashFunc hf;if (_n == _table.size()){size_t newSize = GetNextPrime(_table.size());vector<Node*> newTable;newTable.resize(newSize, nullptr);for (size_t i = 0; i < _table.size(); i++){Node* cur = _table[i];while (cur){Node* next = cur->_next;size_t hashi = hf(kot(cur->_data)) % newSize;cur->_next = newTable[hashi];newTable[hashi] = cur;cur = next;}_table[i] = nullptr;}_table.swap(newTable);}size_t hashi = hf(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){HashFunc hf;KeyOfT kot;size_t hashi = hf(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){HashFunc hf;KeyOfT kot;size_t hashi = hf(key) % _table.size();Node* prev = nullptr;Node* cur = _table[hashi];while (cur){if (kot(cur->_data) == key){if (prev == nullptr){_table[hashi] = cur->_next;}else{prev->_next = cur->_next;}--_n;delete cur;	return true;}prev = cur;cur = cur->_next;}return false;}private:vector<Node*> _table; size_t _n = 0; };
}

· unordered_map.h


#include"HashTable.h"namespace CVE
{template<class K, class V>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<const K, V>& kv){return kv.first;}};public:typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT>::iterator iterator;typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT>::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:hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT> _ht;};
}

· unordered_set.h

#include"HashTable.h"namespace CVE
{template<class K>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename hash_bucket::HashTable<K, K, SetKeyOfT>::const_iterator iterator;typedef typename hash_bucket::HashTable<K, K, SetKeyOfT>::const_iterator const_iterator;const_iterator begin() const{return _ht.begin();}const_iterator end() const{return _ht.end();}pair<const_iterator, bool> insert(const K& key){pair<typename hash_bucket::HashTable<K, K, SetKeyOfT>::iterator, bool> ret = _ht.Insert(key);return pair<const_iterator, bool>(ret.first, ret.second);}private:hash_bucket::HashTable<K, K, SetKeyOfT> _ht;};
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/519545.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

智能驾驶规划控制理论学习06-基于优化的规划方法

智能驾驶规划控制理论学习06-基于优化的规划方法

目录 一、优化概念 1、一般优化问题 2、全局最优和局部最优 二、无约束优化 1、无约束优化概述 2、梯度方法 通用框架 线性搜索 回溯搜索 3、梯度下降 基本思想 实现流程 ​4、牛顿法 基本思想 实现流程 5、高斯牛顿法 6、LM法&#xff08;Le…
阅读更多...
python进阶：可迭代对象和迭代器

python进阶：可迭代对象和迭代器

一、Iterable&#xff08;可迭代对象&#xff09; 1、可迭代对象&#xff1a;能够进行迭代操作的对象。 可以理解为&#xff1a;能够使用for循环遍历的都是可迭代对象&#xff1b;**所有的可迭代对象&#xff0c;偶可以用内置函数iter转换为迭代器** 2、可迭代对象包括&…
阅读更多...
Hive的性能优化

Hive的性能优化

1.调优概述 Hive 作为大数据领域常用的数据仓库组件&#xff0c;在设计和查询时要特别注意效率。影响 Hive 效率的几乎从不是数据量过大&#xff0c;而是数据倾斜、数据冗余、Job或I/O过多、MapReduce分配不合理等等。对 Hive 的调优既包含 Hive 的建表设计方面&#xff0c;对H…
阅读更多...
解决java: 无法访问javax.servlet.ServletException

解决java: 无法访问javax.servlet.ServletException

问题 在对历往项目工具类总结和归纳更新过程中&#xff0c;common模块在compile编译过程中遇到了“Error java: 无法访问javax.servlet.ServletException 找不到javax.servlet.ServletException的类文件”这个报错问题。 IDE使用的是idea2021。 解决方法 pom中增加如下依赖&…
阅读更多...
2022年浙江省职业院校技能大赛信息安全管理与评估 理论题一阶段

2022年浙江省职业院校技能大赛信息安全管理与评估 理论题一阶段

培训、环境、资料 公众号&#xff1a;Geek极安云科 网络安全群&#xff1a;775454947极安云科专注于技能提升&#xff0c;赋能 2024年广东省高校的技能提升&#xff0c;在培训中我们的应急响应环境 成功押题成功&#xff0c;知识点、考点、内容完美还原大赛赛题环境&#xff0c…
阅读更多...
基于STC系列单片机实现PNP型三极管S8550驱动共阳数码管或NPN型三极管S8050驱动共阴数码管功能

基于STC系列单片机实现PNP型三极管S8550驱动共阳数码管或NPN型三极管S8050驱动共阴数码管功能

Digitron.c #include "Digitron.h" //#include "Key.h" #define uchar unsigned char//自定义无符号字符型为uchar #define uint unsigned int//自定义无符号整数型为uint //uchar code DigitronBitCodeArray[] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x…
阅读更多...
OpenGL

OpenGL

Open Graphics Library 用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口&#xff08;API&#xff09; 它将计算机的资源抽象称为“OpenG的对象”&#xff0c;将资源的操作抽象为“OpenGL指令”。 OpenGL上下文&#xff08;Context&#xff09; 在应用程序调用任何O…
阅读更多...
搜维尔科技：3D Systems Geomagic Design X 逆向工程软件

搜维尔科技：3D Systems Geomagic Design X 逆向工程软件

产品概述 3D Systems Geomagic Design X 是全面的逆向工程软件 GeomagicoDesign XTM是全面的逆向工程软件&#xff0c;它结合了基于特征的CAD数模与三维扫描数据处理&#xff0c;使您能创建出可编辑、基于特征的CAD数模&#xff0c;并与您现有的CAD软件兼容。 拓展您的设计能…
阅读更多...
砝码称重 蓝桥杯

砝码称重 蓝桥杯

在C中&#xff0c;fabs()和abs()都用于计算数字的绝对值&#xff0c;但它们之间有一些区别。 fabs(double x)&#xff1a;计算浮点数x的绝对值&#xff0c;返回一个double类型的结果。 abs(int x)&#xff1a;计算整数x的绝对值&#xff0c;返回一个int类型的结果。 数组的默…
阅读更多...
每日OJ题_链表②_力扣24. 两两交换链表中的节点

每日OJ题_链表②_力扣24. 两两交换链表中的节点

目录 力扣24. 两两交换链表中的节点 解析代码 力扣24. 两两交换链表中的节点 24. 两两交换链表中的节点 难度 中等 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&…
阅读更多...
【java】后序遍历二叉树

【java】后序遍历二叉树

采用递归方式实现 节点类 public class Node {private int value;//父节点private Node fNode;//左节点private Node left;//右节点private Node right;//是否已经打印过private boolean sign false;public Node() {}public boolean isSign() {return sign;}public void setS…
阅读更多...
O2O:Offline Meta-Reinforcement Learning with Online Self-Supervision

O2O:Offline Meta-Reinforcement Learning with Online Self-Supervision

ICML 2022 paper Introduction 元强化学习(Meta RL)结合O2O。元RL需要学习一个探索策略收集数据&#xff0c;同时还需学习一个策略快速适应新任务。由于策略是在固定的离线数据集上进行元训练的&#xff0c;因此在适应探索策略收集的数据时&#xff0c;它可能表现得不可预测&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023