C++ 11已将哈希表纳入了标准之列。hashtable是hash_set、hash_map、hash_multiset、hash_multimap的底层机制，即这四种容器中都包含一个hashtable。
解决碰撞问题的办法有许多，线性探测、二次探测、开链等等。SGI STL的hashtable采用的开链方法，每个hash table中的元素用vector承载，每个元素称为桶（bucket），一个桶指向一个存储了实际元素的链表（list），链表节点（node）结构如下：
~~~
template <class Value>
struct __hashtable_node
{
__hashtable_node* next;
Value val; // 存储实际值
};
~~~
再来看看hash table的迭代器定义：
~~~
template <class Value, class Key, class HashFcn,
class ExtractKey, class EqualKey, class Alloc>
struct __hashtable_iterator { // 迭代器
typedef hashtable<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc>
hashtable;
....
typedef __hashtable_node<Value> node;
// 定义迭代器相应类型
typedef forward_iterator_tag iterator_category; // 前向迭代器
typedef Value value_type;
typedef ptrdiff_t difference_type;
typedef size_t size_type;
typedef Value& reference;
typedef Value* pointer;
node* cur; // 迭代器目前所指节点
hashtable* ht; // 和hashtable之间的纽带
__hashtable_iterator(node* n, hashtable* tab) : cur(n), ht(tab) {}
__hashtable_iterator() {}
reference operator*() const { return cur->val; }
pointer operator->() const { return &(operator*()); }
iterator& operator++();
iterator operator++(int);
bool operator==(const iterator& it) const { return cur == it.cur; }
bool operator!=(const iterator& it) const { return cur != it.cur; }
};
~~~
hash table的迭代器不能后退，这里关注迭代器的自增操作，代码如下：
~~~
template <class V, class K, class HF, class ExK, class EqK, class A>
__hashtable_iterator<V, K, HF, ExK, EqK, A>&
__hashtable_iterator<V, K, HF, ExK, EqK, A>::operator++() // 注意类模板成员函数的定义
{
const node* old = cur;
cur = cur->next; // 移动到下一个node
if (!cur) { // 到了list结尾
size_type bucket = ht->bkt_num(old->val); // 根据节点值定位旧节点所在桶号
while (!cur && ++bucket < ht->buckets.size()) // 计算下一个可用桶号
cur = ht->buckets[bucket]; // 找到，另cur指向新桶的第一个node
}
return *this;
}
~~~
hashtable数据结构内容很多，这里只列出少量代码：
~~~
template <class Value, class Key, class HashFcn,
class ExtractKey, class EqualKey,
class Alloc>
class hashtable { // hash table数据结构
public:
typedef Key key_type;
typedef Value value_type;
typedef HashFcn hasher; // 散列函数类型
typedef EqualKey key_equal;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
....
private:
hasher hash; // 散列函数
key_equal equals; // 判断键值是否相等
ExtractKey get_key; // 从节点取出键值
typedef __hashtable_node<Value> node;
typedef simple_alloc<node, Alloc> node_allocator; // 空间配置器
vector<node*,Alloc> buckets; // 桶的集合，可以看出一个桶实值上是一个node*
size_type num_elements; // node个数
....
}
~~~
SGI STL将hash table的大小，也就是vector的大小设计为28个质数，并存放在一个数组中：
~~~
static const int __stl_num_primes = 28; // 28个质数
static const unsigned long __stl_prime_list[__stl_num_primes] =
{
53, 97, 193, 389, 769,
1543, 3079, 6151, 12289, 24593,
49157, 98317, 196613, 393241, 786433,
1572869, 3145739, 6291469, 12582917, 25165843,
50331653, 100663319, 201326611, 402653189, 805306457,
1610612741, 3221225473, 4294967291
};
~~~
当vector容量不足时，会以两倍的容量进行扩充。
下面介绍插入操作，以insert_unique为例：
~~~
// 插入新元素，键值不能重复
pair<iterator, bool> insert_unique(const value_type& obj)
{
resize(num_elements + 1); // 判断vector是否需要扩充
return insert_unique_noresize(obj); // 直接插入obj
}
~~~
insert操作大致分两步：第一步是扩充（如果需要的话），第二步是插入。
resize代码如下：
~~~
template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::resize(size_type num_elements_hint) // 判断是否需要扩充vector
{
const size_type old_n = buckets.size();
if (num_elements_hint > old_n)
{ // 元素个数大于vector容量，则需要扩充vector
const size_type n = next_size(num_elements_hint);
if (n > old_n)
{
vector<node*, A> tmp(n, (node*) 0); // 建立一个临时的vector作为转移目的地
for (size_type bucket = 0; bucket < old_n; ++bucket)
{ // 一个桶一个桶进行转移
node* first = buckets[bucket];
while (first)
{ // 一个节点一个节点进行转移
size_type new_bucket = bkt_num(first->val, n); // 散列过程，对n取模
buckets[bucket] = first->next;
first->next = tmp[new_bucket]; // 这一句和下一句表示从链表前端插入
tmp[new_bucket] = first;
first = buckets[bucket]; // first指向旧vector的下一个node
}
buckets.swap(tmp); // 两个vector的内容互换，使buckets彻底改变
}
}
}
}
~~~
上述代码基本思路就是：先扩充，再移动，最后交换。
- 扩充利用next_size函数。next_size的作用就是从质数表中选取最接近并且不小于num_elements_hint的质数并返回，利用这个较大值开辟一个新vector。
- 移动实质上就是指针的移动。重新对每个节点进行散列，然后从前链入到新的vector中。
- 交换过程就是上面代码红色部分。这里使用了vector内部的swap成员函数，将*this和tmp的内容进行了互换，这是copy-and-swap技术，《Effective C++》条款11有说明这个技术。扩充完vector后，就可以顺利插入需要插入的元素了。
insert_unique_noresize代码如下：
~~~
template <class V, class K, class HF, class Ex, class Eq, class A>
pair<typename hashtable<V, K, HF, Ex, Eq, A>::iterator, bool> // 注意，返回一个pair
hashtable<V, K, HF, Ex, Eq, A>::insert_unique_noresize(const value_type& obj) // 直接插入节点，无需扩充
{
const size_type n = bkt_num(obj); // 对obj进行散列，然后模上vector大小，从而确定桶号
node* first = buckets[n]; // first指向对应桶的第一个node
for (node* cur = first; cur; cur = cur->next)
if (equals(get_key(cur->val), get_key(obj))) // 遇到相同node，则直接返回这个node
return pair<iterator, bool>(iterator(cur, this), false);
// 没有遇到相同node，则在list开头插入
node* tmp = new_node(obj);
tmp->next = first;
buckets[n] = tmp;
++num_elements;
return pair<iterator, bool>(iterator(tmp, this), true);
}
~~~
这里也是将新节点插入list的开头，详细过程已在注释中说明。
参考：
《STL源码剖析》 P253.
- 前言
- 顺序容器 — heap
- 关联容器 — 红黑树
- 关联容器 — set
- 关联容器 — map
- 关联容器 — hashtable
- 关联容器 — hash_set
- 关联容器 — hash_map
- 算法 — copy
- 顺序容器 — stack
- 顺序容器 — queue
- 顺序容器 — priority_queue
- 顺序容器 — slist
- construct()和destroy()
- 空间配置器
- 函数适配器
- 迭代器以及“特性萃取机”iterator_traits
- 算法 — partial_sort
- 算法 — sort
- 仿函数
- 适配器（adapters）
- C++简易vector
- C++简易list
- STL算法实现
- C++模板Queue