13hashtable

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; }
};