一.哈希表：

1.直接定址法：

1.数据比较集中并且数据都比较小。
2.使用key值作为下标进行数据的存贮。
3.适用于数据比较小并且连续的情况。

字符串中第一个唯一字符

2.闭散列的开放定址法：

1.基本结构：

namespace oper_addres {enum state {Empty,Delete,Exist,};template<class k, class v>struct Hash_Node {Hash_Node(pair<k, v> x = pair<k,v>()):_date(x),_state(Empty){}pair<k, v> _date;state _state;};template<class k, class v>class Hash {public:Hash(size_t n = 10){_hash.resize(n);}private:vector<Hash_Node<k, v>> _hash;size_t _num = 0;};
}

2.insert

1.不存在重复数据：除留余数法，1%10==1 下标1位置放置数值1，4%10=4 下标4位置放置数值4，以此类推。

2.存在重复数据->线性探测->7%10=7 ,下标7位置放置数值7，17%10=7 下标7位置有值就向后放置下标8就放置17，27%10=7下标7位置有值 下标8位置有值下标9放置，++然后取模找到可以放置值的位置结束。

3.如何确定这个位置的值情况？
提供枚举常量 ：Empty Delete Exist

4.扩容+数值拷贝：每插入一个值都需要计算负载因子 = 当前插入的数据量/可以插入的size 当这个差值>=0.7就需要进行扩容，新建一个newhashtable大小为当前表的两倍，新的表使用insert插入原来哈希表数据最后交换两个哈希表的vector。

		bool insert(pair<k, v> x){//扩容：size_t tmp = ((_num * 10) / _hash.size());if (tmp >= 7){Hash<k, v>* newhash = new Hash<k, v>(_hash.size() * 2);for (auto e : _hash){newhash->insert(e._date);}_hash.swap(newhash->_hash);}//1.正常插入：插入位置size_t indx = x.first % _hash.size();//2.进行插入：if ((_hash[indx]._state) != Empty || (_hash[indx]._state) == Delete){//向后查找->线性探测：while (_hash[indx]._state == Exist){indx++;indx %= _hash.size();}_hash[indx]._date = x;_hash[indx]._state = Exist;_num++;return true;}_hash[indx]._date = x;_hash[indx]._state = Exist;_num++;return true;}

3.find

1.find数据传参查找的数据并且返回数据的下标。
2.数据%hashtable.size(),对应下标位置就是这个值返回下标，如果不是线性探测直到空为止。数据不存在返回-1.

			int find(const k& fd){size_t Hashi = fd % _hash.size();if (_hash[Hashi]._state == Exist && _hash[Hashi]._date.first == fd){return Hashi;}else{while (_hash[Hashi]._date.first != fd && _hash[Hashi]._state != Empty){Hashi++;Hashi %= _hash.size();}if (_hash[Hashi]._date.first == fd && _hash[Hashi]._state == Exist)return Hashi;elsereturn -1;}}

4.erase

1.这个地方首先使用find找到对应的下标位置进行返回。
2.找到就修改这个位置的状态为Delete，并且返回true。

bool erase(const k& fd){int hashi = find(fd);if (hashi != -1){_hash[hashi]._state = Delete;return true;}return false;}

5.补充：

size_t size(){return _num;}bool empty(){if (_num == 0)return true;return false;}

1.哈希冲突？
2.数据%hashtable.size()同一个位置的数据然后进行线性探测，线性探测的次数越多哈希冲突越多。哈希冲突越多，效率就越低。
3.当因子大于0.7就考虑进行扩容。

6.pair<k,v> k的数据类型：

1.数据类型的一个转换考虑如何变成下标可以识别的size_t类型。
2.实现仿函数，并且重载operator()
3.特殊类型可以使用类模板的特化。

template<class T>struct transition{size_t operator()(const T& x){return x;}};//1.string -> stringtemplate<>struct transition<string>{size_t operator()(const string& x){//1.可以计算string字符串的asia码的和并且每次*131降低哈希冲突：size_t sum = 0;for (auto& e : x){sum += (e*131);}return sum;}};

3.开散列的拉链法/哈希桶：

1.开散列,首先对于key值计算出下标位置，具有相同下标位置的值放在同一个子集里面，每一个子集就是一个桶，每一个桶中的元素通过一个单链表连接在一起，每一个链表的头节点由vector保存

1.基本结构：

namespace Hash_bucket{template<class T>struct transition{size_t operator()(const T& x){return x;}};//1.string -> stringtemplate<>struct transition<string>{size_t operator()(const string& x){//1.可以计算string字符串的asia码的和并且每次*131降低哈希冲突：size_t sum = 0;for (auto& e : x){sum += (e * 131);}return sum;}};template<class k, class v>struct Hash_Node {typedef Hash_Node Node;Hash_Node(pair<k, v> x = pair<k, v>()):_date(x),_next(nullptr){}pair<k, v> _date;Node* _next;};//, class trans = transition<k>template<class k, class v, class trans = transition<k>>class Hash {public:typedef Hash_Node<k, v> Node;Hash(size_t n = 10){_hash.resize(n,nullptr);_num = 0;}private:vector<Node*> _hash;size_t _num;};
}

2.insert

1.正常插入：

bool insert(const pair<k, v>& x){//1.正常插入：trans kot;size_t hashi = kot(x.first) % _hash.size();Node* newnode = new Node(x);//1-1:_hash[hashi]==nullptr 直接插入节点：if (_hash[hashi] == nullptr){_hash[hashi] = newnode;_num++;return true;}//1-2：_hash[hashi]!=nullptr 进行单链表的头插：else{newnode->_next = _hash[hashi];_hash[hashi] = newnode;_num++;return true;}return false;}

2.考虑扩容

1,什么时候需要取进行扩容？
2.当我们的vector<Node*> _hash;每一个下标处都有非空节点就进行扩容。
3.扩容需要考虑原来链表中保存的节点并且考虑进行重新的插入数据。
4.节点数据不需要先delete后new，直接进行简单连接的转移。
5.开头使用find可以帮助我们判断要插入的这个节点之前存不存在。

		bool insert(const pair<k, v>& x){if (find(x.first))return false;trans kot;//1.计算平衡因子：if (_num == _hash.size()){vector<Node*> newhash(_hash.size() * 2, nullptr);for(int i=0;i<_hash.size();i++){Node* cur = _hash[i];while (cur){Node* next = cur->_next;// 头插到新表size_t hashi = kot(cur->_date.first) % (_hash.size()*2);cur->_next = newhash[hashi];newhash[hashi] = cur;cur = next;}_hash[i] = nullptr;}_hash.swap(newhash);}else{//1.正常插入size_t hashi = kot(x.first) % _hash.size();Node* newnode = new Node(x);//1-1:_hash[hashi]==nullptr 直接插入节点：newnode->_next = _hash[hashi];_hash[hashi] = newnode;_num++;return true;}return false;}

3.find

1.%_hash.size()快速确定下标位置。
2.通过cur遍历单链表找到值相同的节点就返回。
3.找不到就返回空节点。

Node* find(const k& fd)
{trans kot;size_t i = kot(fd) % _hash.size();Node* cur = _hash[i];while (cur){if (cur->_date.first == fd)return cur;cur = cur->_next;}return nullptr;
}

4.erase

1.%_hash.size()快速确定下标位置。
2.两个情况：
2-1：_hash[hashi]保存的就是需要删除的节点
2-1：需要删除的节点在单链表中。

bool erase(const k& fd){trans kot;size_t i = kot(fd) % _hash.size();Node* cur = _hash[i];Node* prev = nullptr;while (cur){if (cur->_date.first == fd){//头节点就是需要删除的if (prev == nullptr){_hash[i] = cur->_next;}//在单链表中的节点需要被删除：else{prev->_next = cur->_next;}return true;}prev = cur;cur = cur->_next;}return false;}

5.数据计算观察：

		void Some(){size_t bucketSize = 0;size_t maxBucketLen = 0;size_t sum = 0;double averageBucketLen = 0;for (size_t i = 0; i < _hash.size(); i++){Node* cur = _hash[i];if (cur){++bucketSize;}size_t bucketLen = 0;while (cur){++bucketLen;cur = cur->_next;}sum += bucketLen;if (bucketLen > maxBucketLen){maxBucketLen = bucketLen;}}averageBucketLen = (double)sum / (double)bucketSize;//平衡因子printf("load factor:%lf\n", (double)_num / _hash.size());//表长度：printf("all bucketSize:%d\n",_hash.size());//桶的个数：printf("bucketSize:%d\n", bucketSize);//最长的桶的长度printf("maxBucketLen:%d\n", maxBucketLen);//平均桶长度printf("averageBucketLen:%lf\n\n", averageBucketLen);}

二.unordered_set和unordered_map的封装：

1.unordered_set

1.基本结构：

namespace sfpy {template<class k,class transition = transition<k>>class myunset {public:struct copy_set {const k& operator()(const k& x){return x;}};private:Hash_bucket::Hash<k,k,copy_set,transition> _t;};
}

2.插入：

//1.插入：bool Insert(const k& x){pair<iterator, bool> ret = _t.Insert(x);return ret.second;}bool insert(const k& x){return _t.insert(x);}

3.迭代器：

typedef typename Hash_bucket::Hash<k, k, copy_set, transition>::_iterator iterator;iterator begin(){return _t.find_begin();}iterator end(){return nullptr;}

4.find

//3.find()iterator _find(const k& x){return _t.Find(x);}

5.整体代码：

namespace sfpy {template<class k,class transition = transition<k>>class myunset {public:struct copy_set {const k& operator()(const k& x){return x;}};typedef typename Hash_bucket::Hash<k, k, copy_set, transition>::_iterator iterator;//1.插入：bool Insert(const k& x){pair<iterator, bool> ret = _t.Insert(x);return ret.second;}bool insert(const k& x){return _t.insert(x);}//2.迭代器：iterator begin(){return _t.find_begin();}iterator end(){return nullptr;}//3.find()iterator _find(const k& x){return _t.Find(x);}private:Hash_bucket::Hash<k,k,copy_set,transition> _t;};
}

2.unorder_map

1.基本结构：

namespace sfpy {template<class k , class v , class transition = transition<k>>class myunmap {public:struct copy_map{const k& operator()(const pair<k,v>& x){return x.first;}};private:Hash_bucket::Hash<k,pair<k,v>, copy_map , transition> _t;};
}

2.插入：

//1.插入：bool Insert(const pair<k, v> x){pair<iterator, bool> ret = _t.Insert(x);return ret.second;}bool insert(const pair<k, v> x){return _t.insert(x);}

3.迭代器：

typedef typename Hash_bucket::Hash<k, pair<k, v>, copy_map, transition>::_iterator iterator;//2.迭代器iterator begin(){return _t.find_begin();}iterator end(){return  _t.find_end();}

4.find

iterator _find(const k& x){return _t.Find(x);}

5.operator[]重载：

v& operator[](const k& key){pair<iterator, bool> ret = _t.Insert(make_pair(key,v()));return ret.first->second;}

6.整体代码：

namespace sfpy {template<class k , class v , class transition = transition<k>>class myunmap {public:struct copy_map{const k& operator()(const pair<k,v>& x){return x.first;}};typedef typename Hash_bucket::Hash<k, pair<k, v>, copy_map, transition>::_iterator iterator;//1.插入：bool Insert(const pair<k, v> x){pair<iterator, bool> ret = _t.Insert(x);return ret.second;}bool insert(const pair<k, v> x){return _t.insert(x);}//2.迭代器iterator begin(){return _t.find_begin();}iterator end(){return  _t.find_end();}//3.find()iterator _find(const k& x){return _t.Find(x);}v& operator[](const k& key){pair<iterator, bool> ret = _t.Insert(make_pair(key,v()));return ret.first->second;}private:Hash_bucket::Hash<k,pair<k,v>, copy_map , transition> _t;};
}

7.补充代码：

1.我们知道在unordered_set和unordered_map中key值是不可以被修改的。
2.我们上面的代码是可以修改key值就是一个比较离谱的事情。
3.封装unordered_map和unordered_set对key的类型进行加const。

namespace sfpy {template<class k , class v , class transition = transition<k>>class myunmap {public:struct copy_map{const k& operator()(const pair<const k,v>& x){return x.first;}};typedef typename Hash_bucket::Hash<k, pair<const k, v>, copy_map, transition>::_iterator iterator;//1.插入：bool Insert(const pair<const k, v> x){pair<iterator, bool> ret = _t.Insert(x);return ret.second;}bool insert(const pair<const k, v> x){return _t.insert(x);}//2.迭代器iterator begin(){return _t.find_begin();}iterator end(){return  _t.find_end();}//3.find()iterator _find(const k& x){return _t.Find(x);}v& operator[](const k& key){pair<iterator, bool> ret = _t.Insert(make_pair(key,v()));return ret.first->second;}private:Hash_bucket::Hash<k,pair<const k, v>, copy_map , transition> _t;};
}

3.HashTable

1.map和set去封装同一个哈希表。
2.模板：template<class k , class T, class copy, class trans>
3.copy类重载了operator()做键值的获取。
4.trans是一个类型转换，比如说string转化为一个size_t类型方便下标的使用。

1.find查找：

1.返回查找到的数据的节点或者空指针。
2.数据计算下表并且遍历单链表找到节点返回节点指针。
3.找不到节点就返回nullptr

Node* find(const k& fd){trans up;copy kot;size_t i = up(fd) % _hash.size();Node* cur = _hash[i];while (cur){if ((up(kot(cur->_date))) == up(fd))return cur;cur = cur->_next;}return nullptr;}

2.迭代器：

1.基本结构：

1.迭代器肯定需要封装数据的节点。
2.封装数据的节点够吗？不够！
3.只封装数据的节点重载++在一个单链表的数据还可以，但是进行链表的跳转就无法实现了。
4.考虑封装一个哈希表到迭代器中。
5.迭代器和哈希表会相互封装(上面的类找不到下面的)—>模板+声明放到上面的那个类的上面。

struct unorderediterator{typedef Hash_Node<T> Node;typedef Hash<k, T, copy, trans> HT;typedef unorderediterator<k, T, copy, trans> self;HT* _Hash;Node* _node;unorderediterator(HT* hash, Node* x):_Hash(hash), _node(x){}};

2.operator++

1,情况一：当前节点的下一个不是空直接修改迭代器中节点的内容_node = cur->next
2.情况二：当前节点的下一个是空，求当前单链表所在节点的哈希下表使用节点访问数据进行计算，找到下标之后哈希表向后进行遍历。
2-1：找到一个不是空的就进行_node的修改。
2-2：找不到，表示哈希表一直向后进行遍历到结尾都是空指针。

//主要是要去找节点：self operator++(){trans kot;copy up;//1.情况一：当前节点有下一个节点：if (_node->_next != nullptr)_node = _node->_next;//2.哈希位置的跳转：else{size_t hashi = kot(up(_node->_date)) % _Hash->_hash.size();hashi++;while (hashi < _Hash->_hash.size()){if (_Hash->_hash[hashi]){_node = _Hash->_hash[hashi];break;}hashi++;}if (hashi == _Hash->_hash.size())_node = nullptr;}return *this;}

3.整体代码：

//迭代器：template<class k, class T, class copy, class trans>struct unorderediterator{typedef Hash_Node<T> Node;typedef Hash<k, T, copy, trans> HT;typedef unorderediterator<k, T, copy, trans> self;HT* _Hash;Node* _node;unorderediterator(HT* hash, Node* x):_Hash(hash), _node(x){}T& operator*(){return _node->_date;}T* operator->(){return &(_node->_date);}bool operator!=(const self& bitter)//self* bitter{//比较哈希表中的vector不是iterator？//迭代器==哈希+节点 比较迭代器的地址还是节点的地址？if (this->_node == bitter._node)return false;return true;}//主要是要去找节点：self operator++(){trans kot;copy up;//1.情况一：当前节点有下一个节点：if (_node->_next != nullptr)_node = _node->_next;//2.哈希位置的跳转：else{size_t hashi = kot(up(_node->_date)) % _Hash->_hash.size();hashi++;while (hashi < _Hash->_hash.size()){if (_Hash->_hash[hashi]){_node = _Hash->_hash[hashi];break;}hashi++;}if (hashi == _Hash->_hash.size())_node = nullptr;}return *this;}};

3.插入：

1.bool返回的插入：

1.正常插入：通过key计算下标值。
2.当前Hash[hashi]中已经有数据进行头插操作。
3.当前Hash[hashi]中没有有数据就修改hash[hashi]值。
4.负载因子到1就需要进行扩容操作，负载因子=单链表个数/hash.size()
5.创建一个新的大小为当前哈希表的两倍，遍历原来的链表有key求下标的方法重新进行原来数据的移动，节约了时间，结尾和_node进行哈希表的交换。

bool insert(const T& x){copy kot;trans up;//1.调find函数去查一下当前要插入的数据是否已经存在if (find(kot(x)))return false;//1.计算平衡因子：if (_num == _hash.size()){vector<Node*> newhash(_hash.size() * 2, nullptr);for (int i = 0; i < _hash.size(); i++){Node* cur = _hash[i];while (cur){Node* next = cur->_next;// 头插到新表size_t hashi = up(kot(cur->_date)) % (_hash.size() * 2);cur->_next = newhash[hashi];newhash[hashi] = cur;cur = next;}_hash[i] = nullptr;}_hash.swap(newhash);}else{//1.正常插入size_t hashi = up(kot(x)) % _hash.size();Node* newnode = new Node(x);//1-1:_hash[hashi]==nullptr 直接插入节点：newnode->_next = _hash[hashi];_hash[hashi] = newnode;_num++;return true;}return false;}Node* find(const k& fd){trans up;copy kot;size_t i = up(fd) % _hash.size();Node* cur = _hash[i];while (cur){if ((up(kot(cur->_date))) == up(fd))return cur;cur = cur->_next;}return nullptr;}

2.重载operator[]实现的重载unordered_map独有：

1,重载operator[]一定需要pair<iterator,bool>的插入返回。
2.operator[]不存在就插入，存在就返回value的引用可以进行修改。
3.ret.second 为false表示已经插入过对应的key值。
4.ret.second 为true表示没有插入过对应的key值这一次刚刚插入数据。
5.优化了一个find的查找返回迭代器类型的数据方便pair<iterator,bool>返回。

pair <_iterator, bool> Insert(const T& x){copy kot;trans up;//1.调find函数去查一下当前要插入的数据是否已经存在if (Find(kot(x))._node)return make_pair(Find(kot(x)),false);//1.计算平衡因子：if (_num == _hash.size()){vector<Node*> newhash(_hash.size() * 2, nullptr);for (int i = 0; i < _hash.size(); i++){Node* cur = _hash[i];while (cur){Node* next = cur->_next;// 头插到新表size_t hashi = up(kot(cur->_date)) % (_hash.size() * 2);cur->_next = newhash[hashi];newhash[hashi] = cur;cur = next;}_hash[i] = nullptr;}_hash.swap(newhash);}else{//1.正常插入size_t hashi = up(kot(x)) % _hash.size();Node* newnode = new Node(x);//1-1:_hash[hashi]==nullptr 直接插入节点：newnode->_next = _hash[hashi];_hash[hashi] = newnode;_num++;return make_pair(_iterator(this,newnode), true);}return make_pair(_iterator(this,nullptr),false);}_iterator Find(const k& fd){trans up;copy kot;size_t i = up(fd) % _hash.size();Node* cur = _hash[i];while (cur){if ((up(kot(cur->_date))) == up(fd))return _iterator(this, cur);cur = cur->_next;}return _iterator(this,nullptr);}

#pragma once#include<iostream>
#include<string>
#include<vector>using namespace std;template<class T>
struct transition
{size_t operator()(const T& x){return x;}
};//1.string -> string
template<>
struct transition<string>
{size_t operator()(const string& x){//1.可以计算string字符串的asia码的和并且每次*131降低哈希冲突：size_t sum = 0;for (auto& e : x){sum += (e * 131);}return sum;}
};namespace Hash_bucket
{template<class T>struct Hash_Node {typedef Hash_Node Node;Hash_Node(T x = T()):_date(x),_next(nullptr){}T _date;Node* _next;};//T() ---> int//T() ---> pair<int,int> pair类型：//哈希表和迭代器相互包含需要声明迭代器到哈希表的前面：//类模板的声明需要模板+struct/class + 类名：template<class k, class T, class copy, class trans>struct unorderediterator;template<class k , class T, class copy, class trans>class Hash {template<class K, class T, class copy, class Hash>friend struct unorderediterator;public:typedef Hash_Node<T> Node;typedef unorderediterator<k, T, copy, trans> _iterator;Hash(size_t n = 10){_hash.resize(n,nullptr);_num = 0;}pair <_iterator, bool> Insert(const T& x){copy kot;trans up;//1.调find函数去查一下当前要插入的数据是否已经存在if (Find(kot(x))._node)return make_pair(Find(kot(x)),false);//1.计算平衡因子：if (_num == _hash.size()){vector<Node*> newhash(_hash.size() * 2, nullptr);for (int i = 0; i < _hash.size(); i++){Node* cur = _hash[i];while (cur){Node* next = cur->_next;// 头插到新表size_t hashi = up(kot(cur->_date)) % (_hash.size() * 2);cur->_next = newhash[hashi];newhash[hashi] = cur;cur = next;}_hash[i] = nullptr;}_hash.swap(newhash);}else{//1.正常插入size_t hashi = up(kot(x)) % _hash.size();Node* newnode = new Node(x);//1-1:_hash[hashi]==nullptr 直接插入节点：newnode->_next = _hash[hashi];_hash[hashi] = newnode;_num++;return make_pair(_iterator(this,newnode), true);}return make_pair(_iterator(this,nullptr),false);}_iterator Find(const k& fd){trans up;copy kot;size_t i = up(fd) % _hash.size();Node* cur = _hash[i];while (cur){if ((up(kot(cur->_date))) == up(fd))return _iterator(this, cur);cur = cur->_next;}return _iterator(this,nullptr);}bool insert(const T& x){copy kot;trans up;//1.调find函数去查一下当前要插入的数据是否已经存在if (find(kot(x)))return false;//1.计算平衡因子：if (_num == _hash.size()){vector<Node*> newhash(_hash.size() * 2, nullptr);for (int i = 0; i < _hash.size(); i++){Node* cur = _hash[i];while (cur){Node* next = cur->_next;// 头插到新表size_t hashi = up(kot(cur->_date)) % (_hash.size() * 2);cur->_next = newhash[hashi];newhash[hashi] = cur;cur = next;}_hash[i] = nullptr;}_hash.swap(newhash);}else{//1.正常插入size_t hashi = up(kot(x)) % _hash.size();Node* newnode = new Node(x);//1-1:_hash[hashi]==nullptr 直接插入节点：newnode->_next = _hash[hashi];_hash[hashi] = newnode;_num++;return true;}return false;}Node* find(const k& fd){trans up;copy kot;size_t i = up(fd) % _hash.size();Node* cur = _hash[i];while (cur){if ((up(kot(cur->_date))) == up(fd))return cur;cur = cur->_next;}return nullptr;}bool erase(const T& fd){trans kot;copy up;size_t i = kot(up(fd)) % _hash.size();Node* cur = _hash[i];Node* prev = nullptr;while (cur){if (up(cur->_date) == fd){if (prev == nullptr){_hash[i] = cur->_next;}else{prev->_next = cur->_next;}return true;}prev = cur;cur = cur->_next;}return false;}void Some(){size_t bucketSize = 0;size_t maxBucketLen = 0;size_t sum = 0;double averageBucketLen = 0;for (size_t i = 0; i < _hash.size(); i++){Node* cur = _hash[i];if (cur){++bucketSize;}size_t bucketLen = 0;while (cur){++bucketLen;cur = cur->_next;}sum += bucketLen;if (bucketLen > maxBucketLen){maxBucketLen = bucketLen;}}averageBucketLen = (double)sum / (double)bucketSize;//平衡因子printf("load factor:%lf\n", (double)_num / _hash.size());//表长度：printf("all bucketSize:%d\n",_hash.size());//桶的个数：printf("bucketSize:%d\n", bucketSize);//最长的桶的长度printf("maxBucketLen:%d\n", maxBucketLen);//平均桶长度printf("averageBucketLen:%lf\n\n", averageBucketLen);}//找开始的节点：_iterator find_begin(){for (int i = 0; i < _hash.size(); i++){if (_hash[i]){return _iterator(this, _hash[i]);}}return  _iterator(this, nullptr);}_iterator find_end(){return  _iterator(this, nullptr);}private://指针数组：vector<Node*> _hash;size_t _num;};//迭代器：template<class k, class T, class copy, class trans>struct unorderediterator{typedef Hash_Node<T> Node;typedef Hash<k, T, copy, trans> HT;typedef unorderediterator<k, T, copy, trans> self;HT* _Hash;Node* _node;unorderediterator(HT* hash, Node* x):_Hash(hash), _node(x){}T& operator*(){return _node->_date;}T* operator->(){return &(_node->_date);}bool operator!=(const self& bitter)//self* bitter{//比较哈希表中的vector不是iterator？//迭代器==哈希+节点 比较迭代器的地址还是节点的地址？if (this->_node == bitter._node)return false;return true;}//主要是要去找节点：self operator++(){trans kot;copy up;//1.情况一：当前节点有下一个节点：if (_node->_next != nullptr)_node = _node->_next;//2.哈希位置的跳转：else{size_t hashi = kot(up(_node->_date)) % _Hash->_hash.size();hashi++;while (hashi < _Hash->_hash.size()){if (_Hash->_hash[hashi]){_node = _Hash->_hash[hashi];break;}hashi++;}if (hashi == _Hash->_hash.size())_node = nullptr;}return *this;}};
}