第十五周项目2-用哈希法组织关键字

/*   

* 烟台大学计算机与控制工程学院   

* 作者：王雪松  

* 完成日期：2016年12月15日   

*   

* 问题描述：

已知一个关键字序列为if、while、for、case、do、break、else、struct、union、int、double、float、char、long、bool，共15个字符串，哈希函数H(key)为关键字的第一个字母在字母表中的序号，哈希表的表长为26。

* 输入描述：

* 程序输出：

 */ 

代码：

（1）若处理冲突的方法采用线性探测法，请设计算法，输出每个关键字对应的H(key)，输出哈希表，并求成功情况下的平均查找长度。

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <string.h>  
3. #define N 15  
4. #define M 26  
5. int H(char *s)  
6. {  
7.     return ((*s-'a'+1)%M);  
8. }  
9.   
10. int main()  
11. {  
12.     char *s[N]= {"if", "while", "for", "case", "do", "break", "else", "struct", "union", "int", "double", "float", "char", "long", "bool"};  
13.     int i, j, k;  
14.     char HT[M][10];  
15.     int Det[M];   //存放探测次数  
16.     for(i=0; i<M; i++)  
17.     {  
18.         HT[i][0]='\0';  
19.         Det[i]=0;  
20.     }  
21.     printf("字符串 key\tH(key)\n");  
22.     printf("------------------------\n");  
23.     for(i=0; i<N; i++)  
24.     {  
25.         j=H(s[i]);  //求哈希值  
26.         printf("%s\t\t%d\n", s[i],j);  
27.         k=0;   //探测次数初值  
28.         while(1)  
29.         {  
30.             k++;    //累加探测次数  
31.             if(HT[j][0]=='\0')   //当不冲突时，直接放到该处  
32.             {  
33.                 strcpy(HT[j], s[i]);  
34.                 break;  
35.             }  
36.             else    //冲突时，采用线性探查法求下一个地址  
37.             {  
38.                 j=(j+1)%M;  
39.             }  
40.         }  
41.         Det[j]=k;  
42.     }  
43.     printf("---------------------\n");  
44.     printf("哈希表\n");  
45.     printf("位置\t字符串\t探查次数\n");  
46.     printf("---------------------\n");  
47.     for(i=0; i<M; i++)  
48.         printf("%d\t%s\t%d\n", i, HT[i], Det[i]);  
49.     printf("---------------------\n");  
50.     k=0;  
51.     for(i=0; i<M; i++)  
52.         k+=Det[i];  
53.     printf("查找成功情况下的平均查找长度 %f\n", 1.0*k/N);  
54.     return 0;  
55. }  

运行结果：

（2）若处理冲突的方法采用链地址法，请设计算法，输出哈希表，并计算成功情况和不成功情况下的平均查找长度。

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <malloc.h>  
4. #define N 15  
5. #define M 26  
6. typedef struct node   //定义哈希链表的节点类型  
7. {  
8.     char *key;  
9.     struct node *next;  
10. } LNode;  
11.   
12. typedef struct  
13. {  
14.     LNode *link;  
15. } HTType;  
16.   
17. int H(char *s)   //实现哈希函数  
18. {  
19.     return ((*s-'a'+1)%M);  
20. }  
21.   
22. //构造哈希表  
23. void Hash(char *s[], HTType HT[])  
24. {  
25.     int i, j;  
26.     LNode *q;  
27.     for(i=0; i<M; i++)   //哈希表置初值  
28.         HT[i].link=NULL;  
29.     for(i=0; i<N; i++)   //存储每一个关键字  
30.     {  
31.         q=(LNode*)malloc(sizeof(LNode));   //创建新节点  
32.         q->key = (char*)malloc(sizeof(strlen(s[i])+1));  
33.         strcpy(q->key, s[i]);  
34.         q->next=NULL;  
35.         j=H(s[i]);    //求哈希值  
36.         if(HT[j].link==NULL)   //不冲突，直接加入  
37.             HT[j].link=q;  
38.         else        //冲突时，采用前插法插入  
39.         {  
40.             q->next = HT[j].link;  
41.             HT[j].link=q;  
42.         }  
43.     }  
44. }  
45.   
46. //输出哈希表  
47. void DispHT(HTType HT[])  
48. {  
49.     int i;  
50.     LNode *p;  
51.     printf("哈希表\n");  
52.     printf("位置\t关键字序列\n");  
53.     printf("---------------------\n");  
54.     for(i=0; i<M; i++)  
55.     {  
56.         printf(" %d\t", i);  
57.         p=HT[i].link;  
58.         while(p!=NULL)  
59.         {  
60.             printf("%s ", p->key);  
61.             p=p->next;  
62.         }  
63.         printf("\n");  
64.     }  
65.     printf("---------------------\n");  
66. }  
67.   
68. //求查找成功情况下的平均查找长度  
69. double SearchLength1(char *s[], HTType HT[])  
70. {  
71.     int i, k, count = 0;  
72.     LNode *p;  
73.     for(i=0; i<N; i++)  
74.     {  
75.         k=0;  
76.         p=HT[H(s[i])].link;  
77.         while(p!=NULL)  
78.         {  
79.             k++;   //p!=NULL，进入循环就要做一次查找  
80.             if(strcmp(p->key, s[i])==0)   //若找到，则退出  
81.                 break;  
82.             p=p->next;  
83.         }  
84.         count+=k;  
85.     }  
86.     return 1.0*count/N;   //成功情况仅有N种  
87. }  
88.   
89. //求查找不成功情况下的平均查找长度  
90. double SearchLength2(HTType HT[])  
91. {  
92.     int i, k, count = 0;  //count为各种情况下不成功的总次数  
93.     LNode *p;  
94.     for(i=0; i<M; i++)  
95.     {  
96.         k=0;  
97.         p=HT[i].link;  
98.         while(p!=NULL)  
99.         {  
100.             k++;  
101.             p=p->next;  
102.         }  
103.         count+=k;  
104.     }  
105.     return 1.0*count/M;   //不成功时，在表长为M的每个位置上均可能发生  
106. }  
107. int main()  
108. {  
109.     HTType HT[M];  
110.     char *s[N]= {"if", "while", "for", "case", "do", "break", "else", "struct", "union", "int", "double", "float", "char", "long", "bool"};  
111.     Hash(s, HT);  
112.     DispHT(HT);  
113.     printf("查找成功情况下的平均查找长度 %f\n", SearchLength1(s, HT));  
114.     printf("查找不成功情况下的平均查找长度 %f\n", SearchLength2(HT));  
115.     return 0;  
116. }  

运行结果：