【C++从0到王者】第三十六站：哈希
文章目录
- 一、unordered系列容器
- 二、unordered_set
- 三、unordered_map
- 四、unordered_set与set的比较
- 五、各种查找的比较
- 六、哈希函数
-
- 1.哈希函数概念与哈希冲突
- 2.常见哈希函数
- 七、解决哈希冲突
-
- 1.闭散列---开放定址法
- 2.开散列---拉链法/哈希桶
一、unordered系列容器
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到logN，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到。在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同。
unordered_xxx系列与map和set容器的用法上几乎没有任何区别
他们的区别就是
- unordered_xxx系列都是哈希表作为底层的，而map和set是用红黑树作为底层的
- unordered_xxx系列不排序，只去重
- unordered_xxx系列是单项迭代器
二、unordered_set
如下就是unordered_set的文档
unordered_set是一种容器，它以无特定顺序的方式存储唯一的元素，并允许根据元素的值快速检索各个元素。
在unordered_set中，元素的值同时也是它的键，唯一标识该元素。键是不可变的，因此，unordered_set中的元素一旦放入容器后就不能被修改，不过可以插入和删除。
在内部，unordered_set中的元素不按任何特定顺序排序，而是根据它们的哈希值组织成桶，以便通过它们的值（平均具有恒定的平均时间复杂度）直接快速访问各个元素。
对于通过键访问单个元素，unordered_set容器比set容器更快，尽管对于通过子集范围迭代它们通常效率较低。
容器中的迭代器是单向迭代器。
由于接口其实大差不差，所以我们可以直接使用去感受一下
void test1()
{
unordered_set<int> us;
us.insert(1);
us.insert(5);
us.insert(2);
us.insert(6);
us.insert(4);
us.insert(3);
unordered_set<int>::iterator usit = us.begin();
while (usit != us.end())
{
cout << *usit << endl;
usit++;
}
cout << endl;
}
三、unordered_map
如下是unordered_map的文档
无序映射是关联容器，存储由键值和映射值组合形成的元素，并允许根据它们的键快速检索各个元素。
在unordered_map中，键值通常用于唯一标识元素，而映射值是与该键关联的对象的内容。键和映射值的类型可以不同。
在内部，unordered_map中的元素不根据它们的键或映射值按任何特定顺序排序，而是根据它们的哈希值组织成桶，以便通过它们的键值直接快速访问各个元素（平均具有恒定的平均时间复杂度）。
对于通过键访问单个元素，unordered_map容器比map容器更快，尽管对于通过子集范围迭代它们通常效率较低。
无序映射实现了直接访问运算符（operator[]），允许使用键值作为参数直接访问映射值。
容器中的迭代器是单向迭代器。
void test2()
{
unordered_map<string, string> dict;
dict["insert"] = "插入";
dict["sort"] = "排序";
dict["delete"] = "删除";
dict["string"] = "字符串";
dict["insert"] = "xxxxx";
dict.insert(make_pair("iterator", "迭代器"));
unordered_map<string, string>::iterator umit = dict.begin();
while (umit != dict.end())
{
cout << umit->first << ":" << umit->second << endl;
umit++;
}
cout << endl;
}
四、unordered_set与set的比较
如下所示，我们采用如下代码进行比较
void test3()
{
const size_t N = 100000;
unordered_set<int> us;
set<int> s;
vector<int> v;
v.reserve(N);
srand(time(0));
for (size_t i = 0; i < N; ++i)
{
v.push_back(rand());
//v.push_back(rand()+rand()); //减少重复数据
//v.push_back(i); //有序的时候
}
size_t begin1 = clock();
for (auto e : v)
{
s.insert(e);
}
size_t end1 = clock();
cout << "set insert:" << end1 - begin1 << endl;
size_t begin2 = clock();
for (auto e : v)
{
us.insert(e);
}
size_t end2 = clock();
cout << "unordered_set insert:" << end2 - begin2 << endl;
size_t begin3 = clock();
for (auto e : v)
{
s.find(e);
}
size_t end3 = clock();
cout << "set find:" << end3 - begin3 << endl;
size_t begin4 = clock();
for (auto e : v)
{
us.find(e);
}
size_t end4 = clock();
cout << "unordered_set find:" << end4 - begin4 << endl << endl;
cout <<"插入数据个数："<< s.size() << endl;
cout <<"插入数据个数：" << us.size() << endl << endl;;
size_t begin5 = clock();
for (auto e : v)
{
s.erase(e);
}
size_t end5 = clock();
cout << "set erase:" << end5 - begin5 << endl;
size_t begin6 = clock();
for (auto e : v)
{
us.erase(e);
}
size_t end6 = clock();
cout << "unordered_set erase:" << end6 - begin6 << endl << endl;
}
可以看到，在无序的数据的时候，unordered_set更占优势一些。
但是我们会发现有很多的重复数据，于是我们可以对随机值+随机值以此减少重复数据
可以看到，还是unordered_set占据优势
然后我们可以尝试一下有序的数据
此时set占据优势
可见，如果数据是无序的，unordered_set更优，如果是有序的，使用set更好
五、各种查找的比较
- 暴力查找
首先就是我们最常见的暴力查找，他的时间复杂度是O(N)
- 二分
不过我们可以对其进行一定程度的优化，即先排序，这样的画他的时间复杂度就变为了logN，但是增删还是不方便
- 平衡树
再后来就是使用红黑树，他的效率都是很优秀的，增删查改都是logN
- 哈希
除此之外还有一种方式就是哈希，即存储的值和存储位置建立出一个对应关系，这样的话时间复杂度直接变为了O(1)，哈希我们也称作散列
哈希的方式有点类似于计数排序
这种方式在现实生活中就应用于图书馆中的分区
但是上面这种哈希仅仅只是比较适合于数据比较集中的，像字母只有26个，就很集中比较适合上面这种方式
这种方式也被称为直接定址法
但是如果数据很分散的话，就不适合了。因为会试想一下，在一个数组中，大部分的元素位于0~20之间，但是突然一个数据是9999，那么我们难道就要开这么大的空间，去直接定址吗？显然是不可能的！
于是我们就有了下面一种哈希，除留余数法，即对所有数据对一个数据取模后，在根据这个值进行放入。
不过这种方法会导致一种问题，就是哈希冲突：不同的值，可能会映射到一个位置，值和位置是多对一的关系
为了解决这种方法，我们可以使用很多种方法去解决。
一种方法是线性探测、或者二次探测，即使用某种规则去占用下一个位置，不过这种方式不是很好，因为会影响其他位置
不过还有一种方式是拉链法，即哈希桶的方式去解决。这种方式比较好，不会影响其他位置
六、哈希函数
1.哈希函数概念与哈希冲突
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素
当向该结构中：
- 插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放- 搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置
取元素比较，若关键码相等，则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)
例如在如下的哈希函数中
例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快
不过有时候我们也会遇到一种情况，当我们继续插入44的时候，我们发现原本的4的位置已经被占领了
**不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞 **
**把具有不同关键码而具有相同哈希地址的数据元素称为“同义词” **
2.常见哈希函数
- 直接定址法
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
优点：简单、均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况比如统计字符串中的字符出现的个数，因为字符的范围比较集中
- 除留余数法
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，
按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址。不过上述的方法可能会产生哈希冲突
七、解决哈希冲突
**解决哈希冲突两种常见的方法是：闭散列和开散列 **
1.闭散列—开放定址法
所谓的开放定址法：其实就是当前位置被占用了，通过某种规则去找下一个位置（占用别人的位置）
常见的方案有：线性探测，二次探测等…
我们下面主要探讨线性探测
下面是线性探测的插入策略：
如下所示，我们使用这个哈希函数，当我们依次插入1，111，4，5，6，7，44，9的时候，44由于下标为四的状态已经被占用了，所以要向后寻找空位置，进行放入。111也由于1的下标被占用了，也冲突了，所以向后寻找。这就是线性探测，如果我们继续插入一个19，那么他应该放入9下标的位置，但是9已经被占用了，所以会放入0的位置
如下就是已经有9了，继续放入19
下面是线性探测的查找：
在如下所示的表中，如果我们想继续查找44的话，那么就会根据哈希函数计算出下标，从4的位置开始找起来，如果不是直接匹配，那么就继续向后寻找，直到找到。如下就可以在8的位置找到44
如果想要找到54的话，那么也是根据哈希函数，从4开始找起来，一值找到0位置，发现0位置是一个空位置，那么结束查找，因为没有找到。
在这里也侧面反映出一个问题，哈希表不可以太满了，太满了会导致效率极其低下
线性探测的删除：
试想一下，我们删除一个数据是可以直接删除的吗？如果遇到如下的情况，先删除了6，然后查找44。似乎出现了卡bug的行为，因为删除6以后，6的位置已经为空了，而查找是一旦发现为空就停止查找了
所以删除会影响查找
所以为了解决上面的办法，我们删除不应该是将一个位置变为空，而是使用标记。
我们可以对每个数据使用三种状态进行标记：EXIST、EMPTY、DELETE，分别表示存在，空，删除三种状态
这样的话，当我们删除一个数据的时候，直接修改他的状态即可。
而对于查找的时候，遇到DELETE的时候不要停止，遇到空才停止
闭散列的代码实现
首先是闭散列的结构，如下所示。 在哈希表中，虽然vector已经有size函数了，但是这里计算出来的并非有效数据，所以我们还需要一个n来记录哈希表中的有效数据
enum STATE
{
EXIST,
EMPTY,
DELETE
};
template<class K,class V>
struct HashDate
{
pair<K, V> _kv;
STATE _state = EMPTY;
};
template<class K, class V >
class HashTable
{
public:
private:
vector<HashDate<K, V>> _table;
size_t _n = 0;
};
- 闭散列的插入实现
考虑到，闭散列是根据线性探测查找的，所以我们可以简单的写出以下代码，因为我是是使用vector作为底层的，所以我们使用size作为模的对象，切记不可以使用capacity，因为capacity虽然开出来了容量，但是这个容量是不可以使用的。size才是可访问的范围。
上面的代码其实还存在一定问题:
那就是哈希表的扩容问题，何时进行扩容，是需要我们去考虑的。而且我们不能让哈希表满了，因为哈希表一旦满了，就会死循环了
对于这个负载因子
负载因子越大，冲突概率越大，空间利用率越高
负载因子越小，冲突概率越小，空间利用率越低
哈希表不能满了在扩容，控制负载因子到一定值就必须扩容
所以我们可能会写出以下代码，但是下面代码还是错的
为什么错了呢？其实是因为，resize以后，导致哈希函数改变了，从而导致映射关系乱了，需要重新映射
我们重新映射的办法就是，在创建一个哈希表，然后依次往新的哈希表中插入数据，最后交换两个哈希表的vector，这样的写法有点类似于赋值运算符重载的现代写法
bool Insert(const pair<K, V>& kv)
{
if (10 * _n / _table.size() >= 7)
{
size_t newSize = _table.size() * 2;
//遍历旧表，重新映射到新表
HashTable<K, V> newHT;
newHT._table.resize(newSize);
for (int i = 0; i < _table.size(); i++)
{
if (_table[i]._state == EXIST)
{
newHT.Insert(_table[i]._kv);
}
}
_table.swap(newHT._table);
}
size_t hashi = kv.first % _table.size();
while (_table[hashi]._state == EXIST)
{
hashi++;
hashi %= _table.size();
}
_table[hashi]._kv = kv;
_table[hashi]._state = EXIST;
++_n;
return true;
}
我们可以使用如下的测试用力进行测试：
void test4()
{
Sim::HashTable<int, int> ht;
int a[] = { 1,111,4,15,25,7,44,9 };
for (auto e : a)
{
ht.Insert(make_pair(e, e));
}
}
如下图是扩容之前的
如下是扩容之后的
- 闭散列查找
闭散列的查找还是比较容易的，这里我们特别注意的是，我们的返回值是一个HashDate
HashDate<const K, V>* Find(const K& key)
{
size_t hashi = key % _table.size();
while (_table[hashi]._state != EMPTY)
{
if (_table[hashi]._state == EXIST
&& _table[hashi]._kv.first == key)
{
return (HashDate<const K, V>*) & _table[hashi];
}
hashi++;
hashi %= _table.size();
}
return nullptr;
}
- 闭散列删除
如下所示，哈希表的删除是少数删除比插入还简单的容器，因为只需要改一个状态即可。
bool Erase(const K& key)
{
HashDate<const K, V>* ret = Find(key);
if (ret)
{
ret->_state = DELETE;
--_n;
return true;
}
return false;
}
- 特殊类型的量化
上面的代码其实还是不够完善的，因为当我们的哈希表中的元素是字符串类型的时候，就麻烦了，字符串类型无法进行取模运算，所以我们需要有一个办法对字符串进行量化，让他转化为整型，有了整型以后，才能去建立映射关系。甚至于这个key都一定是字符串，如果不是字符串，那么又该如何进行量化，这才是插入中最麻烦的地方。
为了解决这个问题，我们可以使用仿函数。利用仿函数去量化，那么仿函数该如何去写呢？首先就是默认的，可以直接转为size_t类型的
template<class K>
struct DefaultHashFunc
{
size_t operator()(const K& key)
{
return (size_t)key;
}
};
如果遇到特殊类型的，我们可以自己写一个仿函数去量化，比如string类型
struct StringHashFunc
{
size_t operator()(const string& key)
{
return (size_t)key[0];
}
};
这样我们只需要传参的时候使用这个仿函数即可
但是对于string其实使用是很高频的，所以我们不妨使用模板的特化
template<>
struct DefaultHashFunc<string>
{
size_t operator()(const string& key)
{
return (size_t)key[0];
}
};
接下来，我们可以使用如下测试用例进行测试
void test5()
{
//Sim::HashTable dict;
Sim::HashTable<string, string> dict;
dict.Insert(make_pair("sort", "排序"));
dict.Insert(make_pair("insert", "插入"));
dict.Insert(make_pair("delete", "删除"));
//Sim::HashDate* ret = dict.Find("sort");
Sim::HashDate<const string, string>* ret = dict.Find("sort");
ret->_kv.second = "xxxx";
}
虽然解决了特殊类型的问题，但是对于string类型而言，上面的处理其实并不是很好，因为太单一了，随便两个首字母相同的就冲突了，所以我们可以考虑所有字母相加
template<>
struct DefaultHashFunc<string>
{
size_t operator()(const string& key)
{
size_t hash = 0;
for (auto ch : key)
{
hash += ch;
}
return hash;
}
};
但是上面还是无法规避一些特殊情况，比如两个字符串里面的字母都相同，仅仅只是交换了某些字母的顺序
其实对于字符串转整型有很多种方法
如旁边所示，是字符串转整型的一些方法：字符串转整型
我们可以使用第一种方法
template<>
struct DefaultHashFunc<string>
{
size_t operator()(const string& key)
{
size_t hash = 0;
for (auto ch : key)
{
hash = hash * 131 + ch;
}
return hash;
}
};
这样的话，确实不是那么容易冲突了
上面就是线性探测的方法了。
线性探测所存在的问题就是，容易发生拥堵踩踏事件
线性探测的基本思路就是
hashi = key % n;
hashi = hashi + i;
i>=0;
为了防止过于频繁的拥堵踩踏事件，我们可以使用二次探测。
二次探测与线性探测的唯一不同就是，二次探测每次是探测平方的，这样就会导致每个数据都会间隔开。使得数据不是那么集中拥堵，可以一定程度缓解拥堵踩踏
hashi = key % n;
hashi = hashi + pow(i,2);
i>=0;
但是无论如何，无论是线性探测也好，二次探测也好，他们都会导致拥堵踩踏，产生冲突，冲突的值会相互影响，这是开放定址法自身的缺陷
如下是闭散列/开放地址法的完整代码
namespace open_address
{
enum STATE
{
EXIST,
EMPTY,
DELETE
};
template<class K,class V>
struct HashDate
{
pair<K, V> _kv;
STATE _state = EMPTY;
};
template<class K>
struct DefaultHashFunc
{
size_t operator()(const K& key)
{
return (size_t)key;
}
};
template<>
struct DefaultHashFunc<string>
{
size_t operator()(const string& key)
{
size_t hash = 0;
for (auto ch : key)
{
hash = hash * 131 + ch;
}
return hash;
}
};
//template<>
//struct DefaultHashFunc2.开散列—拉链法/哈希桶
- 开散列概念：
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中
所以开散列其实就是一个指针数组，关键码对应的值直接挂在对应的下标下面
开散列的基本思路
如下所示，是开散列的基本思路，我们使用一个指针数组来将每个结点给链接上去
namespace hash_bucket
{
template<class K,class V>
struct HashNode
{
pair<K, V> _kv;
HashNode<K, V>* _next = nullptr;
HashNode(const pair<K, V>& kv)
:_kv(kv)
{}
};
template<class K, class V>
class HashTable
{
typedef HashNode<K,V> Node;
public:
HashTable()
:_n(0)
{
_table.resize(10, nullptr);
}
private:
vector<Node*> _table;
size_t _n;
};
}
- 开散列的插入
如下所示，是我们一开始的基本思路，我们先不考虑特殊类型无法取模的问题，我们直接使用头插法，便可以很轻松的完成插入
bool Insert(const pair<K, V>& kv)
{
size_t hashi = kv.first % _table.size();
Node* newnode = new Node(kv);
newnode->_next = _table[hashi];
_table[hashi] = newnode;
++_n;
return true;
}
但是这段代码还存在的问题就是扩容问题。因为我们不可能让这个桶上一直挂数据。
也就是说，不扩容，不断插入，某些桶越来越长，效率得不到保障，但是这里的负载因子可以适当放大一些，一般负载因子在1，平均下俩每个桶一个数据
如果按照我们上面闭散列的逻辑的话，那么就是这样扩容的
一个一个的将值给放进去，但是这样的话，存在一个问题，那就是我们还需要new一些新结点，而原来的结点还需要再释放一下
这样做其实是不太好的，效率比较低。而前面闭散列敢这样做的原因，就是因为不需要new新节点，所以可以这样玩。而这里不能这样做就是需要开新节点了
所以我们最好的策略就是直接把原来的结点给挪用即可
如下就是最终代码，这里我们已经添加了仿函数进行处理特殊类型了。
bool Insert(const pair<K, V>& kv)
{
//去重
if (Find(kv.first))
{
return false;
}
HashFunc hf;
if (_n == _table.size())
{
size_t newSize = _table.size() * 2;
vector<Node*> newTable(newSize, nullptr);
for (int i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
while (cur)
{
Node* next = cur->_next;
size_t hashi = hf(cur->_kv.first) % newTable.size();
cur->_next = newTable[hashi];
newTable[hashi] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(newTable);
}
size_t hashi = hf(kv.first) % _table.size();
Node* newnode = new Node(kv);
newnode->_next = _table[hashi];
_table[hashi] = newnode;
++_n;
return true;
}
我们使用如下测试用例
void test6()
{
hash_bucket::HashTable<int, int> ht;
int a[] = { 1,111,4,15,25,7,44,9 };
for (auto e : a)
{
ht.Insert(make_pair(e, e));
}
}
监视窗口如下所示
我们也可以写一个print用来展示
void Print()
{
for (int i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
printf("[%d]->", i);
while (cur)
{
cout << cur->_kv.first << "->";
cur = cur->_next;
}
cout << "NULL" << endl;
}
}
然后我们的测用例改为如下，可以更加直观的感受扩容
void test6()
{
hash_bucket::HashTable<int, int> ht;
int a[] = { 1,111,4,15,25,7,44,9 };
for (auto e : a)
{
ht.Insert(make_pair(e, e));
}
ht.Print();
cout << endl;
ht.Insert(make_pair(24, 24));
ht.Insert(make_pair(34, 34));
ht.Insert(make_pair(54, 54));
ht.Print();
}
运行结果如下：
- 开散列的查找
Node* Find(const K& key)
{
HashFunc hf;
size_t hashi = hf(key) % _table.size();
Node* cur = _table[hashi];
while (cur)
{
if (cur->_kv.first == key)
{
return cur;
}
cur = cur->_next;
}
return nullptr;
}
- 开散列的删除
bool Erase(const K& key)
{
HashFunc hf;
size_t hashi = hf(key) % _table.size();
Node* cur = _table[hashi];
Node* prev = nullptr;
while (cur)
{
if (cur->_kv.first == key)
{
if (prev)
{
prev->_next = cur->_next;
}
else
{
_table[hashi] = cur->_next;
}
delete cur;
cur = nullptr;
_n--;
return true;
}
else
{
prev = cur;
cur = cur->_next;
}
}
return false;
}
接下来我们来测试一下
void test6()
{
hash_bucket::HashTable<int, int> ht;
int a[] = { 1,111,4,15,25,7,44,9 };
for (auto e : a)
{
ht.Insert(make_pair(e, e));
}
ht.Print();
cout << endl;
ht.Insert(make_pair(24, 24));
ht.Insert(make_pair(34, 34));
ht.Insert(make_pair(54, 54));
ht.Print();
cout << endl;
ht.Erase(44);
ht.Erase(4);
ht.Erase(24);
ht.Print();
}
运行结果为
- 开散列的析构
开散列与闭散列的不同之处在于，他需要写一个析构函数，因为闭散列的数组上都是自定义类型，所以可以不用写析构函数，而开散列的数组上都是一些指针，这些指针都是内置类型，他们指向一段空间， 就需要写上析构函数了
~HashTable()
{
for (int i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
while (cur)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_table[i] = nullptr;
}
}
我们可以用如下代码来进行测试
void test7()
{
hash_bucket::HashTable<string, string> dict;
dict.Insert(make_pair("sort", "排序"));
dict.Insert(make_pair("insert", "插入"));
dict.Insert(make_pair("delete", "删除"));
dict.Insert(make_pair("process", "进程"));
dict.Insert(make_pair("right", "xxxx"));
hash_bucket::HashNode<string, string>* ret = dict.Find("right");
ret->_kv.second = "右边";
dict.Print();
cout << endl;
dict.Erase("sort");
dict.Print();
}
运行结果为
下面是哈希桶的完整代码：
namespace hash_bucket
{
template<class K,class V>
struct HashNode
{
pair<K, V> _kv;
HashNode<K, V>* _next = nullptr;
HashNode(const pair<K, V>& kv)
:_kv(kv)
{}
};
template<class K>
struct DefaultHashFunc
{
size_t operator()(const K& key)
{
return (size_t)key;
}
};
template<>
struct DefaultHashFunc<string>
{
size_t operator()(const string& str)
{
size_t hashi = 0;
for (auto ch : str)
{
hashi = hashi * 131 + ch;
}
return hashi;
}
};
template<class K, class V, class HashFunc = DefaultHashFunc<K>>
class HashTable
{
typedef HashNode<K,V> Node;
public:
HashTable()
:_n(0)
{
_table.resize(10, nullptr);
}
bool Insert(const pair<K, V>& kv)
{
if (Find(kv.first))
{
return false;
}
HashFunc hf;
if (_n == _table.size())
{
size_t newSize = _table.size() * 2;
vector<Node*> newTable(newSize, nullptr);
for (int i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
while (cur)
{
Node* next = cur->_next;
size_t hashi = hf(cur->_kv.first) % newTable.size();
cur->_next = newTable[hashi];
newTable[hashi] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(newTable);
}
size_t hashi = hf(kv.first) % _table.size();
Node* newnode = new Node(kv);
newnode->_next = _table[hashi];
_table[hashi] = newnode;
++_n;
return true;
}
void Print()
{
for (int i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
printf("[%d]->", i);
while (cur)
{
cout << cur->_kv.first << ":" << cur->_kv.second << "->";
cur = cur->_next;
}
cout << "NULL" << endl;
}
}
Node* Find(const K& key)
{
HashFunc hf;
size_t hashi = hf(key) % _table.size();
Node* cur = _table[hashi];
while (cur)
{
if (cur->_kv.first == key)
{
return cur;
}
cur = cur->_next;
}
return nullptr;
}
bool Erase(const K& key)
{
HashFunc hf;
size_t hashi = hf(key) % _table.size();
Node* cur = _table[hashi];
Node* prev = nullptr;
while (cur)
{
if (cur->_kv.first == key)
{
if (prev)
{
prev->_next = cur->_next;
}
else
{
_table[hashi] = cur->_next;
}
delete cur;
cur = nullptr;
_n--;
return true;
}
else
{
prev = cur;
cur = cur->_next;
}
}
return false;
}
~HashTable()
{
for (int i = 0; i < _table.size(); i++)
{
Node* cur = _table[i];
while (cur)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_table[i] = nullptr;
}
}
private:
vector<Node*> _table;
size_t _n;
};
}