散
列表设计
(刘爱贵 - Aiguille.LIU)
(刘爱贵 - Aiguille.LIU)
1、基本概念
散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。
2、常用的构造散列函数的方法
散列函数能使对一个数据序列的访问过程更加迅速有效,通过散列函数,数据元素将被更快地定位。散列表的常用构造方法有:
(1)直接定址法
(2)数字分析法
(3)平方取中法
(4)折叠法
(5)随机数法
(6)除留余数法
3、处理冲突的方法
散列表函数设计好的情况下,可以减少冲突,但是无法完全避免冲突。常见有冲突处理方法有:
(1)开放定址法
(2)再散列法
(3)链地址法(拉链法)
(4)建立一个公共溢出区
4、散列表查找性能分析
散列表的查找过程基本上和造表过程相同。一些关键码可通过散列函数转换的地址直接找到,另一些关键码在散列函数得到的地址上产生了冲突,需要按处理冲突的方法进行查找。在介绍的三种处理冲突的方法中,产生冲突后的查找仍然是给定值与关键码进行比较的过程。所以,对散列表查找效率的量度,依然用平均查找长度来衡量。
查找过程中,关键码的比较次数,取决于产生冲突的多少,产生的冲突少,查找效率就高,产生的冲突多,查找效率就低。因此,影响产生冲突多少的因素,也就是影响查找效率的因素。影响产生冲突多少有以下三个因素:
1. 散列函数是否均匀;
2. 处理冲突的方法;
3. 散列表的装填因子。
散列表的装填因子定义为:α= 填入表中的元素个数 / 散列表的长度。
α是散列表装满程度的标志因子。由于表长是定值,α与“填入表中的元素个数”成正比,所以,α越大,填入表中的元素较多,产生冲突的可能性就越大;α越小,填入表中的元素较少,产生冲突的可能性就越小。实际上,散列表的平均查找长度是装填因子α的函数,只是不同处理冲突的方法有不同的函数。
(以上内容的详细介绍可以参见参考文献1。)
5、一个散列表实例
"The C Programming Language"一书中给出了一个散列表例子。它的实现代码很典型,可以在宏处理器或编译器的符号表管理例程中找到。完整的C代码如下:
#include
<
stdio.h
>
#include < string .h >
#define HASHSIZE 101
struct nlist {
struct nlist *next;
char *keys;
char *value;
} ;
static struct nlist * hashtable[HASHSIZE];
unsigned hash( char * s)
{
unsigned hashval;
for (hashval = 0; *s != ''; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
struct nlist * hashtable_search( char * s)
{
struct nlist *np;
for (np = hashtable[hash(s)]; np != NULL; np = np->next)
if (strcmp(s, np->keys) == 0)
return np;
return NULL;
}
struct nlist * hashtable_insert( char * keys, char * value)
{
struct nlist *np;
unsigned hashval;
if ((np = hashtable_search(keys)) == NULL) {
np = (struct nlist *)malloc(sizeof(*np));
if (np == NULL || (np->keys = strdup(keys)) == NULL)
return NULL;
hashval = hash(keys);
np->next = hashtable[hashval];
hashtable[hashval] = np;
} else
free((void *)np->value);
if ((np->value = strdup(value)) == NULL)
return NULL;
return np;
}
char * hashtable_getvalue( char * keys)
{
struct nlist *np;
if ((np = hashtable_search(keys)) == NULL)
return NULL;
else
return np->value;
}
int main( int argc, char * argv[])
{
char *ret;
hashtable_insert("INT_MAX", "32767");
hashtable_insert("INT_MIN", "-32768");
hashtable_insert("LONG_MAX", "2147483647");
hashtable_insert("LONG_MIN", "-2147483647");
if ((ret = hashtable_getvalue(argv[1])) == NULL)
printf("%s not found ", argv[1]);
else
printf("%s = %s ", argv[1], ret);
}
#include < string .h >
#define HASHSIZE 101
struct nlist {
struct nlist *next;
char *keys;
char *value;
} ;
static struct nlist * hashtable[HASHSIZE];
unsigned hash( char * s)
{
unsigned hashval;
for (hashval = 0; *s != ''; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
struct nlist * hashtable_search( char * s)
{
struct nlist *np;
for (np = hashtable[hash(s)]; np != NULL; np = np->next)
if (strcmp(s, np->keys) == 0)
return np;
return NULL;
}
struct nlist * hashtable_insert( char * keys, char * value)
{
struct nlist *np;
unsigned hashval;
if ((np = hashtable_search(keys)) == NULL) {
np = (struct nlist *)malloc(sizeof(*np));
if (np == NULL || (np->keys = strdup(keys)) == NULL)
return NULL;
hashval = hash(keys);
np->next = hashtable[hashval];
hashtable[hashval] = np;
} else
free((void *)np->value);
if ((np->value = strdup(value)) == NULL)
return NULL;
return np;
}
char * hashtable_getvalue( char * keys)
{
struct nlist *np;
if ((np = hashtable_search(keys)) == NULL)
return NULL;
else
return np->value;
}
int main( int argc, char * argv[])
{
char *ret;
hashtable_insert("INT_MAX", "32767");
hashtable_insert("INT_MIN", "-32768");
hashtable_insert("LONG_MAX", "2147483647");
hashtable_insert("LONG_MIN", "-2147483647");
if ((ret = hashtable_getvalue(argv[1])) == NULL)
printf("%s not found ", argv[1]);
else
printf("%s = %s ", argv[1], ret);
}
散列函数hash,它通过一个for循环进行计算,每次循环中,它将上一次循环中计算得到的结果经过变换(即乘以31)后得到的新值同字符中的当前字符的值相加(*s + 31 * hashval),然后将该结果值同数据长度执行取模操作,其结果即是该函数的返回值。这个散列函数并不是最好的,但比较简短有效。另外,上面代码中采用链地址法来处理冲突,对桶大小未作限制。
这个散列函数到底是否真的简短有效呢?我们使用C语言中的保留关键字对其进行分析和测试。C语言的保留关键字有32个(如下面代码中定义),散列表长度为101。因此装填因子
α = 32 /101 = 0.32
这个装填因子比较小,从理论上说冲突的可能性较小,但牺牲了较多的空间,以空间换取了效率。
我们使用如下的程序对C语言保留关键字进行hash计算:
#define
HASHSIZE 101
unsigned hash( char * s)
{
unsigned hashval;
for (hashval = 0; *s != ''; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
char * keywords[] = {
"auto", "break", "case", "char", "const", "continue", "default", "do",
"double", "else", "enum", "extern", "float", "for", "goto", "if",
"int", "long", "register", "return", "short", "signed", "sizeof", "static",
"struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while"
} ;
int main( void ) {
int i, size, pos;
int count[HASHSIZE];
for(i = 0; i < HASHSIZE; i++)
count[i] = 0;
size = sizeof(keywords) / sizeof(keywords[0]);
for(i = 0;i < size; i++)
count[hash(keywords[i])]++;
for(i = 0; i < size; i++) {
pos = hash(keywords[i]);
printf("%-10s: %-3d %d ", keywords[i], pos, count[pos]);
}
return 0;
}
unsigned hash( char * s)
{
unsigned hashval;
for (hashval = 0; *s != ''; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
char * keywords[] = {
"auto", "break", "case", "char", "const", "continue", "default", "do",
"double", "else", "enum", "extern", "float", "for", "goto", "if",
"int", "long", "register", "return", "short", "signed", "sizeof", "static",
"struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while"
} ;
int main( void ) {
int i, size, pos;
int count[HASHSIZE];
for(i = 0; i < HASHSIZE; i++)
count[i] = 0;
size = sizeof(keywords) / sizeof(keywords[0]);
for(i = 0;i < size; i++)
count[hash(keywords[i])]++;
for(i = 0; i < size; i++) {
pos = hash(keywords[i]);
printf("%-10s: %-3d %d ", keywords[i], pos, count[pos]);
}
return 0;
}
我们可以得到如下的输出结果:
auto :
10
1
break : 0 1
case : 32 1
char : 53 1
const : 14 1
continue : 87 1
default : 17 1
do : 80 1
double : 76 1
else : 91 1
enum : 63 1
extern : 16 1
float : 57 1
for : 72 1
goto : 78 1
if : 24 1
int : 98 1
long : 66 1
register : 49 1
return : 96 1
short : 99 1
signed : 81 1
sizeof : 51 1
static : 85 1
struct : 1 1
switch : 5 1
typedef : 2 1
union : 22 1
unsigned : 4 1
void : 70 1
volatile : 71 1
while : 100 1
break : 0 1
case : 32 1
char : 53 1
const : 14 1
continue : 87 1
default : 17 1
do : 80 1
double : 76 1
else : 91 1
enum : 63 1
extern : 16 1
float : 57 1
for : 72 1
goto : 78 1
if : 24 1
int : 98 1
long : 66 1
register : 49 1
return : 96 1
short : 99 1
signed : 81 1
sizeof : 51 1
static : 85 1
struct : 1 1
switch : 5 1
typedef : 2 1
union : 22 1
unsigned : 4 1
void : 70 1
volatile : 71 1
while : 100 1
从这个结果可以看出,散列表中的数据分布比较均匀,而且更为理想的是,居然没有发生一个冲突。可见,书中所说的“简短有效”确实名副其实,甚至是非常理想的散列函数。这使得我不禁又要推荐“C程序设计语言”一书啦!
6、参考文献
(1)严蔚敏,吴伟民. 数据结构(C语言版).清华大学出版社,1997年。
(2)Brian W. Kernighan, Dennis M. Ritchie. 徐宝文等译. C程序设计语言(第2版),机械工业出版社,2008年。