目录
1.哈希概念
2.哈希碰撞
3.解决哈希冲突
4.哈希表闭散列实现
框架：
4.3插入
1.哈希概念
- 线性表以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。线性表查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的比较次数。
假如理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(哈希)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
- 插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
计算方法：关键码(数据)%数组的容量的元素个数（除留余数法）
- 搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比 较，若关键码相等，则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表 (Hash Table)(或者称散列表)
插入579 ，查询任意元素的时间复杂度都是O(1)
2.哈希碰撞
当插入1,11,21,31,41，按计算方法取模的结果都是1 ，不同关键码通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞
- 把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
1. 直接定制法：取关键字的某个线性函数为散列地址：Hash（Key）= 直接把关键码转化哈希地址 优点：简单、均匀缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况
- 如果数据不集中那么会有大量的空间浪费
2. 除留余数法：设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函 数：Hash(key) = key% p(p<=m)m是容量(通常直接使用m就行),将关键码转换成哈希地址
3.解决哈希冲突
解决哈希冲突两种常见的方法是：闭散列和开散列
3.1闭散列
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去(思想)
3.1.线性探测:从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止(实际方法)
size_t start = hash(kv.first) % _tables.size();
size_t i = 0;
size_t index = start;
// 线性探测
while (_tables[index]._status == EXIST)
{
i++;
index =start+ i;
index %= _tables.size();
}3.2.二次探测 线性探测的缺陷是产生冲突的数据堆积在一块（效率会变低），这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测是为了避免该问题；不在一次一次加了，加二次方，如果算出来的哈希地址大于容量，就取模就好像又走了一遍。
size_t start = hash(kv.first) % _tables.size();
size_t i = 0;
size_t index = start;
// 二次探测
while (_tables[index]._status == EXIST)
{
i++;
index =start + i * i;
index %= _tables.size();
}3.3荷载因子
哈希表什么情况下进行扩容？如何扩容？
哈希表的荷载因子a: a=插入的元素/哈希表的容量；这个值a需限制在0.7-0.8之下，达到就扩容；如果不扩容哈希碰撞的可能性就非常大，效率下降。
4.哈希表闭散列实现
框架：
//状态，防止元素被删除后哈希表查询不到一些位置 enum Status { EXIST, EMPTY, DELETE, }; template<class T, class V> struct HashData { pair<T, V> _kv; Status _status = EMPTY; }; //仿函数，字符串需要特殊处理 template<class K> struct Hash // 特化 template<> struct Hash<string> template<class T, class V,class Func=Hash<T>> class HashTable { public: //接口函数 bool Erase(const T& key) HashData<T, V>* Find(const T& key) bool Insert(const pair<T, V>& kv) private: vector<HashData<T, V>> _tables; //插入的元素个数 size_t _n=0; };
4.1.查询
- 查询逻辑：key先取模得到哈希地址，按照哈希地址找，如果不是那么说明，出现过哈希碰撞，找“下一个”位置，直到找到这个数或者找到“下一个”空位置说明没有这个元素
HashData<T, V>* Find(const T& key)
{
if (_tables.size() == 0)
{
return nullptr;
}
//可以先不管这个仿函数，就是取里面的值
Func hash;
size_t start = hash(key)% _tables.size();
size_t i = 0;
size_t index = start;
while (_tables[index]._status != EMPTY)
{
if (_tables[index]._kv.first == key && _tables[index]._status == EXIST)
{
return &_tables[index];
}
i++;
index =start + i * i;
index %= _tables.size();
}
return nullptr;
}
4.2删除
- 删除查询的位置，有就把HashData指针的成员_status改为删除（_DELETE）标记一下，没有就删除失败返回false
bool Erase(const T& key)
{
HashData<T, V>* ret = Find(key);
if (ret == nullptr)
{
return false;
}
else
{
--_n;
ret->_status = DELETE;
return true;
}
}4.3插入
- 插入逻辑：先用Find查询是否有这个元素，有就插入失败，再判断是否需要扩容，插入就好；
bool Insert(const pair<T, V>& kv)
{
HashData<T, V>* ret = Find(kv.first);
if (ret)
{
return false;
}
// 荷载因子到0.7，就扩容
// 荷载因子越小，冲突概率越低，效率越高，空间浪费越多
// 荷载因子越大，冲突概率越高，效率越低，空间浪费越少
if (_tables.size() == 0 || _n * 10 / _tables.size() >= 7)
{
//扩容
size_t newHashSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
HashTable<T, V> newHT;
newHT._tables.resize(newHashSize);
for (size_t i = 0; i < _tables.size(); i++)
{
if (_tables[i]._status == EXIST)
{
newHT.Insert(_tables[i]._kv);
}
}
_tables.swap(newHT._tables);
}
Func hash;
size_t start = hash(kv.first) % _tables.size();
size_t i = 0;
size_t index = start;
// 线性探测 or 二次探测
while (_tables[index]._status == EXIST)
{
i++;
index =start + i * i;
//index =start + i;
index %= _tables.size();
}
_tables[index]._kv = kv;
_tables[index]._status = EXIST;
++_n;
return true;
}4.3.1.荷载因子为0.7了，扩容会导致容量变大，取模：key/哈希表容量，那么这个哈希表的映射关系不符合了；只能全部重新插入了
4.3.2字符串需要怎样插入了？
4.3.2.1仿函数及string的特化
- 能转化为整形的就直接转化，string和自定义类型就需要一个特化版本
//仿函数
template<class K>
struct Hash
{
size_t operator()(const K& key)
{
return key;
}
};
// 特化
template<>
struct Hash<string>
{
size_t operator()(const string& s)
{
size_t value = 0;
for (auto e : s)
{
// BKDR,减少哈希冲突
value *= 31;
value += e;
}
return value;
}
};
