STL笔记之hashtable

之前对hash一直存在恐惧感，毕竟没用过……最近在一个组件里面自己实现了一个hashtable，感觉也就这么回事；回头看看书上对hashtable的分析，发现是极其的相似。不过，旧版本的C++标准里面并没有hashtable这个东西，而C++11中引入了相关的容器（std::unordered_set, std::unordered_multiset, std::unordered_map, std::unordered_multimap），所以可以直接使用C++11里面的容器了。

1. hashtable结构

SGI STL中hash table使用的是开链法进行的冲突处理，其结构如图所示：



hash table的节点定义如下：

template <class _Val>
struct _Hashtable_node
{
_Hashtable_node* _M_next;
_Val _M_val;
};

2. hashtable迭代器

这里省略了不必要的代码，只需要注意迭代器类型、成员组成以及几个关键的操作即可。

struct _Hashtable_iterator {
typedef _Hashtable_node<_Val> _Node;

typedef forward_iterator_tag iterator_category;

_Node* _M_cur;
_Hashtable* _M_ht;

iterator& operator++();
iterator operator++(int);
};

hashtable的迭代器类型为ForwardIterator，所以只支持operator++操作。

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;
// 如果为空，表明当前的bucket已经没有节点了，需要指向下一个存在节点的bucket
if (!_M_cur) {
// 取得当前的bucket索引值
size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
// 寻找下一个存在节点的bucket
while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
_M_cur = _M_ht->_M_buckets[__bucket];
}
return *this;
}

// operator++(int)基于operator++()实现
template <class _Val, class _Key, class _HF, class _ExK, class _EqK,
class _All>
inline _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>
_Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++(int)
{
iterator __tmp = *this;
++*this;
return __tmp;
}

3. hashtable关键实现
3.1 素数

很多书籍上提到最好取一个素数作为hash表格的大小，但是看了下网上似乎有两种观点：一种赞同，另一种说取其他数也可以。不过都认同的一个观点是，m不应该是进制数的幂，比如十进制的时候，m如果是10^n，那么结果总是和原始值的后n位相关的，这样冲突的概率会更大。所以，CLRS上面也提到了m常常选择与2的幂不太接近的质数。在这种情况下，取一个素数总是个不坏的选择。

SGI STL提供了28个素数最为备选方案，__stl_next_prime可以选出一个最接近n且比n要大的素数。

enum { __stl_num_primes = 28 };

static const unsigned long __stl_prime_list[__stl_num_primes] =
{
ul,         97ul,         193ul,       389ul,       769ul,
ul,       3079ul,       6151ul,      12289ul,     24593ul,
ul,      98317ul,      196613ul,    393241ul,    786433ul,
ul,    3145739ul,    6291469ul,   12582917ul,  25165843ul,
ul,   100663319ul,  201326611ul, 402653189ul, 805306457ul,
41ul, 3221225473ul, 4294967291ul
};

inline unsigned long __stl_next_prime(unsigned long __n)
{
const unsigned long* __first = __stl_prime_list;
const unsigned long* __last = __stl_prime_list + (int)__stl_num_primes;
const unsigned long* pos = lower_bound(__first, __last, __n);
return pos == __last ? *(__last - 1) : *pos;
}

size_type max_bucket_count() const
{
return __stl_prime_list[(int)__stl_num_primes - 1];
}

3.2 关键源码

template <class _Val, class _Key, class _HashFcn,
class _ExtractKey, class _EqualKey, class _Alloc>
class hashtable {
public:
typedef _Key key_type;
typedef _Val value_type;
typedef _HashFcn hasher;
typedef _EqualKey key_equal;

hasher hash_funct() const { return _M_hash; }
key_equal key_eq() const { return _M_equals; }

private:
// hash table 节点
typedef _Hashtable_node<_Val> _Node;

private:
hasher                _M_hash;
key_equal             _M_equals;
_ExtractKey           _M_get_key;
// bucket vector : hash数组本身使用vector进行管理
vector<_Node*,_Alloc> _M_buckets;
size_type             _M_num_elements;

public:
hashtable(size_type __n,
const _HashFcn&    __hf,
const _EqualKey&   __eql,
const _ExtractKey& __ext,
const allocator_type& __a = allocator_type())
: __HASH_ALLOC_INIT(__a)
_M_hash(__hf),
_M_equals(__eql),
_M_get_key(__ext),
_M_buckets(__a),
_M_num_elements(0)
{
// 调用_M_initialize_buckets进行初始化操作
_M_initialize_buckets(__n);
}

hashtable(size_type __n,
const _HashFcn&    __hf,
const _EqualKey&   __eql,
const allocator_type& __a = allocator_type())
: __HASH_ALLOC_INIT(__a)
_M_hash(__hf),
_M_equals(__eql),
_M_get_key(_ExtractKey()),
_M_buckets(__a),
_M_num_elements(0)
{
_M_initialize_buckets(__n);
}

hashtable(const hashtable& __ht)
: __HASH_ALLOC_INIT(__ht.get_allocator())
_M_hash(__ht._M_hash),
_M_equals(__ht._M_equals),
_M_get_key(__ht._M_get_key),
_M_buckets(__ht.get_allocator()),
_M_num_elements(0)
{
_M_copy_from(__ht);
}

~hashtable() { clear(); }

size_type size() const { return _M_num_elements; }
size_type max_size() const { return size_type(-1); }
bool empty() const { return size() == 0; }

// begin() 返回第一个有效的节点，不存在则返回end()
iterator begin()
{
for (size_type __n = 0; __n < _M_buckets.size(); ++__n)
if (_M_buckets[__n])
return iterator(_M_buckets[__n], this);
return end();
}

iterator end() { return iterator(0, this); }

public:

size_type bucket_count() const { return _M_buckets.size(); }

// 返回hash数组中指定bucket下标上冲突链表的长度
size_type elems_in_bucket(size_type __bucket) const
{
size_type __result = 0;
for (_Node* __cur = _M_buckets[__bucket]; __cur; __cur = __cur->_M_next)
__result += 1;
return __result;
}

// 插入操作
pair<iterator, bool> insert_unique(const value_type& __obj)
{
resize(_M_num_elements + 1);
return insert_unique_noresize(__obj);
}

iterator insert_equal(const value_type& __obj)
{
resize(_M_num_elements + 1);
return insert_equal_noresize(__obj);
}

pair<iterator, bool> insert_unique_noresize(const value_type& __obj);
iterator insert_equal_noresize(const value_type& __obj);

// 查找指定的key
iterator find(const key_type& __key)
{
// 计算key得到的下标
size_type __n = _M_bkt_num_key(__key);
// 遍历冲突链表
_Node* __first;
for ( __first = _M_buckets[__n];
__first && !_M_equals(_M_get_key(__first->_M_val), __key);
__first = __first->_M_next)
{}
return iterator(__first, this);
}

// 计算具有指定key的节点的个数
size_type count(const key_type& __key) const
{
const size_type __n = _M_bkt_num_key(__key);
size_type __result = 0;

for (const _Node* __cur = _M_buckets[__n]; __cur; __cur = __cur->_M_next)
if (_M_equals(_M_get_key(__cur->_M_val), __key))
++__result;
return __result;
}

private:
// 计算hash表格的大小（取素数表中的合适的素数）
size_type _M_next_size(size_type __n) const
{ return __stl_next_prime(__n); }

// 初始化hash数组
void _M_initialize_buckets(size_type __n)
{
const size_type __n_buckets = _M_next_size(__n);
_M_buckets.reserve(__n_buckets);
_M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0);
_M_num_elements = 0;  // 实际节点个数
}

// 计算下标的几组函数
size_type _M_bkt_num_key(const key_type& __key) const
{
return _M_bkt_num_key(__key, _M_buckets.size());
}

size_type _M_bkt_num(const value_type& __obj) const
{
return _M_bkt_num_key(_M_get_key(__obj));
}

size_type _M_bkt_num_key(const key_type& __key, size_t __n) const
{
return _M_hash(__key) % __n;
}

size_type _M_bkt_num(const value_type& __obj, size_t __n) const
{
return _M_bkt_num_key(_M_get_key(__obj), __n);
}

// 内存管理：分配新节点
_Node* _M_new_node(const value_type& __obj)
{
_Node* __n = _M_get_node();
__n->_M_next = 0;
__STL_TRY {
construct(&__n->_M_val, __obj);
return __n;
}
__STL_UNWIND(_M_put_node(__n));
}

// 内存管理：节点回收
void _M_delete_node(_Node* __n)
{
destroy(&__n->_M_val);
_M_put_node(__n);
}
};

// 插入操作，不允许重复
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)
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;
return pair<iterator, bool>(iterator(__tmp, this), true);
}

// 插入操作，允许重复
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];

// 如果发现同样的key的节点存在，则插入到这个节点之后
for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
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);
}

// 查找或者插入：找到则直接返回，否则进行插入操作
template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::reference
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::find_or_insert(const value_type& __obj)
{
resize(_M_num_elements + 1);

size_type __n = _M_bkt_num(__obj);
_Node* __first = _M_buckets[__n];

for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
return __cur->_M_val;

_Node* __tmp = _M_new_node(__obj);
__tmp->_M_next = __first;
_M_buckets[__n] = __tmp;
++_M_num_elements;
return __tmp->_M_val;
}

// 删除指定key的节点
template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::size_type
hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const key_type& __key)
{
const size_type __n = _M_bkt_num_key(__key);
_Node* __first = _M_buckets[__n];
size_type __erased = 0;

if (__first) {
_Node* __cur = __first;
_Node* __next = __cur->_M_next;
while (__next) {
if (_M_equals(_M_get_key(__next->_M_val), __key)) {
__cur->_M_next = __next->_M_next;
_M_delete_node(__next);
__next = __cur->_M_next;
++__erased;
--_M_num_elements;
}
else {
__cur = __next;
__next = __cur->_M_next;
}
}
if (_M_equals(_M_get_key(__first->_M_val), __key)) {
_M_buckets[__n] = __first->_M_next;
_M_delete_node(__first);
++__erased;
--_M_num_elements;
}
}
return __erased;
}

// 重新调整表格大小
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) {
// 新的表格大小
const size_type __n = _M_next_size(__num_elements_hint);
// 在边界情况下可能无法调整(没有更大的素数了)
if (__n > __old_n) {
vector<_Node*, _All> __tmp(__n, (_Node*)(0),
_M_buckets.get_allocator());
__STL_TRY {
// 填充新的表格
for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) {
_Node* __first = _M_buckets[__bucket];
while (__first) {
size_type __new_bucket = _M_bkt_num(__first->_M_val, __n);
_M_buckets[__bucket] = __first->_M_next;
__first->_M_next = __tmp[__new_bucket];
__tmp[__new_bucket] = __first;
__first = _M_buckets[__bucket];
}
}
// 通过swap交换
_M_buckets.swap(__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 */
}
}
}

// 清空hash表
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;
}

4. unordered_map

C++11标准里面纳入了相关的四个容器：（可以把unordered_map和unordered_multimap当做hashtable来使用）



unordered_map很多接口和SGI的hashtable非常相似。不过我并没有用过hashtable，倒是后来用unordered_map用的多一点。例子很多，这里就不说了。

5. swap

在《Effective C++》讲解异常的时候有提到通过swap的方式确保操作要么成功，要么失败。比如如果要修改某一个地方，可以先通过copy构造一个副本，然后对副本进行修改，最后通过swap操作来实现对原始对象的修改。

这一点在上面分析的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) {
const size_type __n = _M_next_size(__num_elements_hint);
if (__n > __old_n) {
vector<_Node*, _All> __tmp(__n, (_Node*)(0),
_M_buckets.get_allocator());
// =============================================================
// 构造临时的hash表tmp
// =============================================================
__STL_TRY {
for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) {
_Node* __first = _M_buckets[__bucket];
while (__first) {
size_type __new_bucket = _M_bkt_num(__first->_M_val, __n);
_M_buckets[__bucket] = __first->_M_next;
__first->_M_next = __tmp[__new_bucket];
__tmp[__new_bucket] = __first;
__first = _M_buckets[__bucket];
}
}
// =============================================================
// 通过swap交换
// =============================================================
_M_buckets.swap(__tmp);
}
// =============================================================
// 如果出错，则析构tmp中的节点
// =============================================================
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;
}
}
}
}

STL源码剖析笔记系列

1. STL笔记之空间配置器

2. STL笔记之迭代器

3. STL笔记之vector

4. STL笔记之list

5. STL笔记之优先队列

6. STL笔记之deque

7. STL笔记之slist

8. STL笔记之hashtable

本文地址: 程序人生 >> STL笔记之hashtable

作者：代码疯子（Wins0n） 本站内容如无声明均属原创，转载请保留作者信息与原文链接，谢谢！

您可能对下面的文章也感兴趣:
STL笔记之slist
STL笔记之list
STL笔记之vector
STL笔记之deque
HDU 1880 魔咒词典