C语言实现哈希表（key为字符型）

 简单实现了哈希表的插入和查找功能，简要说明如下：

1、数据结构：

struct HashNode

{

            char* sKey;     //键

            int nValue;      //值

            HashNode* pNext; //当Hash值冲突时，指向HASH值相同的下一个节点。

}

HashNode* hashTable[HASH_TABLE_MAX_SIZE]; //哈希表的数组

int hash_table_size;       //哈希表中元素的个数

 

2、函数：

void hash_table_init() 初始化哈希表

void hash_table_insert(const char* skey, int nvalue) 向哈希表中插入键位skey,值为nvalue的键值对。

                            当skey已经在哈希表中时，忽略该键值对。 

void hash_table_remove(const char* skey) 从哈希表中删除键值对。

HashNode* hash_table_lookup(const char* skey) 查找键值为skey的节点。当找到时，返回对应的HashNode指针，

                            没有找到时，返回NULL。

void hash_table_release() 释放哈希表的内存空间。

C语言实现的哈希表(HashTable)源码如下：

[cpp] view plain  copy

 print ?

1. /* 
2.  * Author: puresky 
3.  * Date: 2011/01/08 
4.  * Purpose: a simple implementation of HashTable in C 
5.  */  
6.   
7. #include <stdio.h>  
8. #include <stdlib.h>  
9. #include <string.h>  
10. #include <time.h>  
11.   
12. /*=================hash table start=========================================*/  
13.   
14. #define HASH_TABLE_MAX_SIZE 10000  
15. typedef struct HashNode_Struct HashNode;  
16.   
17. struct HashNode_Struct  
18. {  
19.     char* sKey;  
20.     int nValue;  
21.     HashNode* pNext;  
22. };  
23.   
24. HashNode* hashTable[HASH_TABLE_MAX_SIZE]; //hash table data strcutrue  
25. int hash_table_size;  //the number of key-value pairs in the hash table!  
26.   
27. //initialize hash table  
28. void hash_table_init()  
29. {  
30.     hash_table_size = 0;  
31.     memset(hashTable, 0, sizeof(HashNode*) * HASH_TABLE_MAX_SIZE);  
32. }  
33.   
34.   
35. //string hash function  
36. unsigned int hash_table_hash_str(const char* skey)  
37. {  
38.     const signed char *p = (const signed char*)skey;  
39.     unsigned int h = *p;  
40.     if(h)  
41.     {  
42.         for(p += 1; *p != '\0'; ++p)  
43.             h = (h << 5) - h + *p;  
44.     }  
45.     return h;  
46. }  
47.   
48. //insert key-value into hash table  
49. void hash_table_insert(const char* skey, int nvalue)  
50. {  
51.     if(hash_table_size >= HASH_TABLE_MAX_SIZE)  
52.     {  
53.         printf("out of hash table memory!\n");  
54.         return;  
55.     }  
56.   
57.     unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE;  
58.   
59.     HashNode* pHead =  hashTable[pos];  
60.     while(pHead)  
61.     {  
62.         if(strcmp(pHead->sKey, skey) == 0)  
63.         {  
64.             printf("%s already exists!\n", skey);  
65.             return ;  
66.         }  
67.         pHead = pHead->pNext;  
68.     }  
69.   
70.     HashNode* pNewNode = (HashNode*)malloc(sizeof(HashNode));  
71.     memset(pNewNode, 0, sizeof(HashNode));  
72.     pNewNode->sKey = (char*)malloc(sizeof(char) * (strlen(skey) + 1));  
73.     strcpy(pNewNode->sKey, skey);  
74.     pNewNode->nValue = nvalue;  
75.   
76.     pNewNode->pNext = hashTable[pos];  
77.     hashTable[pos] = pNewNode;  
78.   
79.   
80.     hash_table_size++;  
81. }  
82. //remove key-value frome the hash table  
83. void hash_table_remove(const char* skey)  
84. {  
85.     unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE;  
86.     if(hashTable[pos])  
87.     {  
88.         HashNode* pHead = hashTable[pos];  
89.         HashNode* pLast = NULL;  
90.         HashNode* pRemove = NULL;  
91.         while(pHead)  
92.         {  
93.             if(strcmp(skey, pHead->sKey) == 0)  
94.             {  
95.                 pRemove = pHead;  
96.                 break;  
97.             }  
98.             pLast = pHead;  
99.             pHead = pHead->pNext;  
100.         }  
101.         if(pRemove)  
102.         {  
103.             if(pLast)  
104.                 pLast->pNext = pRemove->pNext;  
105.             else  
106.                 hashTable[pos] = NULL;  
107.   
108.             free(pRemove->sKey);  
109.             free(pRemove);  
110.         }  
111.     }  
112. }  
113.   
114. //lookup a key in the hash table  
115. HashNode* hash_table_lookup(const char* skey)  
116. {  
117.     unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE;  
118.     if(hashTable[pos])  
119.     {  
120.         HashNode* pHead = hashTable[pos];  
121.         while(pHead)  
122.         {  
123.             if(strcmp(skey, pHead->sKey) == 0)  
124.                 return pHead;  
125.             pHead = pHead->pNext;  
126.         }  
127.     }  
128.     return NULL;  
129. }  
130.   
131. //print the content in the hash table  
132. void hash_table_print()  
133. {  
134.     printf("===========content of hash table=================\n");  
135.     int i;  
136.     for(i = 0; i < HASH_TABLE_MAX_SIZE; ++i)  
137.         if(hashTable[i])  
138.         {  
139.             HashNode* pHead = hashTable[i];  
140.             printf("%d=>", i);  
141.             while(pHead)  
142.             {  
143.                 printf("%s:%d  ", pHead->sKey, pHead->nValue);  
144.                 pHead = pHead->pNext;  
145.             }  
146.             printf("\n");  
147.         }  
148. }  
149.   
150. //free the memory of the hash table  
151. void hash_table_release()  
152. {  
153.     int i;  
154.     for(i = 0; i < HASH_TABLE_MAX_SIZE; ++i)  
155.     {  
156.         if(hashTable[i])  
157.         {  
158.             HashNode* pHead = hashTable[i];  
159.             while(pHead)  
160.             {  
161.                 HashNode* pTemp = pHead;  
162.                 pHead = pHead->pNext;  
163.                 if(pTemp)  
164.                 {  
165.                     free(pTemp->sKey);  
166.                     free(pTemp);  
167.                 }  
168.   
169.             }  
170.         }  
171.     }  
172. }  
173.   
174. /* ===============================hash table end=========================*/  
175.   
176.   
177. /* ============================test function ============================*/  
178. #define MAX_STR_LEN 20  
179. #define MIN_STR_LEN 10  
180. void rand_str(char r[])  
181. {  
182.     int i;  
183.     int len = MIN_STR_LEN + rand() % (MAX_STR_LEN - MIN_STR_LEN);  
184.     for(i = 0; i < len - 1; ++i)  
185.         r[i] = 'a' + rand() % ( 'z' - 'a');  
186.     r[len - 1] = '\0';  
187. }  
188.   
189. int main(int argc, char** argv)  
190. {  
191.     srand(time(NULL));  
192.     hash_table_init();  
193.     printf("insert testing.........\n");  
194.     int n = 10;  
195.     const char *key1 = "aaammd";  
196.     const char *key2 = "xzzyym";  
197.     const char *key3 = "cdcded";  
198.   
199.     hash_table_insert(key1, 110);  
200.     hash_table_insert(key2, 220);  
201.     hash_table_insert(key3, 330);  
202.     char str[MAX_STR_LEN + 1];  
203.     while(n--)  
204.     {  
205.         rand_str(str);  
206.         hash_table_insert(str, n);  
207.     }  
208.     hash_table_print();  
209.   
210.     printf("\nlookup testing..........\n");  
211.     HashNode* pNode = hash_table_lookup(key1);  
212.     printf("lookup result:%d\n", pNode->nValue);  
213.     pNode = hash_table_lookup(key2);  
214.     printf("lookup result:%d\n", pNode->nValue);  
215.   
216.     printf("\nremove testing..........\n");  
217.     printf("before remove %s:\n", key3);  
218.     hash_table_print();  
219.     hash_table_remove(key3);  
220.     printf("after remove:\n");  
221.     hash_table_print();  
222.     hash_table_release();  
223.   
224.     system("pause");  
225.     return 0;  
226. }