第二十二篇：HashTable相关操作实现（附完整源码）

前言

    学过Java的人肯定对Hash这个词非常之熟悉,HashTable、HashSet、HashMap等都是对哈希表的封装或改进。这次我们来看下哈希表用C语言表示的封装实现。

哈希表

    哈希表又叫散列表，是实现字典操作的一种有效数据结构。哈希表的查询效率极高，在没有冲突（后面会介绍）的情况下不需经过任何比较，一次存取便能得到所查记录，因此理想情况下，查找一个元素的平均时间为O（1）。

    哈希表就是描述key—value对的映射问题的数据结构，这在Java中大家都知道，更详细的描述是：在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使每个关键字与哈希表中唯一一个存储位置相对应。我们称这个对应关系f为哈希函数，这个存储结构即为哈希表。

    直接寻址表

    当关键字的全域U比较小时，直接寻址是一种简单而有效的技术，它的哈希函数很简单：f(key) = key，即关键字大小直接与元素所在的位置序号相等。另外，如果关键字不是自然数，我们需要通过某种手段将其转换为自然数，比如可以将字符关键字转化为其在字母表中的序号作为关键字。直接寻址法不会出现两个关键字对应到同一个地址的情况，既不会出现f（key1） = f(key2)的情况，因此不用处理冲突，这便是其优点所在。

    散列表

    直接寻址的缺点非常明显，如果全域U很大，则在一台标准的计算机可用内存容量中，要存储大小为U的一张表也许不太实际，而且，实际需要存储的关键字集合K可能相对U来说很小，这时散列表需要的存储空间要比直接表少很多。散列表通过散列函数f计算出关键字key在槽的位置。散列函数f将关键字域U映射到散列表T[0...m-1]的槽位上。但是这里会存在一个问题：若干个关键字可能映射到了表的同一个位置处（算法导论上名其曰“槽”），我们称这种情形为冲突。当然理想的方法是尽量避免冲突，我们可以尽可能第将关键字通过f随即地映射到散列表的每个位置上。

哈希函数

    哈希函数的构造方法很多，最好的情况是：对于关键字结合中的任一个关键字，经哈希函数映射到地址集合中任何一个地址的概率相等，也就是说，关键字经过哈希函数得到一个随机的地址，以便使一组关键字的哈希地址均匀分布在整个地址空间中，从而减少冲突。同样，由于多数哈希函数都是假定关键字的全域为自然数集N={0、1、2....}，因此所给关键字如果不是自然数，就要先想办法将其转换为自然数。下面我们就来看常用的哈希函数。

    直接定址法

    对应前面的直接寻址表，关键字与哈希表中的地址有着一一对应关系，因此不需要处理冲突。

    除法散列法

    哈希函数如下：

f（key）= key%m 

    即对所给关键字key取余，这里m必须不能大于哈希表的长度len，通常m取一个不太接近2的整数次幂的素数是一个较好的选择。

    乘法散列法

    用关键字key先乘上A（0<A<1），取出其小数部分，然后用m乘以这个值，再向下取整,该哈希函数为：

f（key）= floor(m*(key*A%1))

    通常，A=(sqrt(5)-1)/2 = 0.6180339877...（黄金分割点）是个比较理想的值。

    其他还有一些，诸如数字分析法、折叠法、全域散列法等，这里不再一一介绍，有兴趣了解的可以参考相关书籍（其实我们一般用的比较多的可能也就是除法散列法和乘法散列法）。

冲突处理

    但我们前面提到，为了节省空间，表中槽的数目应该是小于关键字的数目的，因此完全避免冲突是不可能的。下面介绍两种解决冲突的方法：链接法和开放定址法。

    链接法

    链接法的思路很简单：如果多个关键字映射到了哈希表的同一个位置处，则将这些关键字记录在同一个线性链表中，挂在该位置处，如下图所示：

    图中，关键字k1和k4映射到了哈希表的同一个位置处，k5、k2和k7映射到了哈希表的同一个位置处。另外，为了更快地删除某个元素，可以将链表设计为双向链表。后面的代码中我们采用的是单向链表。

    开放定址法

    在开放定址法中，所有的元素都存放在散列表中，也即是说，每个表项或包含动态集合的一个元素，或为空。该方法采用如下公式记性再散列：

F(key,i) = (f(key) + i)%len

    其中，f(key)为哈希函数，len为哈希表长，i为增量序列，它可能有如下三种情况：

    1）i = 1,2,3...m-1

    2）i = 1，-1，4，-4，9，-9...k^2，-k^2

    3）i为伪随机序列

    采用第一种序列的叫做线性探测再散列，采用第二种序列的叫做二次探测再散列，采用第三种序列的叫做随机探测再散列。说白了，就是在发生冲突时，将关键字应该放入的位置向前或向后移动若干位置，比如采取第一种序列时，如果遇到冲突，就向后移动一个位置来检测，如果还发生冲突，继续向后移动，直到遇到一个空槽，则将该关键字插入到该位置处。

    线性探测比较容易实现，但是它存在一个问题，称为一次群集。随着连续被占用的槽不断增加，平均查找时间也随之不断增加，群集现象很容易出现，这是因为当一个空槽前有i个满槽时，该空槽为下一个将被占用的概率为(i+1)len。

    同样采用二次探测的方法，会产生二次群集，因为每次遇到冲突时，寻找插入位置时都是在跳跃性前进或后退，因此这个相对于一次群集来说，比较轻度。

代码实现

    下面我们要来看下代码的实现了，我们这里采用链接法来处理冲突，因此描述数据结构的h文件的代码如下：

[cpp] view plain copy

1. #define M 7     //哈希函数中的除数,必须小于等于表长  
2. typedef int ElemType;  
3.   
4. /* 
5. 该哈希表采用链接法解决冲突问题 
6. */  
7. typedef struct Node   
8. {   //Node为链表节点的数据结构  
9.     ElemType data;  
10.     struct Node *next;  
11. }Node,*pNode;  
12.   
13. typedef struct HashNode  
14. {   //HashNode为哈希表的每个槽的数据结构  
15.     pNode first;    //first指向链表的第一个节点  
16. }HashNode,*HashTable;  
17.   
18. //创建哈希表  
19. HashTable create_HashTable(int);  
20.   
21. //在哈希表中查找数据  
22. pNode search_HashTable(HashTable, ElemType);  
23.   
24. //插入数据到哈希表  
25. bool insert_HashTable(HashTable,ElemType);  
26.   
27. //从哈希表中删除数据  
28. bool delete_HashTable(HashTable,ElemType);  
29.   
30. //销毁哈希表  
31. void destroy_HashTable(HashTable,int);  

    我们需要先建立一个空哈希表，而后可能要执行插入、删除、查询等相关操作，最后要销毁哈希表，因此相关函数的实现代码如下：

[cpp] view plain copy

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include "data_structure.h"  
4.   
5. /* 
6. 创建一个槽数为n的哈希表 
7. */  
8. HashTable create_HashTable(int n)  
9. {  
10.     int i;  
11.     HashTable hashtable = (HashTable)malloc(n*sizeof(HashNode));  
12.     if(!hashtable)  
13.     {  
14.         printf("hashtable malloc faild,program exit...");  
15.         exit(-1);  
16.     }  
17.   
18.     //将哈希表置空  
19.     for(i=0;i<n;i++)  
20.         hashtable[i].first = NULL;  
21. //  memset(hashtable,0,sizeof(hashtable));  
22.   
23.     return hashtable;  
24. }  
25.   
26. /* 
27. 在哈希表中查找数据data，查找成功则返回在链表中的位置， 
28. 查找不成功则返回NULL，其中哈希函数为H(key)=key%M 
29. */  
30. pNode search_HashTable(HashTable hashtable, ElemType data)  
31. {  
32.     if(!hashtable)  
33.         return NULL;  
34.   
35.     //该写法包含了成功与不成功两种情况  
36.     pNode pCur = hashtable[data%M].first;  
37.     while(pCur && pCur->data != data)  
38.         pCur = pCur->next;  
39.   
40.     return pCur;  
41. }  
42.   
43. /* 
44. 向哈希表中插入数据data，如果data已存在，则返回fasle， 
45. 否则，插入对应链表的最后并返回true，其中哈希函数为H(key)=key%M 
46. */  
47. bool insert_HashTable(HashTable hashtable,ElemType data)  
48. {  
49.     //如果已经存在，返回false  
50.     if(search_HashTable(hashtable,data))  
51.         return false;  
52.   
53.     //否则为data分配空间  
54.     pNode pNew = (pNode)malloc(sizeof(Node));  
55.     if(!pNew)  
56.     {  
57.         printf("pNew malloc faild,program exit...");  
58.         exit(-1);  
59.     }  
60.     pNew->data = data;  
61.     pNew->next = NULL;  
62.   
63.     //将节点插入到对应链表的最后  
64.     pNode pCur = hashtable[data%M].first;  
65.     if(!pCur)   //插入位置为链表第一个节点的情况  
66.         hashtable[data%M].first = pNew;  
67.     else    //插入位置不是链表第一个节点的情况  
68.     {   //只有用pCur->next才可以将pNew节点连到链表上，  
69.         //用pCur连不到链表上，而是连到了pCur上  
70.         //pCur虽然最终指向链表中的某个节点，但是它并不在链表中  
71.         while(pCur->next)  
72.             pCur = pCur->next;  
73.         pCur->next = pNew;  
74.     }  
75.   
76.     return true;  
77. }  
78.   
79. /* 
80. 从哈希表中删除数据data，如果data不存在，则返回fasle， 
81. 否则，删除之并返回true，其中哈希函数为H(key)=key%M 
82. */  
83. bool delete_HashTable(HashTable hashtable,ElemType data)  
84. {  
85.     //如果没查找到，返回false  
86.     if(!search_HashTable(hashtable,data))  
87.         return false;  
88.     //否则，一定存在，找到删除之  
89.     pNode pCur = hashtable[data%M].first;  
90.     pNode pPre = pCur;  //被删节点的前一个节点,初始值与pCur相同  
91.     if(pCur->data == data)   //被删节点是链表的第一个节点的情况  
92.         hashtable[data%M].first = pCur->next;  
93.     else  
94.     {   //被删节点不是第一个节点的情况  
95.         while(pCur && pCur->data != data)  
96.         {  
97.             pPre = pCur;  
98.             pCur = pCur->next;  
99.         }  
100.         pPre->next = pCur->next;  
101.     }  
102.     free(pCur);  
103.     pCur = 0;  
104.     return true;  
105. }  
106.   
107. /* 
108. 销毁槽数为n的哈希表 
109. */  
110. void destroy_HashTable(HashTable hashtable,int n)  
111. {  
112.     int i;  
113.     //先逐个链表释放  
114.     for(i=0;i<n;i++)  
115.     {  
116.         pNode pCur = hashtable[i].first;  
117.         pNode pDel = NULL;  
118.         while(pCur)  
119.         {  
120.             pDel = pCur;  
121.             pCur = pCur->next;  
122.             free(pDel);  
123.             pDel = 0;  
124.         }  
125.     }  
126.     //最后释放哈希表  
127.     free(hashtable);  
128.     hashtable = 0;  
129. }  

    我们采用如下代码来测试：

[cpp] view plain copy

1. /******************************* 
2.             哈希表 
3. Author:兰亭风雨 Date:2014-03-07 
4. Email:[e-mail] 
5. *******************************/  
6. #include<stdio.h>  
7. #include "data_structure.h"  
8.   
9. int main()  
10. {  
11.     int len = 15;   //哈希表长，亦即表中槽的数目  
12.     printf("We set the length of hashtable %d\n",len);  
13.   
14.     //创建哈希表并插入数据  
15.     HashTable hashtable = create_HashTable(len);  
16.     if(insert_HashTable(hashtable,1))  
17.         printf("insert 1 success\n");  
18.     else   
19.         printf("insert 1 fail,it is already existed in the hashtable\n");  
20.     if(insert_HashTable(hashtable,8))  
21.         printf("insert 8 success\n");  
22.     else   
23.         printf("insert 8 fail,it is already existed in the hashtable\n");  
24.     if(insert_HashTable(hashtable,3))  
25.         printf("insert 3 success\n");  
26.     else   
27.         printf("insert 3 fail,it is already existed in the hashtable\n");  
28.     if(insert_HashTable(hashtable,10))  
29.         printf("insert 10 success\n");  
30.     else   
31.         printf("insert 10 fail,it is already existed in the hashtable\n");  
32.     if(insert_HashTable(hashtable,8))  
33.         printf("insert 8 success\n");  
34.     else   
35.         printf("insert 8 fail,it is already existed in the hashtable\n");  
36.   
37.     //查找数据  
38.     pNode pFind1 = search_HashTable(hashtable,10);  
39.     if(pFind1)  
40.         printf("find %d in the hashtable\n",pFind1->data);         
41.     else   
42.         printf("not find 10 in the hashtable\n");  
43.     pNode pFind2 = search_HashTable(hashtable,4);  
44.     if(pFind2)  
45.         printf("find %d in the hashtable\n",pFind2->data);         
46.     else   
47.         printf("not find 4 in the hashtable\n");  
48.   
49.     //删除数据  
50.     if(delete_HashTable(hashtable,1))  
51.         printf("delete 1 success\n");  
52.     else   
53.         printf("delete 1 fail");  
54.     pNode pFind3 = search_HashTable(hashtable,1);  
55.     if(pFind3)  
56.         printf("find %d in the hashtable\n",pFind3->data);         
57.     else   
58.         printf("not find 1 in the hashtable,it has been deleted\n");  
59.   
60.     //销毁哈希表  
61.     destroy_HashTable(hashtable,len);  
62.     return 0;  
63. }  

    输出结果如下：

完整源码下载

    完整源码下载地址：http://download.csdn.net/detail/mmc_maodun/7008669