哈希表

实现一个简单的哈希表。

 

1. /*
2.  * hashtab.h -
3.  * A hash table (hashtab) maintains associations between
4.  * key values and datum values.  The type of the key values
5.  * and the type of the datum values is arbitrary.  The
6.  * functions for hash computation and key comparison are
7.  * provided by the creator of the table.
8.  *
9.  * Author : jta, 2008, 6
10.  */
11. #ifndef _HASHTAB_H_
12. #define _HASHTAB_H_
15. #ifdef  __cplusplus
16. extern "C" {
17. #endif
19. #define HASHTAB_MAX_NODES   0xffffffff
21. typedef unsigned long u32;
23. struct hashtab_node {
24.     void *key;
25.     void *datum;
26.     struct hashtab_node *next;
27. };
29. struct hashtab {
30.     struct hashtab_node **htable;   /* hash table */
31.     u32 size;           /* number of slots in hash table */
32.     u32 nel;            /* number of elements in hash table */
33.     u32 (*hash_value)(struct hashtab *h, void *key);
34.                     /* hash function */
35.     int (*keycmp)(struct hashtab *h, void *key1, void *key2);
36.                     /* key comparison function */
37. };
39. struct hashtab_info {
40.     u32 slots_used;
41.     u32 max_chain_len;
42. };
44. /*
45.  * Creates a new hash table with the specified characteristics.
46.  *
47.  * Returns NULL if insufficent space is available or
48.  * the new hash table otherwise.
49.  */
50. struct hashtab *hashtab_create(u32 (*hash_value)(struct hashtab *h, void *key),
51.                                int (*keycmp)(struct hashtab *h, void *key1, void *key2),
52.                                u32 size);
54. /*
55.  * Inserts the specified (key, datum) pair into the specified hash table.
56.  *
57.  * Returns -ENOMEM on memory allocation error,
58.  * -EEXIST if there is already an entry with the same key,
59.  * -EINVAL for general errors or
60.  * 0 otherwise.
61.  */
62. #define hashtab_add hashtab_insert
63. int hashtab_insert(struct hashtab *h, void *k, void *d);
65. /*
66.  * Searches for the entry with the specified key in the hash table.
67.  *
68.  * Returns NULL if no entry has the specified key or
69.  * the datum of the entry otherwise.
70.  */
71. void *hashtab_search(struct hashtab *h, void *k);
73. /*
74.  * Destroys the specified hash table.
75.  */
76. void hashtab_destroy(struct hashtab *h);
78. /*
79.  * Applies the specified apply function to (key,datum,args)
80.  * for each entry in the specified hash table.
81.  *
82.  * The order in which the function is applied to the entries
83.  * is dependent upon the internal structure of the hash table.
84.  *
85.  * If apply returns a non-zero status, then hashtab_map will cease
86.  * iterating through the hash table and will propagate the error
87.  * return to its caller.
88.  */
89. int hashtab_map(struct hashtab *h,
90.         int (*apply)(void *k, void *d, void *args),
91.         void *args);
93. /* Fill info with some hash table statistics */
94. void hashtab_stat(struct hashtab *h, struct hashtab_info *info);
96. #ifdef  __cplusplus
97. }
98. #endif
100. #endif  /* _HASHTAB_H_ */

1. /*
2.  * hashtab.c - Implementation of the hash table.
3.  *
4.  * Author : jta, 2008, 6
5.  */
6. #include <string.h>
7. #include <malloc.h>
8. #include "hashtab.h"
11. u32 hashfun( struct hashtab * h , void* key ) ;
13. int keycmp(struct hashtab *h, void *key1, void *key2);
16. struct hashtab *hashtab_create(u32 (*value)(struct hashtab *h, void *key),
17.                                int (*cmp)(struct hashtab *h, void *key1, void *key2),
18.                                u32 size)
19. {
20.     struct hashtab *p;
21.     u32 i;
23.     p = malloc(sizeof(*p));
24.     if (p == NULL)
25.         return p;
26.     memset(p,0,sizeof(*p));
28.     p->size = size;
29.     p->nel = 0;
30.     p->hash_value = value? value : hashfun;
31.     p->keycmp = cmp ? cmp : keycmp;
32.     p->htable = malloc(sizeof(*(p->htable)) * size);
33.     if (p->htable == NULL) {
34.         free(p);
35.         return NULL;
36.     }
38.     for (i = 0; i < size; i++)
39.         p->htable[i] = NULL;
41.     return p;
42. }
44. int hashtab_insert(struct hashtab *h, void *key, void *datum)
45. {
46.     u32 hvalue;
47.     struct hashtab_node *prev, *cur, *newnode;
49.     if (!h || h->nel == HASHTAB_MAX_NODES)
50.         return -1;
52.     hvalue = h->hash_value(h, key);
53.     prev = NULL;
54.     cur = h->htable[hvalue];
55.     while (cur && h->keycmp(h, key, cur->key) > 0) {
56.         prev = cur;
57.         cur = cur->next;
58.     }
60.     if (cur && (h->keycmp(h, key, cur->key) == 0))
61.         return -1;
63.     newnode = malloc(sizeof(*newnode));
64.     memset(newnode, 0, sizeof(*newnode));
65.     if (newnode == NULL)
66.         return -1;
67.     newnode->key = key;
68.     newnode->datum = datum;
69.     if (prev) {
70.         newnode->next = prev->next;
71.         prev->next = newnode;
72.     } else {
73.         newnode->next = h->htable[hvalue];
74.         h->htable[hvalue] = newnode;
75.     }
77.     h->nel++;
78.     return 0;
79. }
82. void *hashtab_search(struct hashtab *h, void *key)
83. {
84.     u32 hvalue;
85.     struct hashtab_node *cur;
87.     if (!h)
88.         return NULL;
90.     hvalue = h->hash_value(h, key);
91.     cur = h->htable[hvalue];
92.     while (cur != NULL && h->keycmp(h, key, cur->key) > 0)
93.         cur = cur->next;
95.     if (cur == NULL || (h->keycmp(h, key, cur->key) != 0))
96.         return NULL;
98.     return cur->datum;
99. }
101. void hashtab_destroy(struct hashtab *h)
102. {
103.     u32 i;
104.     struct hashtab_node *cur, *temp;
106.     if (!h)
107.         return;
109.     for (i = 0; i < h->size; i++) {
110.         cur = h->htable[i];
111.         while (cur != NULL) {
112.             temp = cur;
113.             cur = cur->next;
114.             free(temp);
115.         }
116.         h->htable[i] = NULL;
117.     }
119.     free(h->htable);
120.     h->htable = NULL;
122.     free(h);
123. }
125. int hashtab_map(struct hashtab *h,
126.         int (*apply)(void *k, void *d, void *args),
127.         void *args)
128. {
129.     u32 i;
130.     int ret;
131.     struct hashtab_node *cur;
133.     if (!h)
134.         return 0;
136.     for (i = 0; i < h->size; i++) {
137.         cur = h->htable[i];
138.         while (cur != NULL) {
139.             ret = apply(cur->key, cur->datum, args);
140.             if (ret)
141.                 return ret;
142.             cur = cur->next;
143.         }
144.     }
145.     return 0;
146. }
149. void hashtab_stat(struct hashtab *h, struct hashtab_info *info)
150. {
151.     u32 i, chain_len, slots_used, max_chain_len;
152.     struct hashtab_node *cur;
154.     slots_used = 0;
155.     max_chain_len = 0;
156.     for (slots_used = max_chain_len = i = 0; i < h->size; i++) {
157.         cur = h->htable[i];
158.         if (cur) {
159.             slots_used++;
160.             chain_len = 0;
161.             while (cur) {
162.                 chain_len++;
163.                 cur = cur->next;
164.             }
166.             if (chain_len > max_chain_len)
167.                 max_chain_len = chain_len;
168.         }
169.     }
171.     info->slots_used = slots_used;
172.     info->max_chain_len = max_chain_len;
173. }
177. /**
178.  * Default hash function
179.  */
182. u32 hashfun( struct hashtab * h , void* key )
183. {
184.     int* pi = (int *)key ;
185.     return *pi%10 ;
186. }
188. int keycmp(struct hashtab *h, void *key1, void *key2)
189. {
190.     int* pi1 = (int *)key1 ;
191.     int* pi2 = (int *)key2 ;
192.     return *pi1 - *pi2;
193. }
195. #ifdef _DEBUG_HASHTAB_
196. int main()
197. {
198.     struct hashtab *hash ;
199.     u32 size = 10;
200.     hash = hashtab_create(hashfun, keycmp, size);
201.     int x =  (hash->hash_value)( hash, (void *)&size );
202.     int tk = 21;
203.     char cd[5] = "xx";
204.     hashtab_insert(hash, (void*)&tk, (void*)cd);
205.     char* cp = (char*)hashtab_search(hash, (void*)&tk);
206.     printf("%s",cp);
207.     return 0;
208. }
209. #endif