C 基础数据结构---散列表（Hash） ADT

我这几天好好的反思了一下我这么久以来的学习方法，我认为学习应该将自己学到的知识用自己的话讲出来比较好。以前只是听说有这样的一种数据结构叫做hash，但一直也没有去了解具体是如何实现的，但是在之前做过MD5的东西。所以对hash了解一个皮毛应该不是很难。我接受任何批评。

什么是哈希表？用一个不是很恰当的解释来阐述一下：链表数组。相信对链表很熟悉了吧?那么由链表构成的数组也不陌生。
    哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置（链表数组下标）来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
    哈希表的做法其实很简单，就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余（这个过程叫做散列法。在下面的内容中将介绍几种好的散列算法），取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。
而当使用哈希表进行查询的时候，就是再次使用哈希函数将key转换为对应的数组下标，并定位到该空间获取value，如此一来，就可以充分利用到数组的定位性能进行数据定位。

    什么是Hash
Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射，pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。关于hash可以查询相关的hash算法，比如：MD2, MD4, MD5,消息摘要，安全哈希算法 (SHA-1)等。

一、拉链法

    转到散列表，为什么前面我介绍说散列表可以理解为链表数组呢？数组的特点是：寻址容易，插入和删除困难；而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为“链表的数组”，如图：
 



左边很明显是个数组，数组的每个成员包括一个指针，指向一个链表的头，当然这个链表可能为空，也可能元素很多。我们根据元素的一些特征把元素分配到不同的链表中去，也是根据这些特征，找到正确的链表，再从链表中找出这个元素。

元素特征转变为数组下标的方法就是散列法。

散列法当然不止一种，你可以任意的设计，只要你觉得该算法在你的应用中足够优越就ok，下面列出三种比较常用的：
a，除法散列法
最直观的一种，上图使用的就是这种散列法，公式：
index = value % 16
学过汇编的都知道，求模数其实是通过一个除法运算得到的，所以叫“除法散列法”。
b，平方散列法
求index是非常频繁的操作，而乘法的运算要比除法来得省时（对现在的CPU来说，估计我们感觉不出来），所以我们考虑把除法换成乘法和一个位移操作。公式：
index = (value * value) >> 28 （右移，除以2^28。记法：左移变大，是乘。右移变小，是除。）
如果数值分配比较均匀的话这种方法能得到不错的结果，但我上面画的那个图的各个元素的值算出来的index都是0——非常失败。也许你还有个问题，value如果很大，value *value不会溢出吗？答案是会的，但我们这个乘法不关心溢出，因为我们根本不是为了获取相乘结果，而是为了获取index。
c，斐波那契（Fibonacci）散列法
平方散列法的缺点是显而易见的，所以我们能不能找出一个理想的乘数，而不是拿value本身当作乘数呢？答案是肯定的。
a，对于16位整数而言，这个乘数是40503
b，对于32位整数而言，这个乘数是2654435769
c，对于64位整数而言，这个乘数是11400714819323198485
这几个“理想乘数”是如何得出来的呢？这跟一个法则有关，叫黄金分割法则，而描述黄金分割法则的最经典表达式无疑就是著名的斐波那契数列，即如此形式的序列：0,1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,233, 377, 610， 987, 1597,2584, 4181, 6765, 10946，…。另外，斐波那契数列的值和太阳系八大行星的轨道半径的比例出奇吻合。
对我们常见的32位整数而言，公式：
index = (value * 2654435769) >> 28
如果用这种斐波那契散列法的话，那上面的图就变成这样了：


很明显，用斐波那契散列法调整之后要比原来的取摸散列法好很多。

适用范围
快速查找，删除的基本数据结构，通常需要总数据量可以放入内存。

基本原理及要点
hash函数选择，针对字符串，整数，排列，具体相应的hash方法。
碰撞处理，一种是openhashing，也称为拉链法；另一种就是closedhashing，也称开地址法，openedaddressing。
扩展
d-left hashing中的d是多个的意思，我们先简化这个问题，看一看2-lefthashing。2-lefthashing指的是将一个哈希表分成长度相等的两半，分别叫做T1和T2，给T1和T2分别配备一个哈希函数，h1和h2。在存储一个新的key时，同时用两个哈希函数进行计算，得出两个地址h1[key]和h2[key]。这时需要检查T1中的h1[key]位置和T2中的h2[key]位置，哪一个位置已经存储的（有碰撞的）key比较多，然后将新key存储在负载少的位置。如果两边一样多，比如两个位置都为空或者都存储了一个key，就把新key存储在左边的T1子表中，2-left也由此而来。在查找一个key时，必须进行两次hash，同时查找两个位置。

 

二、开地址法

一般的线性表，树中，记录在结构中的相对位置是随机的，即和记录的关键字之间不存在确定的关系，因此，在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较“的基础上，查找的效率依赖于查找过程中所进行的比较次数。

理想的情况是能直接找到需要的记录，因此必须在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使每个关键字和结构中一个唯一的存储位置相对应。

哈希表最常见的例子是以学生学号为关键字的成绩表，１号学生的记录位置在第一条，１０号学生的记录位置在第１０条...

如果我们以学生姓名为关键字，如何建立查找表，使得根据姓名可以直接找到相应记录呢？

a	b	c	d	e	f	g	h	I	j	k	l	m	n	o	p	q	r	s	t	u	v	w	x	y	z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

 

	刘丽	刘宏英	吴军	吴小艳	李秋梅	陈伟	...
姓名中各字拼音首字母	ll	lhy	wj	wxy	lqm	cw	...
用所有首字母编号值相加求和	24	46	33	72	42	26	...
最小值可能为3 最大值可能为78 可放75个学生

用上述得到的数值作为对应记录在表中的位置，得到下表：

		成绩一	成绩二...
3	...
...	...
24	刘丽	82	95
25	...
26	陈伟
...	...
33	吴军
...	...
42	李秋梅
...	...
46	刘宏英
...	...
72	吴小艳
...	...
78	...

上面这张表即哈希表。

如果将来要查李秋梅的成绩，可以用上述方法求出该记录所在位置：

李秋梅:lqm 12+17+13=42取表中第42条记录即可。

问题：如果两个同学分别叫刘丽刘兰该如何处理这两条记录？

这个问题是哈希表不可避免的，即冲突现象：对不同的关键字可能得到同一哈希地址。

1、哈希表的构造方法

1、直接定址法

例如：有一个从1到100岁的人口数字统计表，其中，年龄作为关键字，哈希函数取关键字自身。

地址	01	02	...	25	26	27	...	100
年龄	1	2	...	25	26	27	...	...
人数	3000	2000	...	1050	...	...	...	...
...

２、数字分析法

有学生的生日数据如下：

年.月.日

75.10.03
75.11.23
76.03.02
76.07.12
75.04.21
76.02.15
...

经分析,第一位，第二位，第三位重复的可能性大，取这三位造成冲突的机会增加，所以尽量不取前三位，取后三位比较好。

３、平方取中法

取关键字平方后的中间几位为哈希地址。

４、折叠法

将关键字分割成位数相同的几部分（最后一部分的位数可以不同），然后取这几部分的叠加和（舍去进位）作为哈希地址，这方法称为折叠法。

例如：每一种西文图书都有一个国际标准图书编号，它是一个10位的十进制数字，若要以它作关键字建立一个哈希表，当馆藏书种类不到10,000时，可采用此法构造一个四位数的哈希函数。如果一本书的编号为0-442-20586-4,则：

	5864		5864
	4220		0224
+)	04	+)	04
	-----------		-----------
	10088		6092
	H(key)=0088		H(key)=6092
	(a)移位叠加		(b)间界叠加

５、除留余数法

取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址。

H(key)=key MOD p (p<=m)

６、随机数法

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即

H(key)=random(key) ,其中random为随机函数。通常用于关键字长度不等时采用此法。

2、处理冲突的方法

		成绩一	成绩二...
3	...
...	...
24	刘丽	82	95
25	...
26	陈伟
...	...
33	吴军
...	...
42	李秋梅
...	...
46	刘宏英
...	...
72	吴小艳
...	...
78	...

如果两个同学分别叫刘丽刘兰，当加入刘兰时，地址24发生了冲突，我们可以以某种规律使用其它的存储位置，如果选择的一个其它位置仍有冲突，则再选下一个，直到找到没有冲突的位置。选择其它位置的方法有：

１、开放定址法

Hi=(H(key)+di) MOD m i=1,2,...,k(k<=m-1)

其中m为表长，di为增量序列

如果di值可能为1,2,3,...m-1，称线性探测再散列。

如果di取值可能为1,-1,2,-2,4,-4,9,-9,16,-16,...k*k,-k*k(k<=m/2)

称二次探测再散列。

如果di取值可能为伪随机数列。称伪随机探测再散列。

例：在长度为11的哈希表中已填有关键字分别为17,60,29的记录，现有第四个记录，其关键字为38，由哈希函数得到地址为5，若用线性探测再散列，如下：

0	1	2	3	4	5	6	7	8	9	10
					60	17	29

(a)插入前

0	1	2	3	4	5	6	7	8	9	10
					60	17	29	38

(b)线性探测再散列

0	1	2	3	4	5	6	7	8	9	10
					60	17	29

(c)二次探测再散列

0	1	2	3	4	5	6	7	8	9	10
			38		60	17	29

(d)伪随机探测再散列

伪随机数列为9,5,3,8,1...

２、再哈希法

当发生冲突时，使用第二个、第三个、哈希函数计算地址，直到无冲突时。缺点：计算时间增加。

３、链地址法

将所有关键字为同义词的记录存储在同一线性链表中(和拉链法的处理形式相近)。

４、建立一个公共溢出区

假设哈希函数的值域为[0,m-1],则设向量HashTable[0..m-1]为基本表，另外设立存储空间向量OverTable[0..v]用以存储发生冲突的记录。

 

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>


/*
*	实现了一下hash表，有初始化，添加，修改，查询，销毁的接口
*    Implementation of the hash table, initialization, add, modify, query, the destruction of the interface
*/
typedef struct NODE {
	int key;
	int data;
	struct NODE *next;
}*Node;

typedef struct HASH {
	int bucket;
	struct NODE *list;
}*Hash;

int getHashCode(int bucket,int key)
{
	return key%bucket;
}

Hash init(int bucket)
{
	assert(bucket>0);
	printf("Enter init \n");
	Hash hash;
	int i = 0;
	hash = (Hash)malloc(sizeof(struct HASH));
	if(hash == NULL)
	{
		printf("init mem  error ! \n");
		exit(-1);
	}
	hash->bucket = bucket;
	hash->list = (Node)malloc(sizeof(struct NODE)*hash->bucket);

	if(hash->list == NULL)
	{
		printf("init mem  error ! \n");
		exit(-1);
	}
	
	for(i=0;i<bucket;i++)
	{
		hash->list[i].data = 0;
		hash->list[i].key= 0;
		hash->list[i].next= NULL;
	}
	return hash;
}

Node getNode(Hash h,int key)
{
	assert(h!=NULL);
	int key_hash;
	Node list,p;
	key_hash = getHashCode(h->bucket,key);
	list = h->list[key_hash].next;
	if(list==NULL)
	{
		return NULL;
	}
	while(list!=NULL){
		if(list->key == key){
			return list;
		}
		list = list->next;
	}
	return NULL;
}

void insert(Hash h,int key,int data)
{
	assert(h!=NULL);
	//printf("Enter insert \n");
	int key_hash;
	Node list,p;
	list = getNode(h,key);
	if(list==NULL){
		key_hash = getHashCode(h->bucket,key);
		list = h->list[key_hash].next;
		p = (Node)malloc(sizeof(struct NODE));
		if(p==NULL){
			printf("malloc mem error !\n");
			return ;
		}
		p->data = data;
		p->key = key;
		p->next = NULL;

		p->next = h->list[key_hash].next;
		h->list[key_hash].next = p;
		
	}else{
		list->data = data;
	}

	return ;
}

int getData(Hash h,int key,int *data)
{
	assert(h!=NULL && data!=NULL);
	Node node = NULL;
	node = getNode(h,key);
	if(node == NULL){
		return -1;
	}else{
		*data = node->data;
		return 0;
	}
	
}

void printHash(Hash h)
{
	assert(h != NULL);
	printf("Enter printHash \n");
	int bucket;
	int i = 0;
	Node list;
	assert(h!=NULL);
	bucket = h->bucket;
	for(i=0;i<bucket;i++)
	{
		printf("key  bucket = %d ",i);
		list = h->list[i].next;
		while(list!=NULL){
			printf("key %d,data %d,",list->key,list->data);
			list = list->next;
		}
		printf("\n");
	}
	
}

int destory(Hash h)
{
	printf("Enter destory !\n");
	assert(h!=NULL);
	Node list = NULL,p=NULL;
	int bucket ;
	int i ;
	bucket = h->bucket;
	for(i=0;i<bucket;i++)
	{
		list = h->list[i].next;
		while(list!=NULL)
		{
			p = list->next;
			free(list);
			list = p;
		}
		h->list[i].next = NULL;
	}
	free(h->list);
	h->list = NULL;
	free(h);
	h = NULL;
}

int main(int argc ,char *argv[])
{
	printf("Enter hash main !\n");
	Hash hash = NULL;
	int i =0;
	int data;
	int ret = 0;
	hash = init(20);
	for(i=0;i<50;i++){
		insert(hash,i,(i+2)*5);
	}
	printHash(hash);

	ret = getData(hash,35,&data);

	if(ret == -1){
		printf("Not hava thia node !\n");
	}else{
		printf("read data is %d !\n",data);
	}

	destory(hash);

	return 0;
}