链地址法（哈希桶）

解决冲突的思路

开放定址法中所有的元素都放到哈希表⾥，链地址法中所有的数据不再直接存储在哈希表中，哈希表 中存储⼀个指针，没有数据映射这个位置时，这个指针为空，有多个数据映射到这个位置时，我们把这些冲突的数据链接成⼀个链表，挂在哈希表这个位置下⾯，链地址法也叫做拉链法或者哈希桶。

扩容

开放定址法负载因⼦必须⼩于1，链地址法的负载因⼦就没有限制了，可以⼤于1。负载因⼦越⼤，哈 希冲突的概率越⾼，空间利⽤率越⾼；负载因⼦越⼩，哈希冲突的概率越低，空间利⽤率越低；stl中 unordered_xxx的最⼤负载因⼦基本控制在1，⼤于1就扩容，我们下⾯实现也使⽤这个⽅式。

下⾯演⽰ {19,30,5,36,13,20,21,12,24,96} 等这⼀组值映射到M=11的表中

h(19) = 8，h(30) = 8，h(5) = 5，h(36) = 3，h(13) = 2，h(20) = 9，h(21) = 10，h(12) = 1,h(24) = 2,h(96) = 88

哈希桶实现代码：

namespace hash_bucket
{//仿函数template<class K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//string用得多，特化一下template<>struct HashFunc<string>{size_t operator()(const string& s){size_t hash = 0;for (auto ch : s){hash += ch;}return hash;}};template<class K,class V>struct HashNode{pair<K, V> _kv;HashNode<K, V>* _next;//别定义成pair了HashNode(const pair<K,V>& kv):_kv(kv),_next(nullptr){}};template<class K,class V,class Hash=HashFunc<K>> class HashTable{typedef HashNode<K, V> Node;public:HashTable():_tables(__stl_next_prime(0)),_n(0){}//vector里面存的是内置类型Node*而不是自定义类型，所以要自己处理//如果析构需要自己写那么拷贝构造和赋值重载也得自己写~HashTable(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];	while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;//}}Hash hash;//Node* Find(const K& key){size_t hashi = hash(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (key == cur->_kv.first){return cur;}cur = cur->_next;}return nullptr;}bool Erase(const K& key){size_t hashi = hash(key) % _tables.size();Node* cur = _tables[hashi];Node* prev = nullptr;//要记录while (cur){if (key == cur->_kv.first){//分两种情况处理if (prev == nullptr)//要删除的是头结点{_tables[hashi] = cur->_next;}else//删除的不是头结点{prev->_next = cur->_next;}delete cur;--_n;return true;}prev = cur;cur = cur->_next;}return false;}bool Insert(const pair<K,V>& kv){if (_n == _tables.size()){vector<Node*> newtables(__stl_next_prime(_tables.size())+1);for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;size_t hashi = hash(cur->_kv.first) % newtables.size();cur->_next = newtables[hashi];newtables[hashi] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newtables);//}//头插size_t hashi = hash(kv.first) % _tables.size();Node* newnode = new Node(kv);newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n;return true;}private:vector<Node*> _tables;size_t _n=0;//自己造轮子/*struct Data{ListNode* _head;RBTreeNode* _root;size_t len;};*///套两个结构在里面/*struct Date{list<pair<K, V>> _list;map<pair<K, V>> _map;size_t len;};vector<Data> _tables;size_t _n = 0;*/};

Tips:

• 在扩容时，我们不再像开放定址法为了复用Insert而创建一个HashTable而是创建一个新vector，因为Insert里要创建新节点，然后swap之后带走旧表时又要释放这些结点，一来一回消耗比较大；直接用新vector，把原vector挂的结点直接“拿”到新表就可以了。
• 如果觉得挂的链表太长了，可以换成比如_n>8就换挂红黑树，创建一个结构体Data，里面存储的可以是自己“造轮子”的也可以直接用list和map这两个结构（就可以直接用自带的接口）。如果减到比如8个以下了再换回链表。
• vector里面存的是内置类型Node*而不是自定义类型，所以要自己处理，否则不会被处理；如果析构函数需要自己实现，那么赋值重载和拷贝构造也需要自己实现，深拷贝。