散列表设计
(刘爱贵 - 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
>
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
#define
HASHSIZE 101
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
struct
nlist
{
struct nlist *next;
char *keys;
char *value;
}
;
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
static
struct
nlist
*
hashtable[HASHSIZE];
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
unsigned hash(
char
*
s)
{
unsigned hashval;
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
for (hashval = 0; *s != ''; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
struct
nlist
*
hashtable_search(
char
*
s)
{
struct nlist *np;
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
for (np = hashtable[hash(s)]; np != NULL; np = np->next)
if (strcmp(s, np->keys) == 0)
return np;
return NULL;
}
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
struct
nlist
*
hashtable_insert(
char
*
keys,
char
*
value)
{
struct nlist *np;
unsigned hashval;
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
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;
}
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
char
*
hashtable_getvalue(
char
*
keys)
{
struct nlist *np;
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
if ((np = hashtable_search(keys)) == NULL)
return NULL;
else
return np->value;
}
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
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");
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
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;
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
for (hashval = 0; *s != ''; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
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"
}
;
![](https://i-blog.csdnimg.cn/blog_migrate/6810355c2f78c12e91b7997a8e8c583a.gif)
int
main(
void
)
{
int i, size, pos;
int count[HASHSIZE];
for(i = 0; i < HASHSIZE; i++)
count[i] = 0;
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
size = sizeof(keywords) / sizeof(keywords[0]);
for(i = 0;i < size; i++)
count[hash(keywords[i])]++;
![](https://i-blog.csdnimg.cn/blog_migrate/6a9c071a08f1dae2d3e1c512000eef41.gif)
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
从这个结果可以看出,散列表中的数据分布比较均匀,而且更为理想的是,居然没有发生一个冲突。可见,书中所说的“简短有效”确实名副其实,甚至是非常理想的散列函数。这使得我不禁又要推荐“C程序设计语言”一书啦!