文章目录
- 哈希表模板参数改造
- 针对模板参数V改造
- 增加仿函数获取具体数据类型.
- 哈希表的正向迭代器
- 正向迭代器中的内置成员:
- 正向迭代器的成员函数
- 哈希表插入函数的修改(适用于unordered_map)
- 一个类型K去做set和unordered_set他的模板参数的必备条件.
- unordered_set的模拟实现(完整代码)
- unordered_map的实现(完整代码)
- 适用于unordered_set和unordered_map的哈希表代码
哈希表模板参数改造
针对模板参数V改造
因为不同容器的类型不同,如果是unordered_map,V代表一个键值对,如果unordered_set,V代表Key值,而底层哈希表并不知道上层容器所要传递的
V模板参数类型,为了与哈希表的模板参数区分,我们将哈希表中的V模板参
数改为T.
增加仿函数获取具体数据类型.
例如: 在哈希表中当我们使用Find函数进行查找时:
如果上层传递的数据类型为Key值,我们就可以直接与查找数据比较.
如果上层传递的数据类型为pair<K,V>键值对,我们就不可以直接比较,需要利用仿函数获取键值对的first进行比较.
unordered_set仿函数SetKeyOfT代码:
struct SetKeyOfT //根据map还是set传递不同数据类型给底层.{const K& operator()(const K& key){return key;}};
unordered_map仿函数MapKeyOfT代码:
struct MapKeyOfT //根据map还是set传递不同数据类型给底层.{const K& operator()(const pair<K, V>& kv){return kv.first; //获取pair<K,V>键值对中的first.}};
所以,我们要在哈希表模板参数中增加一个仿函数KeyOfT.
如果是unordered_set,就传 SetKeyOfT类型的仿函数.
如果是unordered_map,就传MapKeyOfT类型的仿函数.
模板参数转换图示如下:
额外说明:
1: 我们对原先哈希表中的Hash进行了修改,不要缺省值,因为我们肯定是使用上层容器传递不同的仿函数类型,所以在unordered_set与unordered_map中传递仿函数类型.
哈希表的正向迭代器
正向迭代器中的内置成员:
哈希表正向迭代器有两个内置成员:
1: 结点指针
2: 哈希表的指针
template < class K, class T, class Hash, class KeyOfT >
class HashTable; //重新声明哈希表类模板.
//正向迭代器
template<class K, class T, class KeyOfT, class HashFunc = Hash<K>>
struct __HTIterator
{typedef HashNode<T> Node; //重新定义哈希结点的类型为Node.typedef HashTable<K, T, KeyOfT, HashFunc> HT; //重新定义哈希表的类型为HT.typedef __HTIterator<K, T, KeyOfT, HashFunc> Self; //重新定义正向迭代器的类型为Self.Node* _node; //结点指针HT* _pht; //哈希表指针
};
注意:
因为迭代器中要使用到哈希表类型,所以我们在哈希表迭代器前面必须声明一下哈希表类模板.
正向迭代器的成员函数
以下成员函数较为简单,就不另外说明:
_HashIterator( Node* node,HT* pht ) //初始化列表:_node(node), _pht(pht){}T& operator*() //解引用运算符重载{return _node->_data;}T* operator->() //->运算符重载{return &_node->_data;}bool operator!=( const Self& s ) const //外面增加const可以使const对象也能调用该成员函数.{return _node != s._node; //实质上是迭代器中的_node比较}bool operator==( const Self& s )const {return _node == s._node;}
前置++运算符重载:
前置++运算符重载主要有两个步骤:
1: 如果当前结点指针的下一个结点存在,则结点指针指向下一个结点.
2: 如果当前结点指针的下一个结点不存在:
(1): 通过哈希函数计算哈希桶的位置.
(2): 在哈希表中,从哈希桶中的下一个位置开始遍历查找.
如果哈希桶存在,则将结点指针指向该哈希桶.
如果哈希表遍历完还没有找到,则说明这是哈希表中的最后一个数据的迭代器,则结点指针指向空,表明最后一个数据的下一个结点.
Self& operator++(){if (_node->_next) //在当前桶中迭代{_node = _node->_next;}//如果该哈希桶迭代完毕,则在哈希表中找下一个哈希桶迭代寻找.else{KeyOfT kot;Hash hash;size_t hashi = hash(kot(_node->_data)) % _pht->_table.size(); //迭代器访问哈希表的私有成员size_t i = hashi + 1;for (; i < _pht->_table.size(); ++i){if (_pht->_table[i]){_node = _pht->_table[i];break; //++完就退出.}}if (i == _pht->_table.size()) //此时,这也说明正式哈希桶迭代器的end.{_node = nullptr;}}return *this;}
哈希表插入函数的修改(适用于unordered_map)
为了支持unordered_map中的[]操作符重载,我们针对哈希表中的插入函数返回值进行修改
(1): 如果哈希表中已有所给数据,则返回已有数据的迭代器与插入结果(失败)所构成的键值对.
(2): 如果哈希表没有所给数据,则将新数据头插该哈希桶组成的单链表上,返回新插入结点指针构造与插入结果(成功)组成的键值对.
插入函数代码如下:
pair< Iterator,bool> Insert(const T& data){Hash hash;KeyOfT kot; Iterator ret = Find(kot(data)); if (ret != end()){return make_pair( ret, false);}if (_size == _table.size()) //扩容.{// size_t newSize = _table.size() == 0 ? 10 : 2 * _table.size();vector<Node*> newTable;newTable.resize(GetNextPrime(_table.size()), nullptr); Hash hash;//从旧表结点移动映射新表.for (size_t i = 0; i < _table.size(); ++i){Node* cur = _table[i];while (cur){Node* next = cur->_next;size_t hashi = hash(kot(cur->_data)) % newTable.size();cur->_next = newTable[hashi];newTable[hashi] = cur;cur = next;}_table[i] = nullptr;}_table.swap(newTable);}size_t hashi = hash(kot(data)) % _table.size();Node* newNode = new Node(data);newNode->_next = _table[hashi];_table[hashi] = newNode;++_size;return make_pair(Iterator(newNode,this),true); //如果是新插入的数据,则返回新插入结点构造的迭代器与插入结果组成的pair.}
一个类型K去做set和unordered_set他的模板参数的必备条件.
set容器模板参数:
(1):set模板参数要求能够支持小于比较,例如:二叉搜索树查找成员函数中,我们可以利用compare仿函数将当前结点值与所给值比较,从而决定cur遍历左子树还是右子树,为了能够支持大于比较的,我们可以交换一下实参位置,这也间接支持了大于比较.并且条件判断,进而也支持了等于.
unordered_set容器模板参数要求:
(1)针对于K类型(指针,打浮点数,有符号整型)可以转换为无符号整数取模.对于string,日期类类型,这两个类型与整型类型无关的,此时不可以直接强转为整数,需要相应的提供将该类型转换为整数的仿函数.
(2):K类型对象能够支持等于比较(因为在查找中就是要确定存储的对象与所传的对象是否相等,例如Data日期类),如果不支持需要额外提供等于比较的仿函数.
unordered_set的模拟实现(完整代码)
在上述中,我们已经将unordered_set重点内容讲解完毕,剩下的成员函数只需要复用哈希表中的就可以了.
namespace yzh
{//2:因为我们使用map,set是将实参传给,map,set的所以当string类型取模时要在map,set中写仿函数.template < class K,class Hash = HashFunc<K>> //1:由第二个模板参数决定要存储的数据.class unordered_set{struct SetKeyOfT //根据map还是set传递不同数据类型给底层.{const K& operator()(const K& key){return key;}};public:typedef typename HashBucket::HashTable< K,K,Hash,SetKeyOfT>::Iterator iterator; //重新定义一下迭代器类型为iterator.iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}pair<iterator,bool> Insert(const K& key){return _ht.Insert(key);}private:HashBucket::HashTable<K,K,Hash,SetKeyOfT> _ht;};void test_set() //测试{unordered_set<int> set;set.Insert(1);set.Insert(2);set.Insert(3);unordered_set<int>::iterator it = set.begin();while ( it != set.end() ){cout << *it << " ";++it;}cout << endl;}}
unordered_map的实现(完整代码)
在上述中,我们已经将unordered_map重点内容讲解完毕,剩下的成员函数只需要复用哈希表中的就可以了.
namespace yzh
{template < class K, class V, class Hash = HashFunc<K> > //由第二个模板参数决定要存储的数据类型,class unordered_map{struct MapKeyOfT //根据map还是set传递不同数据类型给底层.{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename HashBucket::HashTable< K, pair<K, V>, Hash, MapKeyOfT>::Iterator iterator;//重新定义一下迭代器类型为iterator.iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}pair<iterator,bool> Insert( const pair<K, V>& kv ){return _ht.Insert(kv);}V& operator[]( const K& key ) //给一个key,返回V的引用.{pair<iterator, bool> ret = _ht.Insert(make_pair(key, V())); //如果插入失败,返回已有数据的迭代器与返回结果组成的pair. //如果插入成功,返回新插入数据的迭代器与返回结果组成的pair.return ret.first->second;}private:HashBucket::HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht; //map和set都知道传递什么来类型的仿函数,以及要传递的数据类型.};void test_map(){unordered_map<string, string> dict;dict.Insert(make_pair("sort", "排序"));dict.Insert(make_pair("string", "排序"));unordered_map<string,string>::iterator it = dict.begin();while (it != dict.end()){cout << it->first << ":" << it->second << endl;++it;}}void testmap1(){unordered_map<string, int> countMap;string arr[] = { "苹果","西瓜","苹果","西瓜","苹果","西瓜","苹果","香蕉" };for (auto& e : arr){countMap[e]++;}for (auto& kv : countMap){cout << kv.first << ":" << kv.second << endl;}}}
适用于unordered_set和unordered_map的哈希表代码
#include <map>
#include <vector>
#include <string>
#include <string>
#include <iostream>
using namespace std;
template < class K > //仿函数的默认值,如果不显示传就会默认调用.
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};template< > //1:对于常见类型,为了方便,我们可以对类模板进行特化.
struct HashFunc <string> //并且根据实参所传类型,优先走特化版本.
{size_t operator()(const string& key){size_t val = 0;for (auto& ch : key) //遍历string,将一个个字母替换成ASCI码进行相加.{val += ch;}return val;}
};
namespace HashBucket
{template < class T >struct HashNode{T _data;HashNode<T>* _next;HashNode(const T& data):_data(data), _next(nullptr){}};template < class K, class T, class Hash, class KeyOfT >class HashTable;template < class K, class T, class Hash, class KeyOfT >struct _HashIterator{typedef HashNode<T> Node;typedef HashTable< K, T, Hash, KeyOfT> HT;typedef _HashIterator< K, T, Hash, KeyOfT> Self;Node* _node;HT* _pht;_HashIterator( Node* node,HT* pht ):_node(node), _pht(pht){}T& operator*(){return _node->_data;}T* operator->(){return &_node->_data;}Self& operator++(){if (_node->_next) //在当前桶中迭代{_node = _node->_next;}//如果该哈希桶迭代完毕,则在哈希表中找下一个哈希桶迭代寻找.else{KeyOfT kot;Hash hash;size_t hashi = hash(kot(_node->_data)) % _pht->_table.size(); //迭代器访问哈希表的私有成员size_t i = hashi + 1;for (; i < _pht->_table.size(); ++i){if (_pht->_table[i]){_node = _pht->_table[i];break; //++完就退出.}}if (i == _pht->_table.size()) //此时,这也说明正式哈希桶迭代器的end.{_node = nullptr;}}return *this;}bool operator!=( const Self& s ) const{return _node != s._node;}bool operator==( const Self& s )const {return _node == s._node;}};template < class K, class T, class Hash, class KeyOfT >struct HashTable{typedef HashNode<T> Node;template < class K, class T, class Hash, class KeyOfT > //为了迭代器能够访问哈希表的私有成员,我们设为迭代器是哈希表的//友元,类模板声明友元需要增加类模板.friend struct _HashIterator;public:typedef _HashIterator< K, T, Hash, KeyOfT> Iterator;Iterator begin()//获取第一个迭代器{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);}size_t GetNextPrime(size_t prime){const int PRIMECOUNT = 28;//素数序列const size_t primeList[PRIMECOUNT] ={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 = 0; i < PRIMECOUNT; i++){if (primeList[i] > prime) //从这个数组里面取第一个大于prime的值.return primeList[i];}return primeList[i]; //虽然数据不可能那么大,但是也有可能不会走if判断,// 所以从语法上来说还要考虑所给值prime大于素数数组整个数据的情况.}~HashTable() //vvector会调用析构函数,但是哈希桶必须自己写.{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;}// cout << "~HushTable()" << endl;}bool Erase(const K& key){if (_table.size() == 0){return true;}Hash hash;size_t hashi = hash(key) % _table.size();Node* prev = nullptr;Node* cur = _table[hashi];while (cur){if (cur->_kv.first == key){if (prev == nullptr){_table[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;--_size;return true;}prev = cur;cur = cur->_next;}return false;}pair< Iterator,bool> Insert(const T& data){Hash hash;KeyOfT kot;//去重Iterator ret = Find(kot(data)); //如果该数据已经有了,则返回已有数据的迭代器与插入结果构成的pair.if (ret != end()){return make_pair( ret, false);}if (_size == _table.size()) //扩容.{// size_t newSize = _table.size() == 0 ? 10 : 2 * _table.size();vector<Node*> newTable;newTable.resize(GetNextPrime(_table.size()), nullptr); //扩容Hash hash;//从旧表结点移动映射新表.for (size_t i = 0; i < _table.size(); ++i){Node* cur = _table[i];while (cur){Node* next = cur->_next;size_t hashi = hash(kot(cur->_data)) % newTable.size();cur->_next = newTable[hashi];newTable[hashi] = cur;cur = next;}_table[i] = nullptr;}_table.swap(newTable);}size_t hashi = hash(kot(data)) % _table.size();Node* newNode = new Node(data);newNode->_next = _table[hashi];_table[hashi] = newNode;++_size;return make_pair(Iterator(newNode,this),true); //如果是新插入的数据,则返回新插入结点构造的迭代器与插入结果组成的pair.}Iterator Find(const K& key){if (_table.size() == 0) //表为空,就返回nullptr.{return end();}Hash hash;KeyOfT kot;size_t hashi = hash(key) % _table.size();Node* cur = _table[hashi];while (cur){if (kot(cur->_data) == key){return Iterator(cur, this);}cur = cur->_next;}return end();}size_t size(){return _size;}size_t TablesSize() //表的长度{return _table.size();}size_t BucketNum() //有多少个桶被用了.{size_t Num = 0;for (size_t i = 0; i < _table.size(); ++i){if (_table[i]){++Num;}}return Num;}size_t MaxBucketLenth(){size_t maxLen = 0;for (size_t i = 0; i < _table.size(); ++i){size_t len = 0;Node* cur = _table[i];while (cur){++len;cur = cur->_next;}if (len > maxLen){maxLen = len;}}return maxLen;}private:vector<Node*> _table;size_t _size = 0;};
}