STL关联容器值hashtable
hashtable(散列表)是一种数据结构，在元素的插入，删除，搜索操作上具有常数平均时间复杂度O(1);
hashtable名词
散列函数：负责将某一元素映射为索引。
碰撞(collision)：不同的元素被映射到相同的位置。
解决碰撞的方法：线性试探法，二次试探法，开链等。
负载系数：元素个数除以表格大小。
主集团：平均插入成本的增长幅度，远高于负载系数的成长幅度。
次集团：hashtable若采用二次探测，则若两个元素经hash function计算出来的位置相同，则插入时所试探的位置也相同，造成某种浪费。
开链：在每个表格元素中位置一个list。
桶(bucket):hashtable表格内的每个元素。
hashtable组织方式
节点类
template <class _Val>
struct _Hashtable_node
{
_Hashtable_node* _M_next;
_Val _M_val;
};
hashtable的节点和list节点相类似。
一个Node的指针指向每个桶上列表的首个元素，而桶上的链表首地址存放在vector向量中。
typedef _Hashtable_node<_Val> _Node;
vector<_Node*,_Alloc> _M_buckets;
hashtable迭代器的自增操作符定义如下：
template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
class _All>
_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>&
_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++()
{
const _Node* __old = _M_cur; //当前节点的副本
_M_cur = _M_cur->_M_next; //前进一个节点
if (!_M_cur) { //到达当前链表的末端，则转向下一个桶的链表开头
//获得节点副本所在的桶编号
size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
//当桶为空，且未到达桶向量的末尾，则继续下一个桶
while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
//当前节点指针指向下一个桶的节点链表开头
_M_cur = _M_ht->_M_buckets[__bucket];
}
return *this;
}
hashtable类定义有五个模板参数
template <class _Val, class _Key, class _HashFcn,
class _ExtractKey, class _EqualKey, class _Alloc>
class hashtable;
_Val 值类型
_Key 键类型
_HashFcn 哈希函数
_ExtractKey 提取键的方法
_EqualKey 判断键相等的方法
_Alloc 分配器类型
hashtable插入操作
insert_unique不允许值重复的插入:
pair<iterator, bool> insert_unique(const value_type& __obj)
{
resize(_M_num_elements + 1);
return insert_unique_noresize(__obj);
}
该函数首先调用resize函数，传入当前元素加一的值，看是否需要进行扩容。处理完成后，再将值__obj插入到hashtable中。
resize函数的定义如下：
template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
::resize(size_type __num_elements_hint)
{
const size_type __old_n = _M_buckets.size(); //桶数量的旧值
if (__num_elements_hint > __old_n) { //传入的新值大于旧值
//从素数表中查找最接近新值的桶数量__n
const size_type __n = _M_next_size(__num_elements_hint);
if (__n > __old_n) { //得到的桶数量大于旧值：需要扩容
//分配容量为__n（新桶数量）的桶向量
vector<_Node*, _All> __tmp(__n, (_Node*)(0),
_M_buckets.get_allocator());
__STL_TRY {
//对旧hashtable中的每个桶
for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) {
_Node* __first = _M_buckets[__bucket]; //取得桶中链表首地址
while (__first) { //未到达旧桶中链表的末尾
//根据链表节点中存放的元素数值_M_val，以新的桶数量__n，
//计算其在新的hashtable中的桶编号（rehash）
size_type __new_bucket = _M_bkt_num(__first->_M_val, __n);
//更新当前桶中节点链表头的指向，使其指向链表中的下一个元素
_M_buckets[__bucket] = __first->_M_next;
//以下两句是增长新桶中的链表，把新节点加进去。
//链表首地址的后继指向新hashtable中计算出来的新桶中的链表开头
__first->_M_next = __tmp[__new_bucket];
//新hashtable，新桶的链表开头指向__first
__tmp[__new_bucket] = __first;
//更新__first至原有的__first->_M_next，即在原hashtable原桶中的链表中前进一个元素。
__first = _M_buckets[__bucket];
}
}
//当旧hashtable中的元素都重新hash到新桶向量后
_M_buckets.swap(__tmp); //将新桶向量与旧桶向量相互交换。
//旧桶数据存放在__tmp向量中，当离开此范围时，__tmp作为一个局部变量，其空间会被自动释放。
}
//发生异常后进行的回滚操作
# ifdef __STL_USE_EXCEPTIONS
catch(...) {
//将新的桶向量中的每个桶
for (size_type __bucket = 0; __bucket < __tmp.size(); ++__bucket) {
//对桶中链表的每个节点
while (__tmp[__bucket]) {
_Node* __next = __tmp[__bucket]->_M_next;
_M_delete_node(__tmp[__bucket]); //删除当前节点
__tmp[__bucket] = __next; //前进一个节点
}
}
throw;
}
# endif /* __STL_USE_EXCEPTIONS */
}
}
}
insert_unique_noresize的函数定义如下：
template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, bool>
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
::insert_unique_noresize(const value_type& __obj)
{
const size_type __n = _M_bkt_num(__obj); //将值映射到对应桶中，并获得桶编号
_Node* __first = _M_buckets[__n]; //桶中链表的开头
//桶中链表非空，则遍历链表
for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
//链表中存在与__obj值相同的节点
if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
//返回相等位置处的迭代器，并附加插入失败标识。
return pair<iterator, bool>(iterator(__cur, this), false);
//链表中不存在与待插入值相等的元素，
_Node* __tmp = _M_new_node(__obj); //创建新链表节点
__tmp->_M_next = __first; //将新节点的后继设为链表开头
_M_buckets[__n] = __tmp; //将桶的链表开头设为新插入的节点
++_M_num_elements; //增加hashtable元素数量
//返回插入位置的迭代器，并附加插入成功标识。
return pair<iterator, bool>(iterator(__tmp, this), true);
}
结合insert_unique函数中调用的两个函数接口的分析，可知：
- 在进行insert_unique函数执行时，首先尝试对桶向量进行扩容，然后再向hashtable中插入元素。
- hashtable的扩容操作类似于vector的自增长过程，都经过1.申请更大空间；2.将原容器中的数据转移到新的容器中；3.清理原容器的空间；三部曲。
- 与vector容器的自增长所不同的是，在数据转移的过程中，hashtable需要根据新的桶数量，对数据进行重新映射。
insert_equal允许重复的插入：
iterator insert_equal(const value_type& __obj)
{
resize(_M_num_elements + 1);
return insert_equal_noresize(__obj);
}
与insert_unique相比较，函数在扩容后调用允许重复值的非扩充插入函数insert_equal_noresize：
template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
::insert_equal_noresize(const value_type& __obj)
{
const size_type __n = _M_bkt_num(__obj); //将值映射到对应桶中，并获得桶编号
_Node* __first = _M_buckets[__n]; //桶中链表的开头
///桶中链表非空，则遍历链表
for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
//链表中存在与__obj值相同的节点，则执行插入操作并返回
if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) {
_Node* __tmp = _M_new_node(__obj); //创建新链表节点
__tmp->_M_next = __cur->_M_next; //将插入节点的后继设为当前节点的后继
__cur->_M_next = __tmp; //当前节点的后继设为插入节点
++_M_num_elements; //更新元素个数
return iterator(__tmp, this); //完成插入操作，返回
}
//链表中没有与插入元素值相同的节点
_Node* __tmp = _M_new_node(__obj); //创建新链表节点
__tmp->_M_next = __first; //将新节点的后继指向链表开头
_M_buckets[__n] = __tmp; //将桶的链表开头指向新插入的节点
++_M_num_elements; //更新元素个数
return iterator(__tmp, this); //完成插入操作，返回
}
insert_unique_noresize与insert_equal_noresize的比较：
- insert_unique_noresize先在hashtable的某个桶中查找与插入值相同的节点，若找到，则直接返回，插入失败。否则，在桶的链表的头部插入新节点。
- insert_equal_noresize先在hashtable的某个桶中查找与插入值相同的节点，若找到，则在其后插入新节点。否则，在桶的链表的头部插入新节点。
hashtable的删除和复制
hashtable删除
template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::clear()
{
//遍历桶向量
for (size_type __i = 0; __i < _M_buckets.size(); ++__i) {
_Node* __cur = _M_buckets[__i]; //当前桶
while (__cur != 0) { //遍历桶中链表
_Node* __next = __cur->_M_next; //保存后继节点地址
_M_delete_node(__cur); //析构指针所指向的对象，并释放节点
__cur = __next; //指针前进
}
_M_buckets[__i] = 0; //链表开头指向空
}
_M_num_elements = 0; //更新元素数量为0
}
hashtable复制
template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
::_M_copy_from(const hashtable& __ht)
{
_M_buckets.clear(); //清空原桶向量
_M_buckets.reserve(__ht._M_buckets.size()); //为桶向量重新分配内存，是其能够容纳被复制对象
//初始化桶向量中的列表开头为空
_M_buckets.insert(_M_buckets.end(), __ht._M_buckets.size(), (_Node*) 0);
__STL_TRY {
//遍历桶
for (size_type __i = 0; __i < __ht._M_buckets.size(); ++__i) {
const _Node* __cur = __ht._M_buckets[__i]; //被复制散列（源散列）的某个桶中链表开头
if (__cur) { //链表非空
_Node* __copy = _M_new_node(__cur->_M_val); //创建链表开头节点副本
_M_buckets[__i] = __copy; //更新目标散列对应桶的链表开头
for (_Node* __next = __cur->_M_next; //对链表中剩下的元素，依次
__next;
__cur = __next, __next = __cur->_M_next) {
__copy->_M_next = _M_new_node(__next->_M_val); //创建节点副本
__copy = __copy->_M_next; //在列表中前进
}
}
}
_M_num_elements = __ht._M_num_elements; //更新元素数量
}
__STL_UNWIND(clear()); //复制发生异常时回滚操作
}
小结
- hashtable不依赖元素的随机性，假设元素分布在一个相对固定的范围内，类似于一种字典结构。
- hashtable可提供常数复杂度的插入，删除，搜索操作，但是需要创建哈希表，是以空间的代价换取时间的高效。
- 树结构提供对数时间复杂度的元素搜索操作，依赖于元素的随机性。
