散列文件的插入、删除、查找和打印（C语言源代码）

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <conio.h>
6. /*定义散列表长度，其值取决于待三列的元素数量
7. 和选取的装填因α的大小，在此假定为13*/
8. #define N 13    
10. /*定义关键字类型，这里假定为整型*/
11. typedef int KeyType;
13. struct ElemType     //元素类型
14. {
15.     KeyType key;    //关键字域
16.     char rest[10];  //其他域，假定用字符数组表示
17. };
19. struct FLNode   //索引文件中的结点类型
20. {
21.     struct ElemType data;   //值域
22.     int next;       //指向下一个结点的指针域
23. };
25. const int b1 = sizeof(KeyType); //用全局常量b1保存索引表文件中的记录（元素）长度
26. const int b2 = sizeof(struct FLNode);   //用全局常量b2保存索引主文件中的记录（结点）长度
28. //建立并初始化散列表文件
29. void InitHashFile(char *fname)
30. {
31.     int i;
32.     int *A;
33.     //以读写方式新建二进制散列文件
34.     FILE *fp;
35.     fp = fopen(fname, "wb+");
36.     if(NULL == fp)
37.     {
38.         printf("Cannot open this file!/n");
39.         exit(1);
40.     }
42.     //动态分配具有N+1个整型储存空间的数组A
43.     A = (int *)calloc(N + 1, b1);
44.     if(NULL == A)
45.     {
46.         printf("Memory alloction failare!/n");
47.         exit(1);
48.     }
49.     
50.     //给数组A中的每个元素赋初值-1，表示空指针
51.     for(i = 0; i < N + 1; i++)
52.     {
53.         A[i] = -1;
54.     }
56.     //初始化散列文件
57.     fwrite((char *)A, (N + 1)*b1, 1, fp);
59.     //删除数组A
60.     free(A);
62.     //关闭fp对应的文件
63.     fclose(fp);
64. }
66. //检测是否存在散列文件
67. void existHash(char *fname)
68. {
69.     char bcreate;
70.     char filename[128];
71.     FILE *fp;
72.     fp = fopen(fname, "rb");
73.     if(NULL == fp)
74.     {
75.         printf("--- 散列文件不存在, 是否新建散列文件(y:从新建立/n:打开其他散列文件)? ---/n");
76.         scanf("%c", &bcreate);
77.         if('y' == bcreate || 'Y' == bcreate)
78.         {
79.             InitHashFile(fname);
80.             printf("--- 新建散列文件完毕! ---/n");
81.         }
82.         else
83.         {
84.             printf("请输入散列文件路径:/n");
85.             scanf("%s", filename);
86.             strcpy(fname, filename);
87.             existHash(fname);
88.         }
89.     }
90.     else
91.     {
92.         fclose(fp);
93.     }
94. }
96. //把元素x插入到散列文件中
97. void HFInsertOne(char *fname, struct ElemType x)
98. {
99.     int p;
100.     int len;    //文件尾结点位置序号
101.     int *A;
102.     int d;
103.     struct FLNode temp;
104.     struct FLNode pn;
106.     //以读写和不新建方式打开散列文件
107.     FILE *fp;
108.     fp = fopen(fname, "rb+");
109.     if(NULL == fp)
110.     {
111.         printf("Cannot open this file!/n");
112.         exit(1);
113.     }
115.     //动态分配具有N + 1个整型存储空间的数组
116.     A = (int *)calloc(N + 1, b1);
117.     if(!A)
118.     {
119.         printf("Memory alloction failare!/n");
120.         exit(1);
121.     }
123.     //将散列文件的表头读入到数组A中
124.     fread((char *)A, (N + 1) * b1, 1, fp);
126.     //以关键字x.key计算x的散列地址，采用除留余数法
127.     d = x.key % N;
128.     //以x和A[d]的值构成待插入散列文件的内存节点temp   
129.     temp.data = x;
130.     temp.next = A[d];
131.     //将temp结点的值写入到散列文件中，并链接到散列文件表头
132.     //下表d单链表的表头
133.     if(-1 == A[N])
134.     {
135.         //将文件指针移至文件尾
136.         fseek(fp, 0L, 2);
137.         //计算出文件尾的结点位置序号
138.         len = (ftell(fp) - (N+1)*b1)/b2;
139.         //将temp结点的值写入文件尾
140.         fwrite((char *)&temp, b2, 1, fp);
141.         //使A[d]指向新插入的结点
142.         A[d] = len;
143.     }
144.     else
145.     {
146.         //p指向空闲单链表的表头结点
147.         p = A[N];
148.         //使空闲单链表的表头指针指向其下一个结点
149.         fseek(fp, b1 * (N+1) + p*b2, 0);
150.         fread((char *)&pn, b2, 1, fp);
151.         A[N] = pn.next;
152.         //使temp的值写入到p位置的结点上
153.         fseek(fp, -b2, 1);
154.         fwrite((char *)&temp, b2, 1, fp);
155.         //使A[p]指向新插入的p结点
156.         A[d] = p;
157.     }
158.     //将数组A中的全部内容写回到散列文件的表头中
159.     fseek(fp,0L,0);
160.     fwrite((char *)A, b1 * (N+1), 1, fp);
161.     //删除动态数组A和关闭散列文件
162.     free(A);
163.     fclose(fp);
164. }
166. //从散列文件中删除关键字尾x.key的元素，并有x带回该
167. //元素，若删除成功则返回1，否则返回0
168. int HFDelete(char *fname, struct ElemType *x)
169. {
170.     struct FLNode tp,tq;
171.     int p, q;
172.     int *A;
173.     int d;
174.     FILE *fp;
176.     //打开散列文件
177.     fp = fopen(fname, "rb+");
178.     if(NULL == fp)
179.     {
180.         printf("Cannot open this file!/n");
181.         exit(1);
182.     }
184.     //申请动态数组A
185.     A = (int *)calloc(N+1, b1);
186.     if(NULL == A)
187.     {
188.         printf("Memory alloction failare!/n");
189.         exit(1);
190.     }
192.     //将散列文件表头读入数组A中
193.     fread((char *)A, (N+1)*b1, 1, fp);
194.     
195.     //计算散列地址d
196.     d = x->key % N;
197.     p= A[d];
198.     while(-1 != p)
199.     {
200.         fseek(fp, (N+1)*b1+p*b2, 0);
201.         fread((char*)&tp, b2, 1, fp);
202.         if(tp.data.key  == x->key)
203.         {
204.             //被删除结点的元素值赋给x带回
205.             *x = tp.data;
207.             //从单链表中删除p结点
208.             if(p == A[d])
209.             {
210.                 A[d] = tp.next;
211.             }
212.             else
213.             {
214.                 tq.next = tp.next;
215.                 fseek(fp, (N+1)*b1+q*b2, 0);
216.                 fwrite((char *)&tq, b2, 1, fp);
217.             }
218.             //将p结点连接到空闲单链表的表头
219.             tp.next = A[N];
220.             fseek(fp, (N+1)*b1+p*b2, 0);
221.             fwrite((char *)&tp, b2, 1,fp);
222.             A[N] = p;
223.             //结束while循环
224.             break;
225.         }
226.         else
227.         {
228.             //使p指针的值赋给q，tp结点的值赋值给tq结点
229.             q = p;
230.             tq = tp;
231.             //p指向单链表中的下一个结点
232.             p = tp.next;
233.         }//if分支结束
234.     }//while循环结束
236.     //将文件指针移到文件头部，并将散列文件的表头重新写入散列文件
237.     fseek(fp, 0L, 0);
238.     fwrite((char *)A, (N + 1) * b1, 1, fp);
239.     //释放A数组申请的内存空间
240.     free(A);
241.     //关闭散列文件
242.     fclose(fp);
244.     if(-1 == p)
245.     {
246.         return 0;   //没有找到要删除的结点
247.     }   
248.     else
249.     {
250.         return 1;   //成功删除要删除的结点
251.     }//if分支结构结束
252. }
254. //从散列文件中查找关键字为x.key的元素，并由x带回
255. //元素，若查找成功则返回1，否则返回0
256. int HFSearch(char *fname, struct ElemType *x)
257. {
258.     int d;
259.     int p;
260.     int *A;
261.     struct FLNode temp;
262.     //以读写方式打开散列文件
263.     FILE *fp;
264.     fp = fopen(fname, "rb+");
265.     if(NULL == fp)
266.     {
267.         printf("Cannot open this file!/n");
268.         exit(1);
269.     }
270.     //申请动态数组A
271.     A = (int *)calloc(N+1, b1);
272.     if(NULL == A)
273.     {
274.         printf("Momery alloction failare!/n");
275.         exit(1);
276.     }
278.     fread((char *)A, (N+1)*b1, 1, fp);
279.     d = x->key % N;
280.     //取出d单链表的表头指针
281.     p = A[d];
282.     //从d点链表中查找关键字为x.key的元素
283.     while(p != -1)
284.     {
285.         fseek(fp, (N+1)*b1 + p*b2, 0);
286.         fread((char *)&temp, b2, 1, fp);
287.         if(temp.data.key == x->key)
288.         {
289.             *x = temp.data; //被查找到的元素由x带回
290.             break;
291.         }
292.         else
293.         {
294.             p = temp.next;  //把结点指针移到下一个结点
295.         }
296.     }
297.     //释放A数组申请的内存空间
298.     free(A);
299.     //关闭散列文件
300.     fclose(fp);
302.     if(-1 == p)
303.     {
304.         return 0;   
305.     }   
306.     else
307.     {
308.         return 1;   
309.     }//if分支结构结束
310. }
312. //顺序打印出散列文件中的每个单链表中的每个结点位置序号及元素值
313. void HFPrint(char *fname)
314. {
315.     int i;
316.     int p;
317.     int *A;
318.     struct FLNode pn;
319.     //以读写方式打开散列文件
320.     FILE *fp;
321.     fp = fopen(fname, "rb+");
322.     if(NULL == fp)
323.     {
324.         printf("Cannot open this file!/n");
325.         exit(1);
326.     }
327.     
328.     //申请动态数组A
329.     A = (int *)calloc(N+1, b1);
330.     if(NULL == A)
331.     {
332.         printf("Momery alloction failare!/n");
333.         exit(1);
334.     }
336.     fread((char *)A, (N+1)*b1, 1, fp);
338.     for(i = 0; i < N+1; i++)
339.     {
340.         printf("%d:", i);
341.         p = A[i];
342.         while(-1 != p)
343.         {
344.             fseek(fp, (N+1)*b1 + p*b2, 0);
345.             fread((char *)&pn, b2, 1, fp);
346.             printf("%d->%d  ", p, pn.data.key);
347.             p = pn.next;
348.         }
349.         printf("/n");
350.     }
351.     
352.     //删除动态数组A申请的内存
353.     free(A);
354.     //关闭散列文件
355.     fclose(fp);
356. }
358. //main函数
359. void main()
360. {
361.     struct ElemType x;
362.     int number; //选择的功能号表
363.     char ch;
364.     //定义tag用于保存或查找函数的返回值
365.     int tag;
366.     //定义散列文件的名字，为字符指针filename指向的字符串
367.     char filename[128];
368.     strcpy(filename, "Hash");
370.     //检测散列文件是否存在
371.     existHash(filename);
373.     while(1)
374.     {
375.         printf("/n");
376.         printf("/03-----------------------------------/03/n");
377.         printf("/03------------ 散列文件 -------------/03/n");
378.         printf("/03 1---- 初始化散列文件 -------------/03/n");
379.         printf("/03 2---- 向散列文件中插入一个元素 ---/03/n");
380.         printf("/03 3---- 从散列文件中删除一个元素 ---/03/n");
381.         printf("/03 4---- 从散列文件中查找一个元素 ---/03/n");
382.         printf("/03 5---- 打印散列文件 ---------------/03/n");
383.         printf("/03 0---- 结束运行 -------------------/03/n");
384.         
385.         printf("/03 请输入你的选择(1-5):");
386.         scanf("%d", &number);
388.         switch(number)
389.         {
390.             case 0:
391.                 return;
392.             case 1:
393.                 //初始化散列文件
394.                 printf("确实要重新初始化散列文件(y/n)？");
395.                 getchar();
396.                 scanf("%c", &ch);
397.                 if('y' == ch || 'Y' == ch)
398.                 {
399.                     //重新初始化散列文件
400.                     InitHashFile(filename); 
401.                     printf("--- 重新初始化散列文件完毕! ---/n");
402.                 }
403.                 else
404.                 {
405.                     printf("--- 未执行重建散列文件操作! ---/n");
406.                 }
407.                 break;
408.             case 2:
409.                 //向散列文件中插入一个元素
410.                 printf("输入待插入元素x的值(一个整数和一个字符串(长度小于10)):/n");
411.                 scanf("%d", &x.key);
412.                 scanf("%s", &x.rest);
413.                 HFInsertOne(filename, x);
414.                 break;
415.             case 3:
416.                 //从散列文件中删除一个元素
417.                 printf("输入待删除元素x的关键字：");
418.                 scanf("%d", &x.key);
419.                 tag = HFDelete(filename, &x);
420.                 if(1 == tag)
421.                 {
422.                     printf("--- 删除成功!%d %s ---/n", x.key, x.rest);
423.                 }
424.                 else
425.                 {
426.                     printf("--- 删除失败 ---/n");
427.                 }   //if分支结构结束
428.                 break;
429.             case 4:
430.                 //从散列文件中查找一个元素
431.                 printf("输入待查找元素x的关键字：/n");
432.                 scanf("%d", &x.key);
433.                 tag = HFSearch(filename, &x);
434.                 if(1 == tag)
435.                 {
436.                     printf("--- 查找成功!%d %s ---/n", x.key, x.rest);
437.                 }
438.                 else
439.                 {
440.                     printf("查找失败!/n");
441.                 }
442.                 break;
443.             case 5:
444.                 //打印散列文件
445.                 HFPrint(filename);
446.                 break;
447.             default:
448.                 printf("/n--- 输入功能号表错误 ---/n");
449.                 break;
450.         }   //switch结束
452.         printf("--- 按任意键继续 ---/n");
453.         getch();    //接收任意字符
454.     }
455. }