词典(二) 哈希表(Hash table)
散列表(hashtable)是一种高效的词典结构，可以在期望的常数时间内实现对词典的所有接口的操作。散列完全摒弃了关键码有序的条件，所以可以突破CBA式算法的复杂度界限。
散列表
逻辑上，有一系列可以存放词条的单元(桶)组成。各个桶按照逻辑次序，在物理上也应当是连续的，因而，可以采用数组来实现，散列表也可以称为桶数组。合法的秩空间[0,R)也可以称作地址空间。
散列函数
散列，即为关键码空间到桶地址空间的映射，hash():key->hash(key)
假设学号为2013300000-2013303999，一个长度为4000的散列表A[0-3999]，只需要hash(key)=key-2013300000，即可实现没有空余也没有重复的散列，称为完美散列。
实际上，完美散列是非常困难的，比如，一个电话号码为7位，而一个单位的电话为几千个，此时按照这种映射，仍然需要10^7次方规模的桶数组。定义装填因子为非空桶/桶的总数，此时的利用率非常低。
因此，制定合理的映射，是非常重要的。散列函数的选取，在计算上应当尽量简单，关键码经过映射后尽量占据整个地址空间，并且映射到各个桶的概率应当接近于1/M。简单的散列函数策略有几种：
（1）除余法：hash(key)=key mod M。显然，如此简单的策略会造成很大的问题，随机性并不好而且容易冲突。
（2）MAD法：multiple-add-divide，hash(key)=(a*key+b) mod M。可以看到，除余法是a=1,b=0的特例。相当于是一种线性方法。
（3）数字分析法：从key的特定进制展开中取出特定的若干位。
还有平方取中法、折叠法异或法等...实现的时候为了简单，可以采用随机数法，不过不同的语言和平台随机数的实现方式可能不同，需谨慎。
1 template<typename K, typename V> class Hashtable :public Dictionary<K, V> 2 { 3 private: 4 Entry<K, V>** ht;//桶数组，存放词条指针 5 int M;//桶数组的数量 6 int N;//词条的数量 7 Bitmap* lazyRemoval;//懒惰删除标记 8 #define lazilyRemoved(x) (lazyRemoval->test(x)) 9 #define markAsRemoved(x) (lazyRemoval->set(x)) 10 protected: 11 int probe4Hit(const K& k);//沿关键码k对应的查找链，找到词条匹配的桶 12 int probe4Free(const K& k);//沿关键码k对应的查找链，找到首个可用的桶 13 void rehash();//重散列算法：扩充桶数组，保证装填因子的警戒线之下 14 public: 15 Hashtable(int c = 5);//创建一个容量不小于c的散列表 16 ~Hashtable();//释放桶数组及其中各元素所指向的词条 17 int size() const { return N; } 18 bool put(K k, V v); 19 V* get(K k); 20 bool remove(K k); 21 };
散列表的实现，内部主要是维护一个桶数组，外部接口即为词典的接口。
1 template<typename K, typename V> Hashtable<K, V>::Hashtable(int c) 2 { 3 M = primeNLT(c,1048576,"prime.txt");//不小于c的素数，应当计算好后列表备查 4 N = 0; 5 ht = new Entry<K, V>*[M]; 6 memset(ht, 0, sizeof(Entry<K, V>*) * M); 7 lazyRemoval = new Bitmap(M); 8 } 9 int primeNLT(int c, int n, std::string file)//查找素数 10 { 11 Bitmap b(n); 12 std::ifstream ifile(file); 13 int num; 14 while (ifile >> num) 15 b.set(num); 16 while (c < n) 17 if (!b.test(c)) c++;//若当前位为0，继续寻找 18 else 19 return c; 20 return 0; 21 }
这里实现的策略，是从事先计算好的文件中选取一个素数作为桶的初始数量。
1 template<typename K, typename V> Hashtable<K, V>::~Hashtable() 2 { 3 for (int i = 0; i < M; i++) 4 if (ht[i]) delete ht[i];//释放非空的桶 5 delete ht; 6 delete lazyRemoval; 7 }
析构函数要注意，释放掉非空的桶以及用来标记的位图结构。
冲突
散列表的一个很大问题，就是冲突。因为散列的基本思想，就是通过快速把key转换为一个秩，从而可以迅速进行查询、插入和删除这样的词典操作。但是，即使把桶数组设置地非常大，或者选择特别合适的哈希函数，也非常有可能造成冲突，即hash(key1)=hash(key2)。此时，后一个词条插入的时候，对应的已经被占用了。因此，必须采用一种办法，化解这种冲突。常见的冲突排解方法有几种：
（1）多槽位法。把一组冲突的词条设置为一个小规模的词典，分别存放在对应的桶单元中。一种简单的方法，把每个桶细分为小的槽位，比如用向量或者列表来实现。这种方法的缺陷显而易见，很多槽位是空着的，利用率很低。
（2）独立链法。与多槽位法类似，不过把每组冲突的词条组织为一个链表的形式。这种方法的缺点在于，查找冲突的时候需要遍历整个链表。
（3）公共溢出区法。在原来的散列之外另设置一个词典，插入冲突时就转存到其中。
闭散列
说了那么多，最后还是要采用一种别的方法0 0闭散列的方法，就是充分利用散列表中的空桶，桶地址对于散列中的其他桶是开放的，散列内部与外界是封闭的。具体地，采用查找链的方法。最简单的就是线性试探，每次冲突的时候，在后继中查找最近的空桶，第i次试探的桶单元为(hash(key)+i) mod M。这种方法也存在较大的缺陷，容易局部聚集从而加长查找的长度，可以采用平方试探法等方法改进。
这种线性查找的方法，可能会因为多个相邻的冲突词条，而产生彼此的交替，在这种情况下，查找的长度也会增大。如果删除了其中的元素，查找链会断裂，从而影响到其他词条的查询。一种解决的办法是懒惰删除，即删除一个元素后，用位图结构来标记，删除掉实际的词条。这样，在实际的查找过程中，无论桶是否空，只要标记存在，就可以继续向下进行查找。基于线性试探的策略如下：
1 template<typename K, typename V> V* Hashtable<K, V>::get(K k) 2 { 3 int r = probe4Hit(k); 4 return ht[r] ? &(ht[r]->value) : NULL; 5 } 6 template<typename K, typename V> int Hashtable<K, V>::probe4Hit(const K& k)//寻找匹配的桶 7 { 8 int r = hashCode(k) % M; 9 while ((ht[r] && (k != ht[r]->key)) || (!ht[r] && lazilyRemoval(r)))//冲突，或者桶为空但是标记过 10 r = (r + 1) % M;//沿着查找链试探 11 return r; 12 } 13 template<typename K, typename V> bool Hashtable<K, V>::remove(K k) 14 { 15 int r = probe4Hit(k); if (!ht[r])return false;//如果词条不存在无法删除 16 delete ht[r]; ht[r] = NULL; markAsRemoved(r); N--; 17 return true; 18 }
对于插入操作，需要先寻找一个合适的空桶，如果没有空桶，那么需要重新分配一个哈希表。为了保证效率，规定装填因子不超过1/2。
1 template<typename K, typename V> bool Hashtable<K, V>::put(K k, V v) 2 { 3 if (ht[probe4Hit(k)]) return false; 4 int r = probe4Free(k);//寻找空桶(控制装填因子，故必然成功) 5 ht[r] = new Entry<K, V>(k, v); ++N;//懒惰删除标志无需复位 6 if (N * 2 > M) rehash();//装填因子小于0.5重散列 7 return true; 8 } 9 template<typename K, typename V> int Hashtable<K, V>::probe4Free(const K& k) 10 { 11 int r = hashCode(k) % M;//除余法确定起始桶 12 while (ht[r]) r = (r + 1) % M;//沿着查找链直到首个空桶（无论是否带有懒惰删除标记） 13 return r; 14 } 15 template<typename K, typename V> void Hashtable<K, V>::rehash() 16 { 17 int old_capacity = M;//记录之前的桶数 18 Entry<K, V>** old_ht = ht; 19 M = primeNLT(2 * M, 1048576, "prime.txt");//容量加倍 20 N = 0; ht = new Entry<K, V>*[M]; memset(ht, 0, sizeof(Entry<K, V>*)*M); 21 delete lazyRemoval; lazyRemoval = new Bitmap(M);//新申请一个位图 22 for (int i = 0; i < old_capacity; i++) 23 if (old_ht[i]) 24 put(old_ht[i]->key, old_ht[i]->value); 25 delete[] old_ht; 26 }
rehash()的策略并不复杂，其实就是重新分配一个数组，并把原来的数组转移到其中，再释放掉之前的数组。
最后，因为key不可能总数整数，因此，需要把char double long等等类型转换为hashcode，方法有很多，在此不表0 0
在介绍理论的最后0 0哈希函数的选择以闭策略的选择都有很多，其实只要弄懂散列的思想以及实现就可以了，细节的方法，各种语言都有自己的哈希表，甚至好多种...
散列的应用
没刷过题，就先搬运下书上的几个例子吧。
桶排序
桶排序可以打破CBA式排序理论上nlogn的界限。通过哈希的策略，通过独立链构建方法，即可实现基于哈希的排序。具体操作，即使用最简单的哈希函数hash(key)=key，把数字存入相应的桶，然后再从头到尾输出桶数组即可。只需要遍历数字一遍，常数时间计算hash(key)，再遍历输出一遍即可，复杂度为O(n)。
基数排序
假设一组词条采用字典序等方式排序，比如英文词典。这时，只需要用多趟桶排序即可完成。具体地，从优先级最低的位开始进行桶排序，排序后的结果再按照优先级的顺序，知道最后一趟排序完，结果即为所需。具体的证明就忽略了...复杂度为O(t*(n+M))，其中M为各个字段的取值范围的最大值，t为趟数。
