1、hashtable概述
hashtable被视为一种字典结构(dictionary),这种结构可以提供常数时间O(logN)的基本操作,就像stack或queue那样。能带来这种O(logN)实现的关键是散列函数(hash function),使用散列函数会带来一个问题:可能有不同的元素被映射到相同的位置即有相同的索引。这无法避免,因为元素个数大于array容量,这便是碰撞问题。解决碰撞问题的方法有许多种,包括线性探测、二次探测、开链等。
2、碰撞问题的解决方法
(1)线性探测
当散列函数计算出某个元素的插入位置,而该位置上的空间已不再可用时,最简单的办法就是循序往下一一寻找,直到找到一个可用空间为止,只要表格array足够大,总是能找到一个安身立命的空间,但是要花多少时间就很难说了。进行元素搜寻操作时,道理也相同,如果散列表计算出来的位置上的元素值与我们的搜寻目标不符,就循序往下一一寻找,直到找到吻合者或者直到遇上空格元素。
分析线性探测的表现,需要两个假设:一表格足够大,二每个元素都够独立。在此假设之下,最坏的情况是线性寻访整个表格,平均情况则是寻访一半表格。所以线性探测的一个突出问题是:平均插入成本的成长幅度,远高于负载系数的成长幅度,这样的现象在hashing过程中称为主集团primary clustering(此时我们手上有的是一大团已被用过的方格,插入操作极有可能在主集团所形成的泥泞中奋力爬行,不断解决碰撞问题)。
(2)二次探测
二次检测主要用来解决主集团的问题,其解决碰撞问题的方程式F(i)=i^2是个二次方程式。如果散列函数计算出新元素的位置为H,而该位置实际上已被使用,那么我们就依序尝试H+1^2,H+2^2,H+3^2,...,H+i^2,而不是像线性探测那样依序尝试H+1,H+2,...,H+i。
二次探测的好处,如果我们假设表格大小为质数(prime),而且永远保持负载系数在0.5一下(如果超过0.5就重新配置并重新整理表格),那么就可以确定每插入一个新元素所需要的探测次数不多于2。如果发生碰撞问题对于计算下一个插入点位置,Hi=H0+i^2(mod M),Hi-1=H0+(i-1)^2(mod M),使用增量算法思想,整理得Hi-Hi-1=i^2-(i-1)^2(mod M),Hi=Hi-1+2*i-1(mod M),这样就不需要进行次方计算转为乘2计算可以通过位移快速完成。对于array的成长,欲扩充表格,首先必须找出下一个新的而且够大(大约两倍)的质数,然后必须考虑重建的成本,重新对于旧表格中每一个元素计算其在新表格中的位置mod N,然后再插入新表格中。
总结:二次探测可以消除主集团,却造成次集团:两个元素经散列函数计算出来的位置若相同,则插入时所探测的位置也相同,形成某种浪费,消除次集团的办法也有例如复式散列。总体而言,二次探测仍然值得投资。
(3)开链
另一种和二次探测法分庭抗礼的就是开链法,STL的hashtable便是采用这种做法。这种做法是在每一个表格元素中维护一个list:散列函数为我们分配某一个list,然后我们在那个list身上执行元素的插入、搜寻、删除等操作。虽然针对list而进行的搜寻只能是一种线性操作,但如果list够短,速度还是够快。使用开链法,表格的负载系数将大于1(元素个数除以表格大小)。
3、hashtable的桶子buckets与节点nodes
hashtable的表格内的元素为桶子bucket,表格内的每个单元,涵盖的不只是节点,而且可能是一桶节点。每个节点的定义如下:一个节点值和一个指针指向下一个节点
template <class Value>
struct __hashtable_node
{
__hashtable_node* next;
Value val;
};
4、hashtable迭代器
hashtable的迭代器有两个数据成员hashtable* ht保持对容器的连结关系和node* cur目前所指的节点。hashtable迭代器必须永远维系着与整个buckets vector的关系,并记录目前所指的节点。利用节点的next指针即可轻易达成前进操作,如果目前节点正好是list的尾端,就跳至下一个bucket身上,那正是指向下一个list的头部节点。hashtable迭代器没有后退operator--操作。
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_iterator<Value, Key, HashFcn,
ExtractKey, EqualKey, Alloc>
iterator;
typedef __hashtable_const_iterator<Value, Key, HashFcn,
ExtractKey, EqualKey, Alloc>
const_iterator;
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_iterator(node* n, hashtable* tab) : cur(n), ht(tab) {}
__hashtable_iterator() {}
reference operator*() const { return cur->val; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_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; }
};
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;
if (!cur) {
size_type bucket = ht->bkt_num(old->val);
while (!cur && ++bucket < ht->buckets.size())
cur = ht->buckets[bucket];
}
return *this;
}
template <class V, class K, class HF, class ExK, class EqK, class A>
inline __hashtable_iterator<V, K, HF, ExK, EqK, A>
__hashtable_iterator<V, K, HF, ExK, EqK, A>::operator++(int)
{
iterator tmp = *this;
++*this;
return tmp;
}
5、hashtable数据结构
buckets聚合体以vector完成,以利动态扩充,vector<node*,Alloc> buckets。num_elements为hashtable中元素个数,bucket_count()返回bucket个数即buckets vector的大小。hashtable的计算元素位置赋予给了函数bkt_num(),通过它调用散列函数取得一个可以执行取模运算的值。开链法并不要求表格大小必须为质数,但STL仍然以质数来设计表格大小,并且先将28个质数计算好,逐渐呈现大约两倍的关系,以备随时访问,同时提供一个函数,用来查询在这28个质数之中最接近某数并大于某数的质数。
class hashtable {
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;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
hasher hash_funct() const { return hash; }
key_equal key_eq() const { return equals; }
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;
size_type num_elements;
public:
size_type bucket_count() const { return buckets.size(); }
};
static const int __stl_num_primes = 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, 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 + __stl_num_primes;
const unsigned long* pos = lower_bound(first, last, n);
return pos == last ? *(last - 1) : *pos;
}
6、hashtable的构造与内存管理
insert_unique:先判断是否需要重建表格,若元素个数大于buckets vector大小,重建表格扩充大小。重建表格需要将旧bucket里每个节点通过节点值计算出位于新bucket的位置,然后通过旧bucket中的first头插法插入到新bucket中去。在不需要重建表格的情况下插入新节点的时候,首先检查该bucket中是否有和obj相同的元素,遍历bucket中每个节点,如果有不插入返回false,如果没有的话就头插法插入新节点。
insert_equal:和insert_unique不同的地方在于,首先检查该bucket中是否有和obj相同的元素,遍历bucket中每个节点,如果有直接尾插法插入,如果没有的话就头插法插入新节点。
bkt_num:判知元素的落脚处,通过调用哈希函数bkt_num_key计算元素值应该插入的位置hash(key)%n。
node* new_node(const value_type& obj)
{
node* n = node_allocator::allocate();
n->next = 0;
__STL_TRY {
construct(&n->val, obj);
return n;
}
__STL_UNWIND(node_allocator::deallocate(n));
}
void delete_node(node* n)
{
destroy(&n->val);
node_allocator::deallocate(n);
}
void initialize_buckets(size_type n)
{
const size_type n_buckets = next_size(n);
buckets.reserve(n_buckets);
buckets.insert(buckets.end(), n_buckets, (node*) 0);
num_elements = 0;
}
pair<iterator, bool> insert_unique(const value_type& obj)
{
resize(num_elements + 1);
return insert_unique_noresize(obj);
}
template <class V, class K, class HF, class Ex, class Eq, class A>
pair<typename hashtable<V, K, HF, Ex, Eq, A>::iterator, bool>
hashtable<V, K, HF, Ex, Eq, A>::insert_unique_noresize(const value_type& obj)
{
const size_type n = bkt_num(obj);
node* first = buckets[n];
for (node* cur = first; cur; cur = cur->next)
if (equals(get_key(cur->val), get_key(obj)))
return pair<iterator, bool>(iterator(cur, this), false);
node* tmp = new_node(obj);
tmp->next = first;
buckets[n] = tmp;
++num_elements;
return pair<iterator, bool>(iterator(tmp, this), true);
}
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)
{
const size_type old_n = buckets.size();
if (num_elements_hint > old_n) {
const size_type n = next_size(num_elements_hint);
if (n > old_n) {
vector<node*, A> tmp(n, (node*) 0);
__STL_TRY {
for (size_type bucket = 0; bucket < old_n; ++bucket) {
node* first = buckets[bucket];
while (first) {
size_type new_bucket = bkt_num(first->val, n);
buckets[bucket] = first->next;
first->next = tmp[new_bucket];
tmp[new_bucket] = first;
first = buckets[bucket];
}
}
buckets.swap(tmp);
}
}
}
}
iterator insert_equal(const value_type& obj)
{
resize(num_elements + 1);
return insert_equal_noresize(obj);
}
template <class V, class K, class HF, class Ex, class Eq, class A>
typename hashtable<V, K, HF, Ex, Eq, A>::iterator
hashtable<V, K, HF, Ex, Eq, A>::insert_equal_noresize(const value_type& obj)
{
const size_type n = bkt_num(obj);
node* first = buckets[n];
for (node* cur = first; cur; cur = cur->next)
if (equals(get_key(cur->val), get_key(obj))) {
node* tmp = new_node(obj);
tmp->next = cur->next;
cur->next = tmp;
++num_elements;
return iterator(tmp, this);
}
node* tmp = new_node(obj);
tmp->next = first;
buckets[n] = tmp;
++num_elements;
return iterator(tmp, this);
}
size_type bkt_num(const value_type& obj, size_t n) const
{
return bkt_num_key(get_key(obj), n);
}
size_type bkt_num_key(const key_type& key, size_t n) const
{
return hash(key) % n;
}
template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::clear()
{
for (size_type i = 0; i < buckets.size(); ++i) {
node* cur = buckets[i];
while (cur != 0) {
node* next = cur->next;
delete_node(cur);
cur = next;
}
buckets[i] = 0;
}
num_elements = 0;
}
template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::copy_from(const hashtable& ht)
{
buckets.clear();
buckets.reserve(ht.buckets.size());
buckets.insert(buckets.end(), ht.buckets.size(), (node*) 0);
__STL_TRY {
for (size_type i = 0; i < ht.buckets.size(); ++i) {
if (const node* cur = ht.buckets[i]) {
node* copy = new_node(cur->val);
buckets[i] = copy;
for (node* next = cur->next; next; cur = next, next = cur->next) {
copy->next = new_node(next->val);
copy = copy->next;
}
}
}
num_elements = ht.num_elements;
}
__STL_UNWIND(clear());
}
7、散列函数
<stl_hash_fun.h>定义有数个现成的散列函数,全都是仿函数。散列函数是可以计算元素位置的函数,针对char、int、long等整数型别,这里大部分的散列函数什么也没做,只是忠实返回原值,但对于字符串(const char*),就设计了一个转换函数:h=5*h+*s。hashtable无法处理下述所列型别以外的元素,例如string,double,float。欲处理这些型别,用户必须自己定义它们的散列函数。
template <class Key> struct hash { };
inline size_t __stl_hash_string(const char* s)
{
unsigned long h = 0;
for ( ; *s; ++s)
h = 5*h + *s;
return size_t(h);
}
__STL_TEMPLATE_NULL struct hash<char*>
{
size_t operator()(const char* s) const { return __stl_hash_string(s); }
};
__STL_TEMPLATE_NULL struct hash<const char*>
{
size_t operator()(const char* s) const { return __stl_hash_string(s); }
};
__STL_TEMPLATE_NULL struct hash<char> {
size_t operator()(char x) const { return x; }
};
__STL_TEMPLATE_NULL struct hash<unsigned char> {
size_t operator()(unsigned char x) const { return x; }
};
__STL_TEMPLATE_NULL struct hash<signed char> {
size_t operator()(unsigned char x) const { return x; }
};
__STL_TEMPLATE_NULL struct hash<short> {
size_t operator()(short x) const { return x; }
};
__STL_TEMPLATE_NULL struct hash<unsigned short> {
size_t operator()(unsigned short x) const { return x; }
};
__STL_TEMPLATE_NULL struct hash<int> {
size_t operator()(int x) const { return x; }
};
__STL_TEMPLATE_NULL struct hash<unsigned int> {
size_t operator()(unsigned int x) const { return x; }
};
__STL_TEMPLATE_NULL struct hash<long> {
size_t operator()(long x) const { return x; }
};
__STL_TEMPLATE_NULL struct hash<unsigned long> {
size_t operator()(unsigned long x) const { return x; }
};