哈希及unordered系列实现
unordered_map/unordered_set底层结构
unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构
哈希概念
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( log2N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
- 插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放 - 搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)
例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快
问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？
是不是就出现了不同的值会存储的同一个位置的情况？这就是哈希冲突
哈希冲突
对于两个数据元素的关键字 和 (i != j)，有 ki != kj ，但有：Hash(ki ) == Hash(kj )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
发生哈希冲突该如何处理呢？
哈希函数
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。 哈希函数设计原则：
- 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0
到m-1之间 - 哈希函数计算出来的地址能均匀分布在整个空间中
- 哈希函数应该比较简单
常见哈希函数
-
直接定址法–(常用)
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况 面试题：字符串中第一个只出现一次
字符，以字母的ASCII码值作为关键字，通过ASCII码来索引字母，类似计数排序的思想 -
除留余数法–(常用)
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址 -
平方取中法–(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况 -
折叠法–(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况 -
随机数法–(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。
通常应用于关键字长度不等时采用此法 -
数学分析法–(了解)
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：
假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况
注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突
哈希冲突解决
解决哈希冲突两种常见的方法是：闭散列和开散列
闭散列
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？
线性探测
比如之前例子中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论
上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
插入
- 通过哈希函数获取待插入元素在哈希表中的位置
- 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探
测找到下一个空位置，插入新元素
删除
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素
// 哈希表每个空间给个标记 // EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除 enum State { EMPTY, EXIST, DELETE, };思考：哈希表什么情况下进行扩容？如何扩容
线性探测的实现：insert的插入影响：满了可能死循环，引入负载因子
负载因子 = 表中数据 / 表的大小——衡量哈希表满的程度
表越接近满，插入数据越容易冲突，冲突越多，效率越低
哈希表并不是满了才增容，开放定址法中，一般负载因子到了0.7左右就开始增容
负载因子越小，冲突概率越低，整体效率越高，但是同时浪费的空间也较大
所以负载因子一般取一个折中值
// 注意：假如实现的哈希表中元素唯一，即key相同的元素不再进行插入
> // 为了实现简单，此哈希表中我们将比较直接与元素绑定在一起
> enum State {
> EMPTY,
> EXIST,
> DELETE,
> };
>
> template<class K>
> struct SetKeyOfValue {
> const K& operator()(const std::pair<K, K>& k)
> {
> return k.first;
> }
> };
>
> template<class K, class V>
> struct HashData{
> State _state;
> std::pair<K, V> _data;
>
> HashData()
> :_state(EMPTY)
> {}
> };
>
>
>
> //用除留余数法实现哈希表
> template<class K, class V, class KOfV>
> class HashTable {
>
> private:
> std::vector< HashData<K, V> > _table;
> size_t _size;
>
> public:
> HashTable()
> :_table(std::vector<HashData<K, V>>())
> ,_size(0)
> {}
>
> ~HashTable()
> {
> ;
> }
>
> bool insert(const std::pair<K, V>& data)
> {
> KOfV kofv;
>
> //负载因子 = 表中数据 / 表的大小——衡量哈希表满的程度
> //表越接近满，插入数据越容易冲突，冲突越多，效率越低
> //哈希表并不是满了才增容，开放定址法中，一般负载因子到了0.7左右就开始增容
> //负载因子越小，冲突概率越低，整体效率越高，但是同时浪费的空间也较大
> //所以负载因子一般取一个折中值
> //当负载因子大于等于0.7时哈希表开始增容
> //因为_size 和 size()都是整型，除出来的数据不会为小数，所以用_size*10后再除以size()，判断是否大于等于7
>
> //_table的size一开始是0，要进行判断，否则下面的判断会出现除数是0的情况
> if (_table.size() == 0)
> {
> _table.resize(10);
> }
>
> if (_size * 10 / _table.size() >= 7)
> {
> //1.开辟2两倍的新表(不一定是2两倍)
> //2.将旧表数据拷贝至新表
> //3.释放旧表空间
> int newcapacity = 2 * _table.size();
> std::vector<HashData<K, V>> newtable;
> newtable.resize(newcapacity);
> for (int i = 0; i < _table.size(); ++i)//也可以复用insert将数据插入新表
> {
> if (_table[i]._state == EXIST)
> {
> size_t index = kofv(_table[i]._data);
> newtable[index % newcapacity] = _table[i];
> }
> }
>
> _table.swap(newtable);//将旧表与新表的数据进行交换，_size不需要交换，有效个数没变
>
> }
>
> int pos = kofv(data) % _table.size();
>
> while (_table[pos]._state == EXIST)
> {
> if (data == _table[pos]._data)//如果当前元素已经存在
> {
> return false;
> }
>
> ++pos;
>
> if (pos == _table.size())//到开头位置再继续找
> {
> pos = 0;
> }
> }
>
> _table[pos]._data = data;
> _table[pos]._state = EXIST;
> ++_size;
>
> return true;
> }
>
> HashData<K, V>* find(const K& key)const
> {
> int pos = key % _table.size();
> KOfV koft;
>
> while (_table[pos]._state != EMPTY)
> {
> if (koft(_table[pos]._data == key))
> {
> if (_table[pos]._state == EXIST)
> {
> return &_table[pos];
> }
> else if (_table[pos]._state == DELETE)//此时该元素已经删除了，说明哈希表中已经不存在该元素了
> {
> return nullptr;
> }
> }
>
> ++pos;
>
> if (pos == _table.size())//如果到了哈希表的末尾，则再从头开始遍历
> {
> pos = 0;
> }
> }
>
> //到了这里说明没找到
> return nullptr;
> }
>
> bool erase(const K& key)
> {
> HashData<K, V>* pos = find(key);
> if (pos != nullptr)//表中有该元素，就删除
> {
> pos->_state = DELETE;
> --_size;
> return true;
> }
> else
> {
> return false;
> }
> }
>
> };
线性探测优点：实现非常简单，
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。如何缓解呢？
二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就
是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： = ( + )% m,
或者： = ( - )% m。其中：i = 1,2,3…， H0是通过散列函数Hash(x)对元素的关键码 key 进行
计算得到的位置，m是表的大小。 对于之前的例子中如果要插入44，产生冲突，使用解决后的情况为：
二次探测解决了冲突数据堆积在一起的情况，当发生冲突时，它寻找其他位置的方法为：key % size() + i^2,i = 1,2,3…；不是像线性探测一样逐个向后查找空位置。
研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容
因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷
开散列
开散列概念
开散列法又叫链地址法(开链法/拉链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素
开散列实现
template<class K, class V> //改成链表形式 struct HashData { std::pair<K, V> _data; HashData<K, V>* _next; HashData(const std::pair<K, V> data) :_data(data) ,_next(nullptr) {} }; // 本文所实现的哈希桶中key是唯一的 //用除留余数法实现哈希表 template<class K, class V, class KOfV> class HashTable { friend struct _IHASH_ITERATOR; typedef HashData<K, V>* pnode; typedef _HASH_ITERATOR<K, V, KOfV> iterator; private: std::vector<pnode> _table; size_t _size;//记录有效数据个数 public: HashTable() :_table(std::vector<pnode>()) , _size(0) {} ~HashTable() { clear(); } //不存在重复元素 bool insert(const std::pair<K, V>& data) { KOfV kofv; //_table的size一开始是0 if (_table.size() == 0) { _table.resize(10); } //如果冲突数据都挂接到同一条链表上，效率还是有问题，于是开散列也需要负载因子 //开散列的负载因子为1 if (_size / _table.size() == 1) { //与闭散列步骤相同 //1.先创建2倍的新表 //2.将旧表数据映射到新表 //3.释放旧表 int newcapacity = 2 * _table.size(); std::vector<pnode> newtable; newtable.resize(newcapacity); for (int i = 0; i < _table.size(); ++i) { pnode curr = _table[i]; while (curr) { //获取key在新表中对应的下标 int index = kofv(curr->_data) % newcapacity; pnode next = curr->_next;//保存curr的下一个节点 curr->_next = newtable[index]; newtable[index] = curr;//头插入新表对应的链表 curr = next; } //原表的所有位置需要置空，否则释放时会将原表中的链表也释放掉 _table[i] = nullptr; } //_size不用交换，因为有效数据个数并没有变 _table.swap(newtable); } //先在表中查找data是否已经存在 int pos = kofv(data) % _table.size(); pnode curr = _table[pos]; while (curr) { if (kofv(curr->_data) == kofv(data)) { return false; } curr = curr->_next; } //如果不存在，则头插入对应位置的链表中——头插方便一些 pnode newnode = new HashData<K, V>(data); curr = _table[pos]; newnode->_next = curr;//连接新旧节点 _table[pos] = newnode;//头插新节点 ++_size; return true; } pnode find(const K& key)const { assert(!empty()); int pos = key % _table.size(); KOfV koft; pnode curr = _table[pos]; while (curr) { //找到了 if (kofv(curr->_data) == key) { return curr; } else//没找到继续向下找，直到找到空说明没有该元素 { curr = curr->_next; } } //到了这里说明没找到 return nullptr; } bool erase(const K& key) { assert(!empty()); KOfV kofv; int index = key % _table.size(); //找到删除节点还需要知道其上一个节点是谁，需要将删除节点的前后节点连接起来 pnode parent = nullptr; pnode curr = _table[index]; while (curr) { //找到了 if (kofv(curr->_data) == key) { //判断要删除的节点是不是头节点 //如果是，则将头节点的下一个节点作为头节点 //如果不是，将删除节点的前后连接起来 if (parent == nullptr) { _table[index] = curr->_next; delete curr; } else { parent->_next = curr->_next; delete curr; } //更改_size并返回true --_size; return true; }//继续向下查找 else { parent = curr; curr = curr->_next; } } //走到这里说明key在表中不存在 return false; } size_t size()const { return _size; } bool empty()const { return _size == 0; } void clear() { for (int i = 0; i < _size; ++i) { pnode curr = _table[i]; while (curr) { pnode next = curr->_next; delete curr; curr = next; } _table[i] = nullptr; } _size = 0; } };开散列增容
桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容
Java中的HashMap当桶长度超过8时就改成挂红黑树//开散列的负载因子为1 if (_size / _table.size() == 1) { //与闭散列步骤相同 //1.先创建2倍的新表 //2.将旧表数据映射到新表 //3.释放旧表 int newcapacity = 2 * _table.size(); std::vector<pnode> newtable; newtable.resize(newcapacity); for (int i = 0; i < _table.size(); ++i) { pnode curr = _table[i]; while (curr) { //获取key在新表中对应的下标 int index = kofv(curr->_data) % newcapacity; pnode next = curr->_next;//保存curr的下一个节点 curr->_next = newtable[index]; newtable[index] = curr;//头插入新表对应的链表 curr = next; } //原表的所有位置需要置空，否则释放时会将原表中的链表也释放掉 _table[i] = nullptr; } //_size不用交换，因为有效数据个数并没有变 _table.swap(newtable); }开散列的思考
只能存储key为整形的元素，其他类型怎么解决？
用仿函数解决，实现一个基本的仿函数，再对其他类型进行模板特化，由于实际中string使用的情形十分广泛，所以我们只对string类型进行模板特化// 哈希函数采用处理余数法，被模的key必须要为整形才可以处理，此处提供将key转化为整形的方法 // 整形数据不需要转化 template<class K> struct _Hash { const K& operator()(const K& key) { return key; } }; //string的特化 template <> struct _Hash<std::string> { size_t operator()(const std::string& str) { //使用BKDR字符串哈希算法计算，避免一些无关的字符串转换后值相同，降低冲突 size_t ret = 0; for (int i = 0; i < str.size(); ++i) { ret = ret * 131 + str[i]; } return ret; } }; template <...> class HashTable{ //... //转换成可以取模的形式 size_t HashFunc(const K& key) { _Hash hash; return hash(key); } //... }除留余数法，最好模一个素数，如何每次快速取一个类似两倍关系的素数？
给出一个素数的数组，需要增容时在素数数组中从小到大找一个大于当前容量的素数，作为新的容量大小。
const int PRIMECOUNT = 28; const size_t primeList[PRIMECOUNT] = { 53ul, 97ul, 193ul, 389ul, 769ul, 1543ul, 3079ul, 6151ul, 12289ul, 24593ul, 49157ul, 98317ul, 196613ul, 393241ul, 786433ul, 1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul, 50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul, 1610612741ul, 3221225473ul, 4294967291ul }; size_t GetNextPrime(size_t prime) { size_t i = 0; for(; i < PRIMECOUNT; ++i) { if(primeList[i] > prime) return primeList[i]; } return primeList[i]; }字符串哈希算法
开散列与闭散列比较
应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间
模拟实现unordered_map/unordered_set
哈希表的改造
-
模板参数列表的改造
// K:关键码类型 // V: 不同容器V的类型不同，如果是unordered_map，V代表一个键值对，如果是unordered_set,V为 K // KOfV: 因为V的类型不同，通过value取key的方式就不同，详细见unordered_map/set的实现 // Hash: 哈希函数仿函数对象类型，哈希函数使用除留余数法，需要将Key转换为整形数字才能取模 template<class K, class V, class KOfV, class Hash> class HashTable; -
增加迭代器操作
这里实现的是按照vector的顺序遍历的，如果想像std中的一样，按照插入顺序遍历的话，需要增加一个链表，按照插入顺序尾插数据。但这样的话，数据的删除操作就很鸡肋，时间复杂度为O(N)。于是，可以在每个节点再增加两个指针：linkprev，linknext，这两个指针分别指向当前节点之前插入的那个节点，和之后插入的那个节点，这样结构虽然变复杂了，但迭代器的遍历变得简单了，只需要按照linknext走就行了。// 为了实现简单，在哈希桶的迭代器类中需要用到HashTable本身， // 注意：因为哈希桶在底层是单链表结构，所以哈希桶的迭代器不需要--操作 template<class K, class V, class KOfV, class Hash, class HF = HashTable<K, V, KOfV, Hash>*>//传一个哈希表的指针，以便找到桶的位置 struct _HASH_ITERATOR { typedef HashData<K, V>* pnode; typedef _HASH_ITERATOR<K, V, KOfV, Hash, HF> Self; pnode _pnode; HF _pht; //哈希桶--主要是为了找下一个空桶时候方便 _HASH_ITERATOR(pnode p,HF pht) :_pnode(p) ,_pht(pht) {} V& operator*() { return _pnode->_data; } V* operator->() { return &_pnode->_data; } const Self& operator++() { KOfV kofv; //如果当前节点的下一个节点不为空，则返回下一个节点 //如果下一个节点为空，则往后找不为空的桶，返回它的第一个节点 if (_pnode->_next != nullptr) { _pnode = _pnode->_next; return *this; } else { pnode curr = _pnode; //找到当前节点在哈希表中的索引 size_t i = _pht->HashFunc(kofv(curr->_data)) % _pht->_table.size(); //初始化i为下一个桶的索引 for (++i; i < _pht->_table.size(); ++i) { if (_pht->_table[i])//找到不为空的桶 { _pnode = _pht->_table[i]; return *this; } } //到了这里，说明之后都是空桶了 _pnode = nullptr; return* this; } } //哈希表没有反迭代器 bool operator==(const Self& it) { return _pnode == it._pnode; } bool operator!=(const Self& it) { return _pnode != it._pnode; } }; -
增加通过key获取value操作
template<class K, class V, class KOfV, class Hash> class HashTable { friend struct _HASH_ITERATOR<K, V, KOfV, Hash, HashTable*>; typedef HashData<K, V>* pnode; private: std::vector<pnode> _table; size_t _size;//记录有效数据个数 public: HashTable() :_table(std::vector<pnode>()) , _size(0) {} ~HashTable() { clear(); } //转换成可以取模的形式 size_t HashFunc(const K& key) { Hash hash; return hash(key); } typedef _HASH_ITERATOR<K, V, KOfV, Hash, HashTable*> iterator; iterator begin() { assert(!empty()); //找到从0位置开始第一个不为空的节点 pnode curr = nullptr; for (int i = 0; i < _size; ++i) { curr = _table[i]; if (curr == nullptr) continue; else break; } return iterator(curr, this); } iterator end() { assert(!empty()); return iterator(nullptr, this); } const std::pair<iterator, bool>& insert(const V& data) { KOfV kofv; //_table的size一开始是0 if (_table.size() == 0) { _table.resize(10); } //如果冲突数据都挂接到同一条链表上，效率还是有问题，于是开散列也需要负载因子 //开散列的负载因子为1 if (_size / _table.size() == 1) { //与闭散列步骤相同 //1.先创建2倍的新表 //2.将旧表数据映射到新表 //3.释放旧表 int newcapacity = 2 * _table.size(); std::vector<pnode> newtable; newtable.resize(newcapacity); for (int i = 0; i < _table.size(); ++i) { pnode curr = _table[i]; while (curr) { //获取key在新表中对应的下标 int index = HashFunc(kofv(curr->_data)) % newcapacity; pnode next = curr->_next;//保存curr的下一个节点 curr->_next = newtable[index]; newtable[index] = curr;//头插入新表对应的链表 curr = next; } //原表的所有位置需要置空，否则释放时会将原表中的链表也释放掉 _table[i] = nullptr; } //_size不用交换，因为有效数据个数并没有变 _table.swap(newtable); } //先在表中查找data是否已经存在 int pos = HashFunc(kofv(data)) % _table.size(); pnode curr = _table[pos]; while (curr) { if (kofv(curr->_data) == kofv(data)) { return std::make_pair(iterator(curr, this), false); } curr = curr->_next; } //如果不存在，则头插入对应位置的链表中——头插方便一些 pnode newnode = new HashData<V>(data); curr = _table[pos]; newnode->_next = curr;//连接新旧节点 _table[pos] = newnode;//头插新节点 ++_size; return std::make_pair(iterator(newnode, this), true); } iterator find(const K& key)const { assert(!empty()); int pos = HashFunc(key) % _table.size(); KOfV koft; pnode curr = _table[pos]; while (curr) { //找到了 if (kofv(curr->_data) == key) { return iterator(curr, this); } else//没找到继续向下找，直到找到空说明没有该元素 { curr = curr->_next; } } //到了这里说明没找到 return iterator(nullptr, this); } //返回删除位置的下一个节点 iterator erase(const K& key) { assert(!empty()); KOfV kofv; int index = HashFunc(key) % _table.size(); //找到删除节点还需要知道其上一个节点是谁，需要将删除节点的前后节点连接起来 pnode parent = nullptr; pnode curr = _table[index]; while (curr) { //找到了 if (kofv(curr->_data) == key) { //判断要删除的节点是不是头节点 //如果是，则将头节点的下一个节点作为头节点 //如果不是，将删除节点的前后连接起来 pnode next = curr->_next; if (parent == nullptr) { _table[index] = curr->_next; delete curr; } else { parent->_next = curr->_next; delete curr; } //更改_size并返回下一个节点 --_size; if (next == nullptr) { //找下一个不为空的桶，返回第一个节点 if (_size == 0)//当桶中已经没有元素时，返回空 { next = nullptr; } else { for (int i = index + 1; i < _table.size(); ++i) { //找到不为空的桶 if (_table[i] != nullptr) { next = _table[i]; } } //也有可能当前元素之后就没有元素了，此时也应该返回空，而刚好next本身就为空 } } return iterator(next, this); }//继续向下查找 else { parent = curr; curr = curr->_next; } } //走到这里说明key在表中不存在 return iterator(nullptr, this); } size_t size()const { return _size; } bool empty()const { return _size == 0; } void clear() { for (int i = 0; i < _size; ++i) { pnode curr = _table[i]; while (curr) { pnode next = curr->_next; delete curr; curr = next; } _table[i] = nullptr; } _size = 0; } };
unordered_map
// unordered_map中存储的是pair的键值对，K为key的类型，V为value的类型，HF哈希函数类型
// unordered_map在实现时，只需将HashT的接口重新封装即可
template <class K, class V>
struct MapKeyOfValue {
const K& operator()(const std::pair<K, V>& kv)//要传引用，因为返回值也是引用，形参在函数运行结束后会销毁，返回值就无法再访问了
{
return kv.first;
}
};
template <class K, class V>
class unordered_map {
private:
// 注意我们第二个参数传的的pair，对应HashData的模板T
HashTable<K, std::pair<K, V>, MapKeyOfValue<K, V>, _Hash<K>> _ht;
public:
typedef typename HashTable<K, std::pair<K, V>, MapKeyOfValue<K, V>, _Hash<K>>::iterator iterator;
unordered_map()
{}
~unordered_map()
{}
iterator begin()
{
return _ht.begin();
}
iterator end()
{
return _ht.end();
}
std::pair<iterator, bool> insert(const std::pair<K, V> kv)
{
return _ht.insert(kv);
}
V& operator[](const K& key)
{
std::pair<iterator, bool> ret = _ht.insert(std::make_pair(key, V()));
return ret.first->second;
}
iterator find(std::pair<K, V> kv)
{
return _ht.find(kv);
}
// capacity
size_t size()const
{
return _ht.eize();
}
bool empty()const
{
return _ht.empty();
}
};
unordered_set
template <class K>
struct SetKeyOfValue {
const K& operator()(const K& key)
{
return key;
}
};
template <class K>
class unordered_set {
private:
// 这里的模板K传给HashData就只是一个K类型
HashTable<K, K, SetKeyOfValue<K>, _Hash<K> > _ht;
public:
typedef typename HashTable<K, K, SetKeyOfValue<K>, _Hash<K>>::iterator iterator;
unordered_set()
{}
~unordered_set()
{}
iterator begin()
{
return _ht.begin();
}
iterator end()
{
return _ht.end();
}
std::pair<iterator, bool> insert(const K& key)
{
return _ht.insert(key);
}
};