理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

哈希冲突是指在哈希表中，不同的键值经过哈希函数计算后得到相同的哈希值，导致它们被映射到同一个槽位或桶中。这种情况下，就会发生冲突。

哈希冲突可能会导致以下问题：

1. 数据丢失：当两个不同的键值被映射到同一个槽位时，其中一个键值的数据可能会被覆盖。
2. 查找效率下降：在发生冲突的槽位中，需要通过额外的操作来查找目标键值，这会增加查找的时间复杂度。
3. 哈希表性能下降：频繁的哈希冲突会导致哈希表的装载因子增加，使得哈希表的性能下降。

enum State
{EMPTY,//该位置为空EXIST,//该位置已经有元素DLETE//该位置元素已被删除
};template<class K, class V>
struct HashData
{State _state = EMPTY;//标记当前位置的状态pair < K, V> _kv;
};

注意事项：

        可能有朋友疑问问什么有三个状态，而不是直接存在和不存在两种，这点在后面查找中你就明白了

4.1.3哈希表成员变量

template<class K,class V>
class HashTable
{
protected:vector<HashData> _tables;size_t size = 0;//存储数据个数
};

注意事项：

1. 哈希表底层一般使用数组（vector）
2. 哈希表的有效数据个数_n与vector的size不同

4.1.4构造函数：

HashTable(size_t size=10)
{_tables.resize(size);
}

注意事项：
             不要把缺省值给个0，不然后面还要对0的情况进行讨论，不如直接开10个空间

4.1.5查找：

HashData<K,V>* Find(const K&key)
{size_t hash = key % _tables.size();size_t pos = hash;size_t i = 1;while (_tables[pos]._state != EMPTY){if (_tables[pos].state == EXIST && _tables[pos]._kv.first == key)return &_tables[pos];pos += i;if (pos >= _tables.size())return nullptr;}return nullptr;
}

bool Insert(pair<K,V>& kv)
{if (Find(kv.first))return false;size_t hash = key % _tables.size();size_t pos = hash;size_t i = 1;while (_tables[pos]._state == EXIST){pos += i;if (pos >= _tables.size())return false;}_tables[pos]._kv = kv;_tables[pos]._states = EXIST;return true;_size++;
}

1. 查找当前是否存在该值，如果存在，则不插入（哈希表不存同样的数据）
2. 通过哈希函数获取待插入元素在哈希表中的位置，得到哈希地址hashi
3. 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，
   使用线性探测沿当前位置向后找，直到状态为空或删除，才插入

   ---

   但是，上述情况是哈希表未满时，如果满了如何扩容？还有，一定要满了才扩容吗？

我们引入负载因子的概念：α = 有效数据个数 / 哈希表长度

            当负载因子越大，哈希冲突的概率就越大，同时发生哈希踩踏的概率也越大，对于开放定址法，应该控制负载因子小于0.7，超过0.7则扩容。

if (_size * 10 / _tables.size() > 7)//扩容{vector<HashData> newtables(_tables.size() * 2);for (auto hashdata : _tables){pair<K, V>kv = hashdata._kv.first;size_t hash = key % _tables.size();size_t pos = hash;size_t i = 1;while (newtables[pos]._state == EXIST){pos += i;}_tables[pos]._kv = kv;_tables[pos]._states = EXIST;}_tables.swap(newtables);}

1. 线性探测优点：实现非常简单，
2. 线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同 关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降 低。如何缓解呢？

线性探测（一个一个往后找），这种探测方法可能会造成大量的哈希冲突。

那么，有没有什么探测方法能缓解哈希冲突呢？有，那就是二次探测！，因此二次探测为了避免该问题，找下一个空位置的方法为：

while (newtables[pos]._state == EXIST)
{pos = hashi + i*i;//二次探测++i;
}

4.2.2节点：

template<class K,class V>
struct HashNode
{HashNode<K, V> _next;pair<K, v> _kv;HashNode(pair<K,V> kv=pair<K,V>()):_next(nullptr),_kv(kv){}};

4.2.3成员变量：

template<class K, class V>
class HashTable
{typedef HashNode<K, V> Node;
protected:vector<Node*> _tables;size_t _size = 0;
};

template<class K, class V,class Hash=HashFunck<K>>
class HashTable
{typedef HashNode<K, V> Node;
protected:vector<Node*> _tables;size_t _size = 0;
};

HashTable(size_t size=10)
{_tables.resize(size);
}

~HashTable()
{for (auto hash_node : tables){while (hash_node){Node* new_node = hash_node->_next;delete hash_node;hash_node = new_node;}}
}

Node* Find(const K&key)
{size_t hash = Hash(key)%_tables.size();Node* cur = _tables[hash];while (cur){if (cur->_kv.first == key)return cur;cur = cur->_next;}return nullptr;
}

	bool Insert(pair<K, V>& kv){if (Find(kv.first))return false;size_t hash = Hash(key) % _tables.size();Node*cur = _tables[hash];Node* p(kv);p->_next=cur;_tables[hash] = p;_size++;return true;}

if (_size == _tables.size())
{vector<Node*> new_tables(_size*2);for (auto node : _tables){while (node){Node* next = node->_next;size_t hash = Hash(node->_kv.firsh) % new_tables.size();node->_next=new_tables[hash];new_tables[hash] = node;node = next;}}_tables.swap(new_tables);
}

4.2.8 删除

bool Erase(const K& key)
{size_t hash = Hash(key) % _tables.size();Node* cur = _tables[hash];Node* pre = nullptr;while (cur){if (cur->_kv.first == key)break;pre = cur;cur = cur->_next;}if (cur == nullptr)return false;if (pre == nullptr)_tables[hash] = cur->_next;elsepre->_next = cur->_next;delete cur;return true;
}

template<class K>
struct HashFunck
{size_t operator()(K s){return s;}
};
template<>
struct HashFunck<string>
{size_t operator()(const string& s){size_t number=0;
int multiply=31;for (auto ch : s)number = number * multiply + ch;//multiply可以取这些值131, 31 131 1313 13131 131313return number;}
};