先前用红黑树封装出了map和set，现在就要用哈希来封装unordered_map和unordered_set（为了简化名称，后面称u_map和u_set），u_map和u_set在学习map时曾了解过，只知道是无序，我还在想，不能排序有啥用呢?原来用于查找数据效率高得很。有了封装map和set的经历，下面的封装就好理解多了，难点基本上都是迭代器和模板参数。
一 模板参数
从u_map和u_set传的模板参数来理解
下图为哈希表接收的模板参数
本文的哈希是开散列的，因为开散列可以更好地解决哈希冲突，所以哈希表中存的就是每个桶中第一个节点的指针，而T就是节点用于存各种数据类型的，也就是说u_map和u_set给哈希表模板传的第二个模板参数就是想要哈希表节点存的类型。接来下看看两个容器在节点存的类型。
节点类内部实现
template<class T>//T为节点所存数据
struct HashNode
{
HashNode(const T& data)
:_data(data)
, _next(nullptr)
{
;
}
T _data;
HashNode<T>* _next;
};u_map实例化的哈希表变量
如下图,u_map存在节点的是一个pair。至于为什么要对K加上const，我想如果了解过map和set的封装的同学肯定能猜到(后面会再提及)。
u_set实例化的哈希表变量
而u_set要节点存的就是一个K类型的，毕竟u_set和set是类似的，只存一个key值，为了让节点可以用一个变量，例如T _data，既可以存u_set的一个key值，又可以存u_map的key和value这两个值，只能让key和value绑在一个结构体上，总不能让节点内多加一个变量吧，u_set又用不了那么多，不就浪费了吗。
综上，传给哈希表的第二个模板参数是节点存的数据的类型，可能是一个pair，也可能是一个K类型的key值。但是哈希表还有其余的模板参数，这就要结合哈希表的实现才能说清楚，如下。
HashBucketTable其余模板参数介绍
第一个就简单了，是专门提供给find这类参数是const K&key的，而T已经介绍过了。
而剩下的两个模板参数都在下面一行代码里了
由于我们前面将u_map的key和value统一为一个值，不仅方便了节点类内变量存储，insert也只要插入一个值就好了，这就说明插入的元素kv可能是个K类型的，也可能是一个pair。
如果是一个pair, 我们要取出里面的key，然后%_table.size()求下标，但是如果u_set调用insert，就可以直接取模，因为这时候的kv就是key, 这就导致这里对不同类型要做不同的处理，借鉴封装map的经验，我们可以用一个仿函数GetKey将key返回，但这也不意味着可以直接取模，如果key是字符串呢，这就要用到第四个模板参数，它就是将一些自定义类型转为整数，然后用于取模，这个仿函数介绍哈希成员函数时会出代码，所以这两个仿函数是互相配合。
map的GetKey
set的GetKey
二 使key不可被修改
当我们大致了解了哈希表的模板参数，还有个大问题前面提了却未解决，u_map和u_set的key都应该是不能修改的，那我们如何实现呢?
1 使u_set的key不可修改
一般来说普通迭代器可以修改节点内的数据，也就是说u_set的普通迭代器可以修改节点内的数据，那不就意味着可以修改key?这样显然是不行的，所以我们要让外部取得iterator定义出的变量具有const_iterator的特性，还是老套路，用typedef重命名来欺骗使用者。
临场发问:typename的作用是什么?
上图中我们自认为是从HashBucketTable这个类内取一个类型，可编译器编译的时候哪知道，假设有一个静态变量a，
访问静态变量a的方式:HashBucketTable<K, pair<const K, V>, GainMapKey>::a，这个形式和前面取iterator不是一模一样吗，编译器哪分得清，而且你类又没实例化，编译器又没办法核实，所以会报错，只能我们写个关键字typename，告诉编译器这是个类型，等实例化了再检查，现在先别报错。
2 使u_map的key不可修改
先前没说为什么要给K加上const，现在可以说了，就是使得K不可修改。
仅仅只是我博客这些功能，u_set也可以通过传const K的方法去实现iterator有const_iterator的作用，但是库里大佬肯定比我想的细致，应该是我没考虑到这种方式对其余功能的阻碍。
三 迭代器实现
这个迭代器的实现则与先前的有些不同，因为当我们++后，如果到空节点了，要去下一个不为空的桶，此时迭代器存的节点指针是没办法找到下一个桶的，这意味着我们需要访问哈希表，所以应该增加一个成员，哈希表指针。
还有个问题，我们需要从深入迭代器实现才可以解决，就是_ht调用返回的pair<iterator,bool>中的iterator和外面u_set的iterator是不同的，因为外部的iterator是const_iterator重定义的，而内部iterator就是普通迭代器，类型已经不匹配了，这是我们自己定义的类型，编译器无法强转，除非我们写了对应的构造函数，编译器才有可能偷偷帮我们转换一下，接来下就带着问题看看迭代器如何支持的这个类型转换。
迭代器代码
template<class K, class T,class KeyofT, class Hashfunc>
class HashBucketTable;
要前置声明,不然迭代器内会不认识哈希表指针
template<class K, class T, class Ptr, class Ref,class KeyofT, class Hashfunc>
struct HashIterator K，KeyofT, Hashfunc是给哈希表的模板参数
{
typedef HashNode<T> Node;
typedef HashIterator<K, T, Ptr, Ref, KeyofT, Hashfunc> Self;
重命名为Self, 方便下面使用，模板参数变量也只需要改这里
typedef HashIterator<K, T, T*,T&,KeyofT, Hashfunc> iterator;
HashIterator(Node* node, const HashBucketTable<K, T, KeyofT, Hashfunc>* pht)
:_node(node)
, _pht(pht)
{
;
}
HashIterator(const iterator& it)
:_node(it._node)
, _pht(it._pht)
{
;
}
Self& operator++()
{
KeyofT kot;
Hashfunc hf;
Node* cur = _node;
if (cur->_next) 下一个节点不为空
{
_node = _node->_next;
}
else 去下一个桶找
{
size_t hashi = (hf(kot(cur->_data)) % _pht->_table.size()) + 1;
while (hashi<_pht->_table.size()) 防止往后找不为空的桶时越界
{
if(!_pht->_table[hashi])
hashi++;
else
{
_node = _pht->_table[hashi];
return *this;
}
}
_node = nullptr; 先前还没返回,说明全是空桶,达到end位置
}
return *this;
}
Ref operator*() 通过控制Ptr和Ref来达到const迭代器的作用
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
bool operator!=(const Self& it)
{
return _node != it._node;
}
bool operator==(const Self& it)
{
return _node == it._node;
}
Node* _node;
const HashBucketTable<K, T, KeyofT, Hashfunc>* _pht; 哈希表指针
};
当HashIterator被实例化为const迭代器， 这个就可以给u_set的insert做类型转换使用，所以我们前面需要定义一个普通迭代器，就是为了这一步
有没有注意到这个成员加了const，首先加上const绝对是可以的，因为限制我们通过_pht这个指针修改哈希表也是合理的。
或许你会说，不对，是因为构造函数是用const的指针接收的。
那就看看下面的，哈希表指针是用this指针初始化的，而this指针的类型是 T*const，这个const不限制赋值，限制了感觉反而不好，举个例子，int* const p1=&a; int*p2=p1;你p1不能修改自己的值，总不能让p2也不能修改自己的值吧，好像不太合理，但如果是const迭代器,那this指针就是const T*const，所以构造函数需要加上const，否则无法匹配，也就是使得哈希表指针这个成员变量要加const。
最后我说一下我之前的一个问题，我想it是const类型的，它的成员也是const类型的，为什么就能赋值给Node* _node, 现在我想明白了,it._node这个的类型是Node*const的，由前面的，这个const不限制，所以可以赋值。
u_map封装代码
u_map的成员函数都是复用_ht变量的函数，比较有意思的就是[]的实现了。
template<class K,class V>
class Unordered_map
{
public:
struct GainMapKey//用来返回pair中的key
{
const K& operator()(const pair<K, V>& data)
{
return data.first;
}
};
typedef HashNode<pair<const K, V>> Node;
typedef typename HashBucketTable<K, pair<const K, V>, GainMapKey>::iterator iterator;
typedef typename HashBucketTable<K, pair<const K, V>, GainMapKey>::const_iterator const_iterator;
pair<iterator,bool> insert(const pair<K,V>& p1)
{
return _ht.insert(p1);
}
bool Erase(const K& k1)
{
return _ht.Erase(k1);
}
iterator find(const K& key) 这里find和_ht.find()返回类型和下面的insert一样
类型是不匹配的，但是构造函数支持了这种类型转换。
{
return _ht.find(key);
}
iterator begin()
{
return _ht.begin();
}
iterator end()
{
return _ht.end();
}
const_iterator begin()const
{
return _ht.begin();
}
const_iterator end()const
{
return _ht.end();
}
V& operator[](const K& p1)
{
pair<iterator,bool> ret=_ht.insert(make_pair(p1,V()));
return (*ret.first).second;
ret.first取得是iterator，*解引用就返回_node->_data的引用，
这个_data对于u_map而言就是一个pair，我们再取second就是[]需要返回的value
}
private:
HashBucketTable<K, pair<const K,V>, GainMapKey> _ht; 偏特化
};u_set封装代码
template<class K>
class Unordered_set
{
public:
struct GainSetKey 为了map和set传模板参数保持一致,set也要传一个GainSetKey
{
const K& operator()(const K& data)
{
return data;
}
};
typedef HashNode<K> Node;
typedef typename HashBucketTable<K,K, GainSetKey>::const_iterator iterator;
typedef typename HashBucketTable<K, K, GainSetKey>::const_iterator const_iterator;
pair<iterator,bool> insert(const K& k1)
{
return _ht.insert(k1);
}
bool Erase(const K& k1)
{
return _ht.Erase(k1);
}
iterator find(const K& key)
{
return _ht.find(key);
}
只提供const版本的begin和end函数，就是为了_ht调用的begin和end函数返回的是const_iterator
const_iterator begin()const
{
return _ht.begin();
}
const_iterator end()const
{
return _ht.end();
}
private:
HashBucketTable<K, K, GainSetKey> _ht; 偏特化
};四 哈希类成员函数介绍
template<class K>
struct DefaultHashfunc
{
size_t operator()(const K& key)
{
return (size_t)key;
}
};
template<>
struct DefaultHashfunc<string> 将string转为整数的仿函数
{
size_t operator()(const string& s)
{
int hash = 1;
for (auto e : s)
hash = hash * 131 + e; BKDR
return (size_t)hash;
}
};
template<class K, class T, class KeyofT, class Hashfunc = DefaultHashfunc<K>>
class HashBucketTable
{
public:
template<class K, class T, class Ptr, class Ref,class KeyofT, class Hashfunc>//友元类的声明
friend struct HashIterator;
HashIterator要访问HashBucketTable的私有成员，所以是
在HashBucketTable对HashIterator友元声明
typedef HashNode<T> Node;
typedef HashIterator<K, T, T*, T&, KeyofT, Hashfunc> iterator;
typedef HashIterator<K, T,const T*,const T&, KeyofT, Hashfunc> const_iterator;
通过传const T*,const T&来达到const迭代器的效果
HashBucketTable()
{
_table.resize(5);
}
析构函数函数
~HashBucketTable()
{
for (size_t i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
while (cur) 找到一个非空桶，遍历链表，delete释放节点
{
Node* next = cur->_next;
_table[i] = next;
delete cur;
cur = next;
}
}
}
iterator begin()
{
for (size_t i = 0; i < _table.size(); i++)//遍历哈希表ht
{
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++)//遍历哈希表ht
{
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);
}
拷贝构造函数
HashBucketTable(const HashBucketTable<K, T, KeyofT, Hashfunc>& ht)
{
KeyofT kot;
Hashfunc hf;
_table.resize(ht._table.size());
for (size_t i = 0; i < ht._table.size(); i++)//遍历哈希表ht
{
Node* cur = ht._table[i];
while (cur)//遍历该桶
{
Node* newnode = new Node(cur->_data);
size_t hashi = hf(kot(cur->_data)) % _table.size();
newnode->_next = _table[hashi];
_table[hashi] = newnode;
cur = cur->_next;//去桶的下一个节点
}
}
}
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 iterator(nullptr,this);
}
bool Erase(const K& key)
{
KeyofT kot;
Hashfunc hf;
iterator ret=find(key);
if(ret._node==nullptr) 没找到节点，返回false
return false;
size_t hashi = hf(key) % _table.size();
Node* pre = nullptr;
Node* cur = _table[hashi];
while (cur)
{
if (kot(cur->_data) == key)
{
if (pre == nullptr)//头删
{
_table[hashi] = cur->_next;//链接
}
else
{
pre->_next = cur->_next;
}
delete cur;
--_size;//负载因子要--
return true;
}
pre = cur;
cur = cur->_next;
}
return false; 没找到,erase失败
}
pair<iterator,bool> insert(const T& kv)
{
KeyofT kot;
Hashfunc hf;
查找该节点是否已经存在
iterator it = find(kot(kv));
if (it._node)//该节点存在，返回该节点迭代器,并且插入失败
return make_pair(it, false);
//扩容
if (_size >= _table.size())
{
size_t newsize = _table.size() * 2;
vector<Node*> newtable;
newtable.resize(newsize);
for (size_t i = 0; i < _table.size(); i++)
{
Node* cur = _table[i]; 搬运旧表上的节点,省得自己new和delete
while (cur)
{
Node* next = cur->_next;
_table[i] = next;
size_t hashi = hf(kot(cur->_data)) % newtable.size();//计算新表映射下标
搬到新表
cur->_next = newtable[hashi];
newtable[hashi] = cur;
cur = next;//搬下个节点
}
}
新旧表交换
_table.swap(newtable);
}
正常插入节点
size_t hasi = hf(kot(kv)) % _table.size();
Node* newnode = new Node(kv);
newnode->_next = _table[hasi];
_table[hasi] = newnode;
_size++;
return make_pair(iterator(newnode,this),true);
}
private:
vector<Node*> _table;
size_t _size = 0;
};
430
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
