哈希的基本原理

一.哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即 O(log2 N)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放；
搜索元素：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表）

例如：数据集合{1，7，5，6，9}

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快

二.哈希冲突

对于两个数据元素的关键字 i 和 j (i != j)，但有：Hash(i) == Hash(j)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞. 把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

例如把44插入上图中即与4发生冲突。

三.哈希函数

引起哈希冲突的一个原因可能是：哈希函数设计不够合理

哈希函数设计原则

哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
哈希函数计算出来的地址能均匀分布在整个空间中
哈希函数应该比较简单

常见的哈希函数
1、 直接定址法--(常用)
        取关键字的某个线性函数为散列地址： Hash（Key）= A*Key + B
        优点：简单、均匀
缺点：需要事先知道关键字的分布情况
        使用场景：适合查找比较小且连续的情况
2、 除留余数法--(常用)

        设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数： Hash(key) = key% p (p<=m),将关键码转换成哈希地址
3. 平方取中法--(了解)
        假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；
        再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址
平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
4、 折叠法--(了解)
        折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
5、 随机数法--(了解)
        选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key), 其中random为随机数函数。
通常应用于关键字长度不等时采用此法
6、数学分析法--(了解)
        设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

四.哈希冲突解决

解决哈希冲突两种常见的方法是：闭散列和开散列

一.闭散列(开放寻址法)

闭散列：当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有
空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？

①插入：

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

比如我们上面举的例子：现在我们需要插入44这个元素，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。

1、通过哈希函数获取待插入元素在哈希表中的位置

2、如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素。

那么如果当前列表已经满了，再插入一个元素呢，很明显我们需要考虑扩容问题，我们引入：

散列表的载荷因子定义为： $\alpha$ = 填入表中的元素个数 / 散列表的长度

$\alpha$ 是散列表装满程度的标志因子，由于表长是定值，与“填入表中的元素个数”成正比，越大填入表中元素越多，产生冲突的可能性越大；反之，越小填入表中的元素越少，产生冲突的可能性就越小；实际上，散列表的平均查找长度是载荷因子的函数，只是不同处理冲突的方法有不同的函数；

对于开放定址法，载荷因子是特别重要因素，应严格限制在0.7-0.8以下；超过0.8，查表时cpu缓存不命中(cache missing)按照指数曲线上升，因此一些采用开放定址法的hash库，如Java的系统库限制了载荷因子为0.75，超过此值将resize散列表。

//大于0.7  防止浮点数可以采用乘10大于7
if (_n * 10 / _tables.size() >= 7)
{HashTable<K, V, Hash> newHT;newHT._tables.resize(_tables.size() * 2);// 旧表重新计算负载到新表for (size_t i = 0; i < _tables.size(); i++){//EXIST见下文删除部分if (_tables[i]._state == EXIST){newHT.Insert(_tables[i]._kv);}}_tables.swap(newHT._tables);
}

那么如果我们插入的元素不是单纯的整形又该怎么办呢？我们应寻找一个处理方法：对于非字符串的元素，我们将其强转为size_t类型，对于字符串类型，我们使用131进制将其转为数字即可。

其过程还是用到了仿函数，模板将string特化一下即可。


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& key){//131进制是科学家发现的冲突极少的进制//自然溢出即可 相当于mod操作size_t hash = 0;for (const auto& ch : key){hash *= 131;hash += ch;}return hash;}
};

插入总代码：


bool Insert(const pair<K, V>& kv)
{if (Find(kv.first))return false;//exit(0);// 扩容if (_n * 10 / _tables.size() >= 7){//size_t newsize = _tables.size() * 2;//vector<HashData<K, V>> newtables(newsize);旧表重新计算负载到新表//for (size_t i = 0; i < _tables.size(); i++)//{}HashTable<K, V, Hash> newHT;newHT._tables.resize(_tables.size() * 2);// 旧表重新计算负载到新表for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]._state == EXIST){newHT.Insert(_tables[i]._kv);}}_tables.swap(newHT._tables);}Hash hs;size_t hashi = hs(kv.first) % _tables.size();// 线性探测while (_tables[hashi]._state == EXIST){++hashi;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._state = EXIST;++_n;return true;
}

线性探测优点：实现非常简单。

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

二次探测：

哈希冲突后，找下一个空位置的方法为

（i=1,2,3...，是通过散列函数Hash(X)对元素的关键码key进行计算得到的位置，m表示表的大小）

即若一个位置x冲突，则去看x + 1 和 x - 1. 若没有空位置再看 x + 4 和 x - 4，以此类推。

研究表明，当表长度为质数且载荷因子不超过0.5时，新表项一定能够插入，而且任何一个位置都不会被探查两次，因此只要表中有一半的位置，就不会存在表满的问题，在搜索时可以不考虑表装满的情况，但在插入时必须确保表的载荷因子不超过0.5，如超过需考虑增容；

代码作者不再展示。

②查找：

找到映射位置后，若不是对应元素，线性往后找即可。

HashData<K, V>* Find(const K& key)
{Hash hs;size_t hashi = hs(key) % _tables.size();//不可能全是满的 负载因子会更新数组大小while (_tables[hashi]._state != EMPTY){if (_tables[hashi]._state == EXIST &&_tables[hashi]._kv.first == key){return &_tables[hashi];}++hashi;hashi %= _tables.size();}return nullptr;
}

③删除：

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

//伪标记
enum State
{EMPTY,EXIST,DELETE
};

bool Erase(const K& key)
{HashData<K, V>* ret = Find(key);if (ret == nullptr){return false;}else{ret->_state = DELETE;_n--;return true;}
}

代码+测试：

#include<vector>
#include<string>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& key){//131进制是科学家发现的冲突极少的进制//自然溢出即可 相当于mod操作size_t hash = 0;for (const auto& ch : key){hash *= 131;hash += ch;}return hash;}
};// 开放寻址法
namespace open_address
{enum State{EMPTY,EXIST,DELETE};template<class K, class V>struct HashData{pair<K, V> _kv;State _state = EMPTY;};template<class K, class V, class Hash = HashFunc<K>>class HashTable{public:HashTable(){//初始化大小_tables.resize(10);}bool Insert(const pair<K, V>& kv){if (Find(kv.first))return false;//exit(0);// 扩容if (_n * 10 / _tables.size() >= 7){//size_t newsize = _tables.size() * 2;//vector<HashData<K, V>> newtables(newsize);旧表重新计算负载到新表//for (size_t i = 0; i < _tables.size(); i++)//{}HashTable<K, V, Hash> newHT;newHT._tables.resize(_tables.size() * 2);// 旧表重新计算负载到新表for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]._state == EXIST){newHT.Insert(_tables[i]._kv);}}_tables.swap(newHT._tables);}Hash hs;size_t hashi = hs(kv.first) % _tables.size();// 线性探测while (_tables[hashi]._state == EXIST){++hashi;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._state = EXIST;++_n;return true;}HashData<K, V>* Find(const K& key){Hash hs;size_t hashi = hs(key) %_tables.size();//不可能全是满的 负载因子会更新数组大小while (_tables[hashi]._state != EMPTY){if (_tables[hashi]._state == EXIST &&_tables[hashi]._kv.first == key){return &_tables[hashi];}++hashi;hashi %= _tables.size();}return nullptr;}bool Erase(const K& key){HashData<K, V>* ret = Find(key);if (ret == nullptr){return false;}else{ret->_state = DELETE;_n--;return true;}}private:vector<HashData<K, V>> _tables;size_t _n = 0; //有效数据个数};void TestHT1(){int a[] = { 10001,11,55,24,19,12,31 };HashTable<int, int> ht;for (auto e : a){ht.Insert(make_pair(e, e));}cout << ht.Find(55) << endl;cout << ht.Find(31) << endl;ht.Erase(55);cout << ht.Find(55) << endl;cout << ht.Find(31) << endl;}void TestHT2(){int a[] = { 10001,11,55,24,19,12,31 };HashTable<int, int> ht;for (auto e : a){ht.Insert(make_pair(e, e));}ht.Insert(make_pair(32, 32));ht.Insert(make_pair(32, 32));}struct Person{//string _id;string _name;int _age;string school;};// 21：15// key不支持强转整形取模，那么就要自己提供转换成整形仿函数//void TestHT3()//{//	HashTable<Person, int> xxht;//	//HashTable<string, int, StringHashFunc> ht;//	HashTable<string, int> ht;//	ht.Insert(make_pair("sort", 1));//	ht.Insert(make_pair("left", 1));//	ht.Insert(make_pair("insert", 1));//	cout << StringHashFunc()("bacd") << endl;//	cout << StringHashFunc()("abcd") << endl;//	cout << StringHashFunc()("aadd") << endl;//}void test_map1(){string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜","苹果", "香蕉", "苹果", "香蕉","苹果","草莓", "苹果","草莓" };unordered_map<string, int> countMap;for (auto& e : arr){countMap[e]++;}cout << countMap.load_factor() << endl;cout << countMap.max_load_factor() << endl;cout << countMap.size() << endl;cout << countMap.bucket_count() << endl;cout << countMap.max_bucket_count() << endl;for (auto& kv : countMap){cout << kv.first << ":" << kv.second << endl;}cout << endl;}
}

因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

二.开散列(拉链法)

开散列法，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

两者相似处较多，重复部分不再赘述

①插入：

开散列为单链表插入，采用相对简单的头插。

对于扩容，开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容，即载荷因子等于 1时。

bool Insert(const pair<K, V>& kv)
{if (Find(kv.first))return false;//exit(0);// 扩容if (_n * 10 / _tables.size() >= 7){//size_t newsize = _tables.size() * 2;//vector<HashData<K, V>> newtables(newsize);旧表重新计算负载到新表//for (size_t i = 0; i < _tables.size(); i++)//{}HashTable<K, V, Hash> newHT;newHT._tables.resize(_tables.size() * 2);// 旧表重新计算负载到新表for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]._state == EXIST){newHT.Insert(_tables[i]._kv);}}_tables.swap(newHT._tables);}Hash hs;size_t hashi = hs(kv.first) % _tables.size();// 线性探测while (_tables[hashi]._state == EXIST){++hashi;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._state = EXIST;++_n;return true;
}

②查找：

找到映射位置链表查询即可

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

③删除：

单链表的删除

bool Erase(const K& key)
{size_t hashi = key % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){// 删除的是第一个if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}return true;}else{prev = cur;cur = cur->_next;}}return false;
}

代码+测试：

// 哈希桶(拉链法)
namespace hash_bucket
{template<class K, class V>struct HashNode{pair<K, V> _kv;HashNode<K, V>* _next;};template<class K, class V, class Hash = HashFunc<K>>class HashTable{typedef HashNode<K, V> Node;public:HashTable(){_tables.resize(10);}bool Insert(const pair<K, V>& kv){Hash hs;//负载因子为1时扩容if (_n == _tables.size()){vector<Node*> newTables(_tables.size() * 2, nullptr);for (int i = 0; i < _tables.size(); i++){Node* cur = _tables[i];//给每条链的每一个值重定向while (cur){Node* next = cur->_next;size_t hashi = hs(cur->_kv.first) % _tables.size();cur->_next = _tables[hashi];_tables[hashi] = cur;cur = next;}_tables.swap(newTables);}size_t hashi = hs(kv.first) % _tables.size();Node* newnode = new Node(kv);//头插newnode->_next = _tables[hashi];_tables[hashi] = newnode;return true;}}Node* Find(const K& key){size_t hashi = key % _tables.size();Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){return cur;}cur = cur->_next;}}bool Erase(const K& key){size_t hashi = key % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){// 删除的是第一个if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}return true;}else{prev = cur;cur = cur->_next;}}return false;}private:vector<Node*> _tables;size_t _n;};
}