C语言面向对象编程（五）：单链表实现（转）

这里实现的单链表，可以存储任意数据类型，支持增、删、改、查找、插入等基本操作。（本文提供的是完整代码，可能有些长。）

下面是头文件：

1 #ifndef SLIST_H
2 #define SLIST_H
3
4 #ifdef __cplusplus
5 extern "C" {
6 #endif
7
8 #define NODE_T(ptr, type) ((type*)ptr)
9
10 struct slist_node {
11     struct slist_node * next;
12 };
13
14 typedef void (*list_op_free_node)(struct slist_node *node);
15 /*
16  * return 0 on hit key, else return none zero
17  */
18 typedef int (*list_op_key_hit_test)(struct slist_node *node, void *key);
19
20 struct single_list {
21     /* all the members must not be changed manually by callee */
22     struct slist_node * head;
23     struct slist_node * tail;
24     int size; /* length of the list, do not change it manually*/
25
26     /* free method to delete the node
27      */
28     void (*free_node)(struct slist_node *node);
29     /*
30      * should be set by callee, used to locate node by key(*_by_key() method)
31      * return 0 on hit key, else return none zero
32      */
33     int (*key_hit_test)(struct slist_node *node, void *key);
34
35     struct single_list *(*add)(struct single_list * list, struct slist_node * node);
36     struct single_list *(*insert)(struct single_list * list, int pos, struct slist_node *node);
37     /* NOTE: the original node at the pos will be freed by free_node */
38     struct single_list *(*replace)(struct single_list *list, int pos, struct slist_node *node);
39     struct slist_node *(*find_by_key)(struct single_list *, void * key);
40     struct slist_node *(*first)(struct single_list* list);
41     struct slist_node *(*last)(struct single_list* list);
42     struct slist_node *(*at)(struct single_list * list, int pos);
43     struct slist_node *(*take_at)(struct single_list * list, int pos);
44     struct slist_node *(*take_by_key)(struct single_list * list, void *key);
45     struct single_list *(*remove)(struct single_list * list, struct slist_node * node);
46     struct single_list *(*remove_at)(struct single_list *list, int pos);
47     struct single_list *(*remove_by_key)(struct single_list *list, void *key);
48     int (*length)(struct single_list * list);
49     void (*clear)(struct single_list * list);
50     void (*deletor)(struct single_list *list);
51 };
52
53 struct single_list * new_single_list(list_op_free_node op_free, list_op_key_hit_test op_cmp);
54
55 #ifdef __cplusplus
56 }
57 #endif
58
59 #endif // SLIST_H

struct single_list 这个类，遵循我们前面介绍的基本原则，不再一一细说。有几点需要提一下：

我们定义了 slist_node 作为链表节点的基类，用户自定义的节点，都必须从 slist_node 继承

为了支持节点（ node ）的释放，我们引入一个回调函数 list_op_free_node ，这个回调需要在创建链表时传入

为了支持查找，引入另外一个回调函数 list_op_key_hit_test

好了，下面看实现文件：

1 #include "slist.h"
2 #include <malloc.h>
3
4 static struct single_list * _add_node(struct single_list *list, struct slist_node *node)
5 {
6
7     if(list->tail)
8     {
9         list->tail->next = node;
10         node->next = 0;
11         list->tail = node;
12         list->size++;
13     }
14     else
15     {
16         list->head = node;
17         list->tail = node;
18         node->next = 0;
19         list->size = 1;
20     }
21
22     return list;
23 }
24
25 static struct single_list * _insert_node(struct single_list * list, int pos, struct slist_node *node)
26 {
27     if(pos < list->size)
28     {
29         int i = 0;
30         struct slist_node * p = list->head;
31         struct slist_node * prev = list->head;
32         for(; i < pos; i++)
33         {
34             prev = p;
35             p = p->next;
36         }
37         if(p == list->head)
38         {
39             /* insert at head */
40             node->next = list->head;
41             list->head = node;
42         }
43         else
44         {
45             prev->next = node;
46             node->next = p;
47         }
48
49         if(node->next == 0) list->tail = node;
50         list->size++;
51     }
52     else
53     {
54         list->add(list, node);
55     }
56
57     return list;
58 }
59
60 static struct single_list * _replace(struct single_list * list, int pos, struct slist_node *node)
61 {
62     if(pos < list->size)
63     {
64         int i = 0;
65         struct slist_node * p = list->head;
66         struct slist_node * prev = list->head;
67         for(; i < pos; i++)
68         {
69             prev = p;
70             p = p->next;
71         }
72         if(p == list->head)
73         {
74             /* replace at head */
75             node->next = list->head->next;
76             list->head = node;
77         }
78         else
79         {
80             prev->next = node;
81             node->next = p->next;
82         }
83
84         if(node->next == 0) list->tail = node;
85
86         if(list->free_node) list->free_node(p);
87         else free(p);
88     }
89
90     return list;
91 }
92
93 static struct slist_node * _find_by_key(struct single_list *list, void * key)
94 {
95     if(list->key_hit_test)
96     {
97         struct slist_node * p = list->head;
98         while(p)
99         {
100             if(list->key_hit_test(p, key) == 0) return p;
101             p = p->next;
102         }
103     }
104     return 0;
105 }
106
107 static struct slist_node *_first_of(struct single_list* list)
108 {
109     return list->head;
110 }
111
112 static struct slist_node *_last_of(struct single_list* list)
113 {
114     return list->tail;
115 }
116
117 static struct slist_node *_node_at(struct single_list * list, int pos)
118 {
119     if(pos < list->size)
120     {
121         int i = 0;
122         struct slist_node * p = list->head;
123         for(; i < pos; i++)
124         {
125             p = p->next;
126         }
127         return p;
128     }
129
130     return 0;
131 }
132
133 static struct slist_node * _take_at(struct single_list * list, int pos)
134 {
135     if(pos < list->size)
136     {
137         int i = 0;
138         struct slist_node * p = list->head;
139         struct slist_node * prev = p;
140         for(; i < pos ; i++)
141         {
142             prev = p;
143             p = p->next;
144         }
145         if(p == list->head)
146         {
147             list->head = p->next;
148             if(list->head == 0) list->tail = 0;
149         }
150         else if(p == list->tail)
151         {
152             list->tail = prev;
153             prev->next = 0;
154         }
155         else
156         {
157             prev->next = p->next;
158         }
159
160         list->size--;
161
162         p->next = 0;
163         return p;
164     }
165
166     return 0;
167 }
168
169 static struct slist_node * _take_by_key(struct single_list * list, void *key)
170 {
171     if(list->key_hit_test)
172     {
173         struct slist_node * p = list->head;
174         struct slist_node * prev = p;
175         while(p)
176         {
177             if(list->key_hit_test(p, key) == 0) break;
178             prev = p;
179             p = p->next;
180         }
181
182         if(p)
183         {
184             if(p == list->head)
185             {
186                 list->head = p->next;
187                 if(list->head == 0) list->tail = 0;
188             }
189             else if(p == list->tail)
190             {
191                 list->tail = prev;
192                 prev->next = 0;
193             }
194             else
195             {
196                 prev->next = p->next;
197             }
198
199             list->size--;
200
201             p->next = 0;
202             return p;
203         }
204     }
205     return 0;
206 }
207
208 static struct single_list *_remove_node(struct single_list * list, struct slist_node * node)
209 {
210     struct slist_node * p = list->head;
211     struct slist_node * prev = p;
212     while(p)
213     {
214         if(p == node) break;
215         prev = p;
216         p = p->next;
217     }
218
219     if(p)
220     {
221         if(p == list->head)
222         {
223             list->head = list->head->next;
224             if(list->head == 0) list->tail = 0;
225         }
226         else if(p == list->tail)
227         {
228             prev->next = 0;
229             list->tail = prev;
230         }
231         else
232         {
233             prev->next = p->next;
234         }
235
236         if(list->free_node) list->free_node(p);
237         else free(p);
238
239         list->size--;
240     }
241     return list;
242 }
243
244 static struct single_list *_remove_at(struct single_list *list, int pos)
245 {
246     if(pos < list->size)
247     {
248         int i = 0;
249         struct slist_node * p = list->head;
250         struct slist_node * prev = p;
251         for(; i < pos ; i++)
252         {
253             prev = p;
254             p = p->next;
255         }
256         if(p == list->head)
257         {
258             list->head = p->next;
259             if(list->head == 0) list->tail = 0;
260         }
261         else if(p == list->tail)
262         {
263             list->tail = prev;
264             prev->next = 0;
265         }
266         else
267         {
268             prev->next = p->next;
269         }
270
271         if(list->free_node) list->free_node(p);
272         else free(p);
273
274         list->size--;
275     }
276
277     return list;
278 }
279
280 static struct single_list *_remove_by_key(struct single_list *list, void *key)
281 {
282     if(list->key_hit_test)
283     {
284         struct slist_node * p = list->head;
285         struct slist_node * prev = p;
286         while(p)
287         {
288             if(list->key_hit_test(p, key) == 0) break;
289             prev = p;
290             p = p->next;
291         }
292
293         if(p)
294         {
295             if(p == list->head)
296             {
297                 list->head = list->head->next;
298                 if(list->head == 0) list->tail = 0;
299             }
300             else if(p == list->tail)
301             {
302                 prev->next = 0;
303                 list->tail = prev;
304             }
305             else
306             {
307                 prev->next = p->next;
308             }
309
310             if(list->free_node) list->free_node(p);
311             else free(p);
312
313             list->size--;
314         }
315     }
316
317     return list;
318 }
319
320 static int _length_of(struct single_list * list)
321 {
322     return list->size;
323 }
324
325 static void _clear_list(struct single_list * list)
326 {
327     struct slist_node * p = list->head;
328     struct slist_node * p2;
329     while(p)
330     {
331         p2 = p;
332         p = p->next;
333
334         if(list->free_node) list->free_node(p2);
335         else free(p2);
336     }
337
338     list->head = 0;
339     list->tail = 0;
340     list->size = 0;
341 }
342
343 static void _delete_single_list(struct single_list *list)
344 {
345     list->clear(list);
346     free(list);
347 }
348
349 struct single_list * new_single_list(list_op_free_node op_free, list_op_key_hit_test op_cmp)
350 {
351     struct single_list *list = (struct single_list *)malloc(sizeof(struct single_list));
352     list->head = 0;
353     list->tail = 0;
354     list->size = 0;
355     list->free_node = op_free;
356     list->key_hit_test = op_cmp;
357
358     list->add = _add_node;
359     list->insert = _insert_node;
360     list->replace = _replace;
361     list->find_by_key = _find_by_key;
362     list->first = _first_of;
363     list->last = _last_of;
364     list->at = _node_at;
365     list->take_at = _take_at;
366     list->take_by_key = _take_by_key;
367     list->remove = _remove_node;
368     list->remove_at = _remove_at;
369     list->remove_by_key = _remove_by_key;
370     list->length = _length_of;
371     list->clear = _clear_list;
372     list->deletor = _delete_single_list;
373
374     return list;
375 }

上面的代码就不一一细说了，下面是测试代码：

1 /* call 1 or N arguments function of struct */
2 #define ST_CALL(THIS,func,args...) ((THIS)->func(THIS,args))
3
4 /* call none-arguments function of struct */
5 #define ST_CALL_0(THIS,func) ((THIS)->func(THIS))
6
7 struct int_node {
8     struct slist_node node;
9     int id;
10 };
11
12 struct string_node {
13     struct slist_node node;
14     char name[16];
15 };
16
17
18 static int int_free_flag = 0;
19 static void _int_child_free(struct slist_node *node)
20 {
21     free(node);
22     if(!int_free_flag)
23     {
24         int_free_flag = 1;
25         printf("int node free\n");
26     }
27 }
28
29 static int _int_slist_hittest(struct slist_node * node, void *key)
30 {
31     struct int_node * inode = NODE_T(node, struct int_node);
32     int ikey = (int)key;
33     return (inode->id == ikey ? 0 : 1);
34 }
35
36 static int string_free_flag = 0;
37 static void _string_child_free(struct slist_node *node)
38 {
39     free(node);
40     if(!string_free_flag)
41     {
42         string_free_flag = 1;
43         printf("string node free\n");
44     }
45 }
46
47 static int _string_slist_hittest(struct slist_node * node, void *key)
48 {
49     struct string_node * sn = (struct string_node*)node;
50     return strcmp(sn->name, (char*)key);
51 }
52
53 void int_slist_test()
54 {
55     struct single_list * list = new_single_list(_int_child_free, _int_slist_hittest);
56     struct int_node * node = 0;
57     struct slist_node * bn = 0;
58     int i = 0;
59
60     printf("create list && nodes:\n");
61     for(; i < 100; i++)
62     {
63         node = (struct int_node*)malloc(sizeof(struct int_node));
64         node->id = i;
65         if(i%10)
66         {
67             list->add(list, node);
68         }
69         else
70         {
71             list->insert(list, 1, node);
72         }
73     }
74     printf("create 100 nodes end\n----\n");
75     printf("first is : %d, last is: %d\n----\n",
76            NODE_T( ST_CALL_0(list, first), struct int_node )->id,
77            NODE_T( ST_CALL_0(list, last ), struct int_node )->id);
78
79     assert(list->size == 100);
80
81     printf("list traverse:\n");
82     for(i = 0; i < 100; i++)
83     {
84         if(i%10 == 0) printf("\n");
85         bn = list->at(list, i);
86         node = NODE_T(bn, struct int_node);
87         printf(" %d", node->id);
88     }
89     printf("\n-----\n");
90
91     printf("find by key test, key=42:\n");
92     bn = list->find_by_key(list, (void*)42);
93     assert(bn != 0);
94     node = NODE_T(bn, struct int_node);
95     printf("find node(key=42), %d\n------\n", node->id);
96
97     printf("remove node test, remove the 10th node:\n");
98     bn = list->at(list, 10);
99     node = NODE_T(bn, struct int_node);
100     printf("  node 10 is: %d\n", node->id);
101     printf("  now remove node 10\n");
102     list->remove_at(list, 10);
103     printf(" node 10 was removed, check node 10 again:\n");
104     bn = list->at(list, 10);
105     node = NODE_T(bn, struct int_node);
106     printf("  now node 10 is: %d\n------\n", node->id);
107
108     printf("replace test, replace node 12 with id 1200:\n");
109     bn = list->at(list, 12);
110     node = NODE_T(bn, struct int_node);
111     printf("  now node 12 is : %d\n", node->id);
112     node = (struct int_node*)malloc(sizeof(struct int_node));
113     node->id = 1200;
114     list->replace(list, 12, node);
115     bn = list->at(list, 12);
116     node = NODE_T(bn, struct int_node);
117     printf("  replaced, now node 12 is : %d\n----\n", node->id);
118
119     printf("test remove:\n");
120     ST_CALL(list, remove, bn);
121     bn = ST_CALL(list, find_by_key, (void*)1200);
122     assert(bn == 0);
123     printf("test remove ok\n----\n");
124     printf("test remove_by_key(90):\n");
125     ST_CALL(list, remove_by_key, (void*)90);
126     bn = ST_CALL(list, find_by_key, (void*)90);
127     assert(bn == 0);
128     printf("test remove_by_key(90) end\n----\n");
129     printf("test take_at(80):\n");
130     bn = ST_CALL(list, take_at, 80);
131     printf("  node 80 is: %d\n", NODE_T(bn, struct int_node)->id);
132     free(bn);
133     printf("test take_at(80) end\n");
134
135     int_free_flag = 0;
136     printf("delete list && nodes:\n");
137     list->deletor(list);
138     printf("delete list && nodes end\n");
139     printf("\n test add/insert/remove/delete/find_by_key/replace...\n");
140 }
141
142 void string_slist_test()
143 {
144     struct single_list * list = new_single_list(_string_child_free, _string_slist_hittest);
145 }
146
147 void slist_test()
148 {
149     int_slist_test();
150     string_slist_test();
151 }

测试代码里主要演示了：

自定义链表节点类型

定义释放回调

定义用于查找的 hit test 回调

如何创建链表

如何使用（ add 、remove 、 take 、find 、 insert 等）

相信到这里，单链表的使用已经不成问题了。

以单链表为基础，可以进一步实现很多数据结构，比如树（兄弟孩子表示法），比如 key-value 链表等等。接下来根据例子的需要，会择机进行展示。

转自：http://blog.csdn.net/foruok/article/details/18594177