算法导论小结-散列表

By:             潘云登

Date:          2009-7-18

Email:         intrepyd@gmail.com

Homepage: http://blog.csdn.net/intrepyd

Copyright: 该文章版权由潘云登所有。可在非商业目的下任意传播和复制。

对于商业目的下对本文的任何行为需经作者同意。

---

 

写在前面

1.          本文内容对应《算法导论》(第2版)》第11章。

2.          主要介绍了散列表的基本概念、散列函数的选择，以及两种解决碰撞的方法（链接法和开放寻址法）。

3.          希望本文对您有所帮助，也欢迎您给我提意见和建议。

4.          本文包含以下内容：

²         散列表的基本概念

²         散列函数

²         解决碰撞的方法

²         完全散列

²         链接法和线性探测实现的散列表

---

 

散列表的基本概念

假设某应用要用到一个动态集合，其中每个元素都有一个属于[0..p]的关键字，此处p是一个不太大的数，且没有两个元素具有相同的关键字，则可以用一个数组[p+1]存储该动态集合，并且使用关键字作为数组下标进行直接寻址。这一直接寻址思想在前面的非比较排序中就有所应用。然而，当p很大并且实际要存储的动态集合大小n<<p时，这样一个数组将浪费大部分空间。

散列表(Hash table)，使用具有m个槽位的数组来存储大小为n的动态集合。α=n/m被定义为散列表的装载因子。在散列表中，具有关键字k的元素的下标为h(k)，即利用散列函数h，根据关键字k计算出槽的位置。散列函数h将关键字域[0..p]映射到散列表[0..m-1]的槽位上，这里，m可以远小于p，从而缩小了需要处理的下标范围，并相应地降低了空间开销。散列表带来的问题是：两个关键字可能映射到同一个槽上，这种情形称为碰撞。因此，散列函数h应当将每个关键字等可能地散列到m个槽位的任何一个中去，并与其它关键字已被散列到哪一个槽位中无关，从而避免或者至少最小化碰撞。

---

 

散列函数

多数散列函数都假定关键字域为自然数集。如果所给关键字不是自然数，则必须有一种方法将它们解释为自然数。这里，介绍三种主要的散列函数：

l          除法散列法：通过取k除以m的余数，来将关键字k映射到m个槽的某一个中去，即散列函数为

h(k) = k mod m

当应用除法散列法时，要注意m的选择，这也是除法散列法的主要缺点。m不应是2的幂，因为如果m=2^p，则h(k)就是k的p个最低有效位。相反，散列函数应该考虑关键字的所有位。可以选作m的值通常是与2的整数幂不太接近的质数。

l          乘法散列法：首先，用关键字k乘上常数A(0<A<1)，并抽取kA的小数部分；然后，用m乘以这个值，再取结果的底(即整数部分)。散列函数可表达为：

h(k) = ⌊m(kA mod 1)⌋

乘法方法的一个优点是对m的选择没有特别的要求，一般选择它为2的某个幂次(m=2^p)。该方法对任何的A值都适用，但对某些值效果更好。A=(sqrt(5)-1)/2=0.6180339…是一个比较理想的值。

l          全域散列(universal hashing)：在执行开始时，从一族仔细设计的函数中，随机地选择一个作为散列函数。这里的随机选择针对的是一次对散列表的应用，而不是一次简单的插入或查找操作。散列函数的确定性，是查找操作正确执行的保证。全域散列法确保，当k!=l时，两者发生碰撞的概率不大于1/m。设计一个全域散列函数类的方法如下，该方法中，散列表大小m的大小是任意的。

选择一个足够大的质数p，使得每一个可能的关键字都落在0到p-1的范围内。设Zp表示集合{0, 1, …, p-1}，Zp*表示集合{1, 2, …, p-1}。对于任何a∈Zp*和任何b∈Zp，定义散列函数ha,b ha,b = ((ak+b) mod p) mod m 所有这样的散列函数构成的函数族为： Hp,m = {ha,b : a∈Zp*和b∈Zp} 由于对a来说有p-1种选择，对于b来说有p种选择，因而，Hp,m中共有p(p-1)个散列函数。

 

---

 

解决碰撞的方法

解决碰撞的方法主要有两种：链接法和开放寻址法。

l          链接法(chaining)：把散列到同一槽中的所有元素都存放在一个链表中。每个槽中有一个指针，指向由所有散列到该槽的元素构成的链表的头。如果不存在这样的元素，则指针为空。如果链接法使用的是双向链表，那么删除操作的最坏情况运行时间与插入操作相同，都为O(1)，而平均情况下一次成功的查找需要Θ(1+α)时间。

l          开放寻址法(open addressing)：所有的元素都存放在散列表中。因此，适用于动态集合大小n不大于散列表大小的情况，即装载因子不超过1。否则，可能发生散列表溢出。在开放寻址中，当要插入一个元素时，可以连续地探查散列表的各项，直到找到一个空槽来放置待插入的关键字。探查的顺序不一定是0, 1, …, m-1，而是要依赖于待插入的关键字k。于是，将探查号作为散列函数的第二个输入参数。为了使所有的槽位都能够被探查到，探查序列<h(k,0), h(k,1), …, h(k,m-1)>必须是<0, 1, …, m-1>的一个排列。有三种技术常用来计算开放寻址法中的探查序列：线性探查、二次探查，以及双重探查。

²         线性探查(linear probing)：使用的散列函数如下

h(k,i) = (h’(k) + i) mod m, i=0, 1, …, m-1

h’为一个普通的散列函数，见前面的介绍。线性探查存在一个称为一次群集的问题，即随着时间的推移，连续被占用的槽不断增加，平均查找时间也随着不断增加。但是，线性探查的优点在于，对m的取值没有特殊的要求。

²         二次探查(quadratic probing)：使用的散列函数如下

h(k,i) = (h’(k) +c1 i + c2 i2) mod m, i=0, 1, …, m-1

为了能够充分利用散列表，c₁、c₂和m的值要受到限制。一种好的选择是，m为2的某个幂次(m=2^p)，c₁=c₂=1/2。二次探查，不会顺序地探查每一个槽位，解决了一次群集问题。但是，如果两个关键字的初始探查位置相同，那么它们的探查序列也是相同的，这一性质导致一种程度较轻的群集现象，称为二次群集。

²         双重散列(double hashing)：使用的散列函数如下

h(k,i) = (h1(k) + i h2(k)) mod m, i=0, 1, …, m-1

为能查找整个散列表，值h₂(k)要与表的大小m互质。确保这一条件成立的一种方法是取m为2的幂，并设计一个总能产生奇数的h₂。另一种方法是取m为质数，并设计一个总是产生较m小的正整数的h₂。例如，可以取m为质数，h₂(k)=1+(k mod m’)，m’=m-1。

---

 

完全散列

如果某一种散列技术在进行查找时，其最坏情况内存访问次数为O(1)的话，则称其为完全散列(perfect hashing)。通常利用一种两级的散列方案，每一级上都采用全域散列。为了确保在第二级上不出现碰撞，需要让第二级散列表S_j的大小m_j为散列到槽j中的关键字数n_j的平方。如果利用从某一全域散列函数类中随机选出的散列函数h，来将n个关键字存储到一个大小为m=n的散列表中，并将每个二次散列表的大小置为m_j=n_j² (j=0, 1, …, m-1)，则在一个完全散列方案中，存储所有二次散列表所需的存储总量的期望值小于2n。

---

 

附：链接法和线性探测实现的散列表

 

/*  * chain_hash.c  * Implement of hash table using chaining method.  *  * Author: Yundeng Pan  * Date:   2009-7-18  * Email:  intrepyd@gmail.com  * Blog:   http://blog.csdn.net/intrepyd  */ #include <stdio.h> #include <stdlib.h> #include "chain_hash.h"   #define HASH_CONSTANT 0.6180339   typedef struct node {     int key;     struct node *prev;     struct node *next; }chain_hash_node;   chain_hash_node *new_chain_hash_table(int hash_table_size) {     int i;     chain_hash_node *chain_hash_table;       chain_hash_table = malloc(sizeof(chain_hash_node)*hash_table_size);     for(i=0; i<hash_table_size; i++)     {                   chain_hash_table[i].key = 0;                   chain_hash_table[i].prev = NULL;                   chain_hash_table[i].next = NULL;     }       return chain_hash_table; }   void free_chain_hash_table(chain_hash_node *chain_hash_table,                                int hash_table_size) {     int i;     chain_hash_node *node;         for(i=0; i<hash_table_size; i++)     {                   while(chain_hash_table[i].next != NULL)                   {                         node = chain_hash_table[i].next;                         chain_hash_delete(chain_hash_table[i].next);                         free(node);                         node = NULL;                   }     }     free(chain_hash_table);     chain_hash_table = NULL; }   void chain_hash_delete(chain_hash_node *node) {     node->prev->next = node->next;     if(node->next != NULL)                   node->next->prev = node->prev; }   int chain_hash_func(int hash_table_size, int value) {     return (hash_table_size * ((value*HASH_CONSTANT)-(int)(value*HASH_CONSTANT))); }   void chain_hash_insert(chain_hash_node *chain_hash_table,                           int hash_table_size, int value) {     int index;     chain_hash_node *node;       index = chain_hash_func(hash_table_size, value);     node = malloc(sizeof(chain_hash_node));     node->key = value;     node->prev = &chain_hash_table[index];     if(chain_hash_table[index].next != NULL)              chain_hash_table[index].next->prev = node;     node->next = chain_hash_table[index].next;     chain_hash_table[index].next = node; }   chain_hash_node *chain_hash_search(chain_hash_node *chain_hash_table,                                         int hash_table_size, int value) {     int index;     chain_hash_node *node;       index = chain_hash_func(hash_table_size, value);     node = chain_hash_table[index].next;     while(node != NULL)     {                   if(node->key == value)                         return node;                   node = node->next;     }       return NULL; }   void chain_hash_print(chain_hash_node *chain_hash_table,                          int hash_table_size) {     int i;     chain_hash_node *node;       printf("/nchain_hash_table:");     for(i=0; i<hash_table_size; i++)     {                   printf("/nslot %d: ", i);                   node = &chain_hash_table[i];                   while(node != NULL)                   {                         printf("%d ", node->key);                         node = node->next;                   }     }     printf("/n/n"); }

 

/*  * probe_hash.c  * Implement of hash table using linear probing.  *  * Author: Yundeng Pan  * Date:   2009-7-18  * Email:  intrepyd@gmail.com  * Blog:   http://blog.csdn.net/intrepyd  */ #include <stdio.h> #include <stdlib.h> #include "probe_hash.h"   #define HASH_CONSTANT 0.6180339 #define NIL -1   int *new_probe_hash_table(int hash_table_size) {     int i, *probe_hash_table;       probe_hash_table = malloc(sizeof(int)*hash_table_size);     for(i=0; i<hash_table_size; i++)     {                   probe_hash_table[i] = NIL;     }       return probe_hash_table; }   void free_probe_hash_table(int *probe_hash_table) {     free(probe_hash_table); }   int probe_inner_hash_func(int hash_table_size, int value) {     return (hash_table_size * ((value*HASH_CONSTANT)-(int)(value*HASH_CONSTANT))); }   int probe_hash_func(int hash_table_size, int key, int index) {     return (key + index) % hash_table_size; }   int probe_hash_insert(int *probe_hash_table, int hash_table_size, int value) {     int i, key, pos;       key = probe_inner_hash_func(hash_table_size, value);     for(i=0; i<hash_table_size; i++)     {                   pos = probe_hash_func(hash_table_size, key, i);                   if(probe_hash_table[pos] == NIL)                   {                         probe_hash_table[pos] = value;                         return pos;                   }     }       printf("Hash table overflow!/n");     return NIL; }   int probe_hash_search(int *probe_hash_table, int hash_table_size, int value) {     int i, key, pos;       key = probe_inner_hash_func(hash_table_size, value);     for(i=0; i<hash_table_size; i++)     {                   pos = probe_hash_func(hash_table_size, key, i);                   if(probe_hash_table[pos] == NIL)                         break;                   if(probe_hash_table[pos] == value)                         return pos;     }       printf("Not found!/n");     return NIL; }   void probe_hash_delete(int *probe_hash_table, int hash_table_size, int value) {     int pos;       pos = probe_hash_search(probe_hash_table, hash_table_size, value);     if(pos != NIL)                   probe_hash_table[pos] = NIL; }   void probe_hash_print(int *probe_hash_table, int hash_table_size) {     int i;       printf("/nprobe_hash_table:");     for(i=0; i<hash_table_size; i++)     {                   printf("/nslot %d: %d", i, probe_hash_table[i]);     }     printf("/n/n"); }