map容器的c实现

原文来自：http://blog.chinaunix.net/uid-21457204-id-3063180.html

主要是使用红黑树这种数据结构封装一个MAP容器，本来想模仿STL MAP，不过现在暂时实现，今后会改进，目前还没实现加锁这功能，不过可以支持win32和linux平台。。。

以下是源代码:

1. /*
   
2. * file: main.c
   
3. * author: [e-mail]
   
4. * history:
   
5. * initial @ 2012-01-31
   
6. */
   
7. 
   
8. #define DEBUG
   
9. 
   
10. #include <stdio.h>
    
11. #include <time.h>
    
12. #include <stdlib.h>
    
13. #include <string.h>
    
14. 
    
15. #include "map.h"
    
16. 
    
17. #ifdef DEBUG
    
18. #define dump(a,s) __dump((a),(s))
    
19. #else
    
20. #define dump(a,s)
    
21. #endif
    
22. 
    
23. 
    
24. typedef struct word_info {
    
25. unsigned long hash_major;
    
26. unsigned long hash_minor;
    
27. char *path;
    
28. unsigned long line;
    
29. unsigned long col;
    
30. }word_info_t;
    
31. 
    
32. typedef struct priv_info {
    
33. unsigned long key;
    
34. char val[10];
    
35. }priv_info_t;
    
36. 
    
37. 
    
38. static void __dump(priv_info_t *array, size_t num)
    
39. {
    
40. int i;
    
41. printf("-- DUMP START -- \n");
    
42. for (i=0; i< num; i++)
    
43. {
    
44. printf("array[%d].key=%03d, array[%d].val=%s\n",
    
45. i, array[i].key, i,array[i].val);
    
46. }
    
47. printf("-- DUMP END -- \n");
    
48. }
    
49. 
    
50. #define map_info(pm){\
    
51. printf("-- dump map start ... --\n");\
    
52. map_dump(pm);\
    
53. printf("-- dump map end ... --\n");\
    
54. }
    
55. 
    
56. #define ARRAY_SIZE(a)(sizeof(a)/sizeof(a[0]))
    
57. 
    
58. #define MAX_NUM 20
    
59. 
    
60. int main()
    
61. {
    
62. map_t map1;
    
63. int key;
    
64. int i, j;
    
65. priv_info_t priv_info[MAX_NUM];
    
66. 
    
67. srand(time(0));
    
68. 
    
69. memset(priv_info, 0, sizeof(priv_info));
    
70. for (i=0; i<MAX_NUM; i++)
    
71. {
    
72. key = rand()%MAX_NUM;
    
73. priv_info[i].key= key;
    
74. sprintf(priv_info[i].val,"i am %d", key);
    
75. }
    
76. dump(priv_info, ARRAY_SIZE(priv_info));
    
77. 
    
78. map_init(&map1);
    
79. 
    
80. i = 0;
    
81. while (i< MAX_NUM)
    
82. {
    
83. struct mnode* node;
    
84. printf("-- %d -- \n", i);
    
85. node = map_find(&map1,&(priv_info[i].key),NULL);
    
86. if (!node){
    
87. printf("->>> insert node: priv_info[%d].key=%d \n", i, priv_info[i].key);
    
88. map_insert_alloc(&map1,&(priv_info[i].key),
    
89. &priv_info[i], sizeof(priv_info[i]),NULL);
    
90. } else {
    
91. /* key not matched, so just print out */
    
92. printf("priv_info[%d].key=%d is exist!\n", i, priv_info[i].key);
    
93. for (j=0; j< MAX_NUM; j++){
    
94. if(priv_info[j].key== priv_info[i].key&& i!=j)
    
95. printf("\t|-- priv_info[%d].key=%d\n", j, priv_info[j].key);
    
96. }
    
97. }
    
98. map_info(&map1);
    
99. 
    
100. i++;
     
101. }
     
102. map_info(&map1);
     
103. 
     
104. printf("-----------------------------------\n");
     
105. for (i=0; i< MAX_NUM; i++)
     
106. {
     
107. struct mnode* node;
     
108. node = map_find(&map1,&i,NULL);
     
109. if (node){
     
110. map_remove_free(&map1,&i, NULL);
     
111. printf("--> key=%03d deleted!\n", i);
     
112. map_info(&map1);
     
113. }else{
     
114. printf("key=%03d not found!\n", i);
     
115. }
     
116. }
     
117. map_info(&map1);
     
118. 
     
119. map_exit(&map1);
     
120. return 0;
     
121. }

.............................................................................................
.............................................................................................

1. /*
   
2. * file: map.h
   
3. * author: [e-mail]
   
4. * history:
   
5. * initial @ 2012-01-31
   
6. */
   
7. #ifndef __MAP_H__
   
8. #define __MAP_H__
   
9. 
   
10. #include <stdlib.h>
    
11. #include "platform.h"
    
12. #include "rbtree.h"
    
13. 
    
14. #define lock_t int
    
15. #define lock_init(x)
    
16. #define lock_exit(x)
    
17. 
    
18. #ifndef NULL
    
19. #define NULL 0
    
20. #endif
    
21. 
    
22. #define __assert(x)
    
23. #define __free(x) free(x)
    
24. #define __malloc(x) malloc(x)
    
25. #define __memcpy(d,s,len) memcpy((d),(s),(len))
    
26. 
    
27. extern struct map;
    
28. 
    
29. typedef int (*CMP_FUNC)(const void*d1, const void *d2);
    
30. 
    
31. typedef struct mnode{
    
32. struct rb_node node;
    
33. void *key;
    
34. void *private;
    
35. }mnode_t;
    
36. 
    
37. /*
    
38. typedef struct ops{
    
39. struct mnode*(*find)(struct map*map, void *key, CMP_FUNC cmpf);
    
40. int (*insert_alloc)(struct map*map, void *key,
    
41. void *private, size_t size, CMP_FUNC cmpf);
    
42. int (*remove_free)(struct map*map, void *key, CMP_FUNC cmpf);
    
43. int (*insert)(struct map*map, struct mnode*data, CMP_FUNC cmpf);
    
44. int (*remove)(struct map*map, void *key, CMP_FUNC cmpf);
    
45. }ops_t;
    
46. */
    
47. 
    
48. typedef struct map{
    
49. struct rb_root root;
    
50. lock_t lock;
    
51. }map_t;
    
52. 
    
53. extern int map_init(struct map* map);
    
54. extern int map_exit(struct map* map);
    
55. 
    
56. struct mnode* __rbfind(struct map*map, void *key, CMP_FUNC cmpf);
    
57. int __rbinsert_alloc(struct map*map, void *key,
    
58. void *private, size_t size, CMP_FUNC cmpf);
    
59. int __rbremove_free(struct map*map, void *key, CMP_FUNC cmpf);
    
60. int __rbinsert(struct map*map, struct mnode*data, CMP_FUNC cmpf);
    
61. int __rbremove(struct map*map, void *key, CMP_FUNC cmpf);
    
62. 
    
63. #define map_find(map,key,cmpf)\
    
64. __rbfind((map),(key),(cmpf))
    
65. 
    
66. #define map_insert_alloc(map,key,priv,size,cmpf)\
    
67. __rbinsert_alloc((map),(key),(priv),(size),(cmpf))
    
68. 
    
69. #define map_remove_free(map,key,cmpf)\
    
70. __rbremove_free((map),(key),(cmpf))
    
71. 
    
72. #if 0
    
73. #define map_insert(map,data,cmpf)\
    
74. __rbinsert((map),(data),(cmpf))
    
75. #define map_remove(map,key,cmpf)\
    
76. __rbremove((map),(key),(cmpf))
    
77. #endif
    
78. 
    
79. 
    
80. #define map_entry(ptr, type, member) container_of(ptr, type, member)
    
81. 
    
82. extern struct mnode *map_first(const struct map*map);
    
83. extern struct mnode *map_last(const struct map*map);
    
84. extern struct mnode *map_next(const struct mnode*mnode);
    
85. extern struct mnode *map_prev(const struct mnode*mnode);
    
86. 
    
87. extern void map_dump(const struct map* map);
    
88. 
    
89. 
    
90. #endif

.............................................................................................
.............................................................................................

1. /*
   
2. * file: map.c
   
3. * author: [e-mail]
   
4. * history:
   
5. * initial @ 2012-01-31
   
6. */
   
7. #define DEBUG
   
8. #include "map.h"
   
9. 
   
10. #define mnode_init(mnode){\
    
11. (mnode)->node.rb_parent_color=0;\
    
12. (mnode)->node.rb_right=0;\
    
13. (mnode)->node.rb_left=0;\
    
14. (mnode)->key=0;\
    
15. (mnode)->private=0;\
    
16. }
    
17. 
    
18. 
    
19. void map_dump(const struct map* map)
    
20. {
    
21. struct mnode *mnode;
    
22. int cnt=0;
    
23. for (mnode= map_first(map); mnode; mnode= map_next(mnode))
    
24. printf("key=%03d%s",*(int*)mnode->key,++cnt%10==0?"\n":" ");
    
25. printf("\n");
    
26. }
    
27. 
    
28. 
    
29. static int __cmp_default(long*d1, long *d2)
    
30. {
    
31. // printf("-- d1:%d, d2:%d\n",*d1, *d2);
    
32. if (*d1< *d2) return-1;
    
33. else if(*d1 > *d2) return 1;
    
34. else return 0;
    
35. }
    
36. 
    
37. struct mnode* __rbfind(struct map*map, void *key, CMP_FUNC cmpf)
    
38. {
    
39. int result;
    
40. CMP_FUNC cmp;
    
41. struct mnode *data;
    
42. struct rb_node *node = map->root.rb_node;
    
43. 
    
44. __assert(map && key);
    
45. 
    
46. cmp = cmpf ? cmpf: __cmp_default;
    
47. /* printf("==> entry %s key:%d\n", __func__,*(int*)key);*/
    
48. while (node)
    
49. {
    
50. data = container_of(node, struct mnode, node);
    
51. /* printf("data->key:%d VS key:%d\n",*(int*)(data->key),*(int*)key);*/
    
52. result = cmp(key, data->key);
    
53. /*printf("result=%d, node->rb_left=%p, node->rb_right=%p\n",
    
54. result, node->rb_left, node->rb_right);*/
    
55. if (result< 0)
    
56. node = node->rb_left;
    
57. else if(result > 0)
    
58. node = node->rb_right;
    
59. else
    
60. return data;
    
61. }
    
62. //printf("node=%p\n", node);
    
63. return NULL;
    
64. }
    
65. 
    
66. int __rbinsert(struct map*map, struct mnode*data, CMP_FUNC cmpf)
    
67. {
    
68. int result;
    
69. struct mnode *this;
    
70. CMP_FUNC cmp;
    
71. struct rb_node **new= &(map->root.rb_node),*parent = NULL;
    
72. 
    
73. __assert(map && data);
    
74. 
    
75. cmp = cmpf ? cmpf: __cmp_default;
    
76. 
    
77. /* Figure out whereto put new node */
    
78. while (*new)
    
79. {
    
80. this = container_of(*new, struct mnode, node);
    
81. result = cmp(data->key, this->key);
    
82. 
    
83. parent = *new;
    
84. if (result< 0) new = &((*new)->rb_left);
    
85. else if(result > 0) new= &((*new)->rb_right);
    
86. else return -2;
    
87. }
    
88. /* Add new nodeand rebalance tree.*/
    
89. rb_link_node(&(data->node), parent, new);
    
90. rb_insert_color(&(data->node),&(map->root));
    
91. return 0;
    
92. }
    
93. 
    
94. int __rbremove(struct map*map, void *key, CMP_FUNC cmpf)
    
95. {
    
96. struct mnode* data = __rbfind(map, key, cmpf);
    
97. __assert(map && key);
    
98. if (data)
    
99. rb_erase(&(data->node),&(map->root));
    
100. return 0;
     
101. }
     
102. 
     
103. int __rbinsert_alloc(struct map*map, void *key,
     
104. void *private, size_t size, CMP_FUNC cmpf)
     
105. {
     
106. struct mnode *new;
     
107. __assert(map && key&& private);
     
108. new = (struct mnode*)__malloc(size+sizeof(struct mnode));
     
109. __assert(new);
     
110. mnode_init(new);
     
111. new->key= key;
     
112. new->private= new+1;
     
113. if (private)
     
114. __memcpy(new->private,private, size);
     
115. 
     
116. return __rbinsert(map, new, cmpf);
     
117. }
     
118. 
     
119. int __rbremove_free(struct map*map, void *key, CMP_FUNC cmpf)
     
120. {
     
121. struct mnode* data;
     
122. __assert(map && key);
     
123. data = __rbfind(map, key, cmpf);
     
124. /* printf("%s: key: %d\n", __func__,*(int*)(data->key));*/
     
125. if (data)
     
126. {
     
127. /* printf("%s: deleted!\n", __func__);*/
     
128. rb_erase(&(data->node),&(map->root));
     
129. __free(data);
     
130. }
     
131. return 0;
     
132. }
     
133. 
     
134. struct mnode *map_first(const struct map*map)
     
135. {
     
136. struct rb_node *node;
     
137. __assert(map);
     
138. node = rb_first(&(map->root));
     
139. if(node)
     
140. return map_entry(node, struct mnode, node);
     
141. return NULL;
     
142. }
     
143. 
     
144. struct mnode *map_last(const struct map*map)
     
145. {
     
146. struct rb_node *node;
     
147. __assert(map);
     
148. node = rb_last(&(map->root));
     
149. if(node)
     
150. return map_entry(node, struct mnode, node);
     
151. return NULL;
     
152. }
     
153. 
     
154. struct mnode *map_next(const struct mnode*mnode)
     
155. {
     
156. struct rb_node *node;
     
157. __assert(mnode);
     
158. node = rb_next(&(mnode->node));
     
159. if(node)
     
160. return map_entry(node, struct mnode, node);
     
161. return NULL;
     
162. }
     
163. 
     
164. struct mnode *map_prev(const struct mnode*mnode)
     
165. {
     
166. struct rb_node *node;
     
167. __assert(mnode);
     
168. node = rb_prev(&(mnode->node));
     
169. if(node)
     
170. return map_entry(node, struct mnode, node);
     
171. return NULL;
     
172. }
     
173. 
     
174. 
     
175. int map_init(struct map* map)
     
176. {
     
177. map->root.rb_node= NULL;
     
178. lock_init(map->lock);
     
179. return 0;
     
180. }
     
181. 
     
182. int map_exit(struct map* map)
     
183. {
     
184. lock_exit(map->lock);
     
185. return 0;
     
186. }