Linux 中的链表list 使用示例

学习链表的实现，还是觉得linux下的显得不错。

今天爬取了份可以用在linux下的代码。不必要重复造轮子了。对于这份代码的详细说明，请参考 《Linux Kernel Linked List Explained》

如下代码的获取路径

http://isis.poly.edu/kulesh/stuff/src/klist/list.h

list.h

1 #ifndef __LIST_H
2 #define __LIST_H
3
4 /* This file is from Linux Kernel (include/linux/list.h)
5 * and modified by simply removing hardware prefetching of list items.
6 * Here by copyright, credits attributed to wherever they belong.
7 * Kulesh Shanmugasundaram (kulesh [squiggly] isis.poly.edu)
8 */
9
10 /*
11 * Simple doubly linked list implementation.
12 *
13 * Some of the internal functions (“__xxx”) are useful when
14 * manipulating whole lists rather than single entries, as
15 * sometimes we already know the next/prev entries and we can
16 * generate better code by using them directly rather than
17 * using the generic single-entry routines.
18 */
19
20 struct list_head {
21 struct list_head * next, * prev;
22 };
23
24 #define LIST_HEAD_INIT(name) { &(name), &(name) }
25
26 #define LIST_HEAD(name) \
27 struct list_head name = LIST_HEAD_INIT(name)
28
29 static inline void INIT_LIST_HEAD( struct list_head * list)
30 {
31 list -> next = list;
32 list -> prev = list;
33 }
34 /*
35 * Insert a new entry between two known consecutive entries.
36 *
37 * This is only for internal list manipulation where we know
38 * the prev/next entries already!
39 */
40 static inline void __list_add( struct list_head * new ,
41 struct list_head * prev,
42 struct list_head * next)
43 {
44 next -> prev = new ;
45 new -> next = next;
46 new -> prev = prev;
47 prev -> next = new ;
48 }
49
50 /* *
51 * list_add – add a new entry
52 * @new: new entry to be added
53 * @head: list head to add it after
54 *
55 * Insert a new entry after the specified head.
56 * This is good for implementing stacks.
57 */
58 static inline void list_add( struct list_head * new , struct list_head * head)
59 {
60 __list_add( new , head, head -> next);
61 }
62
63 /* *
64 * list_add_tail – add a new entry
65 * @new: new entry to be added
66 * @head: list head to add it before
67 *
68 * Insert a new entry before the specified head.
69 * This is useful for implementing queues.
70 */
71 static inline void list_add_tail( struct list_head * new , struct list_head * head)
72 {
73 __list_add( new , head -> prev, head);
74 }
75
76 /*
77 * Delete a list entry by making the prev/next entries
78 * point to each other.
79 *
80 * This is only for internal list manipulation where we know
81 * the prev/next entries already!
82 */
83 static inline void __list_del( struct list_head * prev, struct list_head * next)
84 {
85 next -> prev = prev;
86 prev -> next = next;
87 }
88
89 /* *
90 * list_del – deletes entry from list.
91 * @entry: the element to delete from the list.
92 * Note: list_empty on entry does not return true after this, the entry is in an undefined state.
93 */
94 static inline void list_del( struct list_head * entry)
95 {
96 __list_del(entry -> prev, entry -> next);
97 entry -> next = ( void * ) 0 ;
98 entry -> prev = ( void * ) 0 ;
99 }
100
101 /* *
102 * list_del_init – deletes entry from list and reinitialize it.
103 * @entry: the element to delete from the list.
104 */
105 static inline void list_del_init( struct list_head * entry)
106 {
107 __list_del(entry -> prev, entry -> next);
108 INIT_LIST_HEAD(entry);
109 }
110
111 /* *
112 * list_move – delete from one list and add as another’s head
113 * @list: the entry to move
114 * @head: the head that will precede our entry
115 */
116 static inline void list_move( struct list_head * list, struct list_head * head)
117 {
118 __list_del(list -> prev, list -> next);
119 list_add(list, head);
120 }
121
122 /* *
123 * list_move_tail – delete from one list and add as another’s tail
124 * @list: the entry to move
125 * @head: the head that will follow our entry
126 */
127 static inline void list_move_tail( struct list_head * list,
128 struct list_head * head)
129 {
130 __list_del(list -> prev, list -> next);
131 list_add_tail(list, head);
132 }
133
134 /* *
135 * list_empty – tests whether a list is empty
136 * @head: the list to test.
137 */
138 static inline int list_empty( struct list_head * head)
139 {
140 return head -> next == head;
141 }
142
143 static inline void __list_splice( struct list_head * list,
144 struct list_head * head)
145 {
146 struct list_head * first = list -> next;
147 struct list_head * last = list -> prev;
148 struct list_head * at = head -> next;
149
150 first -> prev = head;
151 head -> next = first;
152
153 last -> next = at;
154 at -> prev = last;
155 }
156
157 /* *
158 * list_splice – join two lists
159 * @list: the new list to add.
160 * @head: the place to add it in the first list.
161 */
162 static inline void list_splice( struct list_head * list, struct list_head * head)
163 {
164 if ( ! list_empty(list))
165 __list_splice(list, head);
166 }
167
168 /* *
169 * list_splice_init – join two lists and reinitialise the emptied list.
170 * @list: the new list to add.
171 * @head: the place to add it in the first list.
172 *
173 * The list at @list is reinitialised
174 */
175 static inline void list_splice_init( struct list_head * list,
176 struct list_head * head)
177 {
178 if ( ! list_empty(list)) {
179 __list_splice(list, head);
180 INIT_LIST_HEAD(list);
181 }
182 }
183
184 /* *
185 * list_entry – get the struct for this entry
186 * @ptr: the &struct list_head pointer.
187 * @type: the type of the struct this is embedded in.
188 * @member: the name of the list_struct within the struct.
189 */
190 #define list_entry(ptr, type, member) \
191 ((type * )(( char * )(ptr) - (unsigned long )( & ((type * ) 0 ) -> member)))
192
193 /* *
194 * list_for_each - iterate over a list
195 * @pos: the &struct list_head to use as a loop counter.
196 * @head: the head for your list.
197 */
198 #define list_for_each(pos, head) \
199 for (pos = (head) -> next; pos != (head); \
200 pos = pos -> next)
201 /* *
202 * list_for_each_prev - iterate over a list backwards
203 * @pos: the &struct list_head to use as a loop counter.
204 * @head: the head for your list.
205 */
206 #define list_for_each_prev(pos, head) \
207 for (pos = (head) -> prev; pos != (head); \
208 pos = pos -> prev)
209
210 /* *
211 * list_for_each_safe - iterate over a list safe against removal of list entry
212 * @pos: the &struct list_head to use as a loop counter.
213 * @n: another &struct list_head to use as temporary storage
214 * @head: the head for your list.
215 */
216 #define list_for_each_safe(pos, n, head) \
217 for (pos = (head) -> next, n = pos -> next; pos != (head);\
218 pos = n, n = pos -> next)
219
220
221 /* *
222 * list_for_each_entry - iterate over list of given type
223 * @pos: the type * to use as a loop counter.
224 * @head: the head for your list.
225 * @member: the name of the list_struct within the struct.
226 */
227 #define list_for_each_entry(pos, head, member) \
228 for (pos = list_entry((head) -> next, typeof ( * pos), member); \
229 & pos -> member != (head); \
230 pos = list_entry(pos -> member.next, typeof ( * pos), member))
231
232 /* *
233 * list_for_each_entry_safe – iterate over list of given type safe against removal of list entry
234 * @pos: the type * to use as a loop counter.
235 * @n: another type * to use as temporary storage
236 * @head: the head for your list.
237 * @member: the name of the list_struct within the struct.
238 */
239 #define list_for_each_entry_safe(pos, n, head, member) \
240 for (pos = list_entry((head) -> next, typeof ( * pos), member), \
241 n = list_entry(pos -> member.next, typeof ( * pos), member); \
242 & pos -> member != (head); \
243 pos = n, n = list_entry(n -> member.next, typeof ( * n), member))
244
245 #endif

下面代码是给出的测试用例（也可以作为其函数的用法示例哦）

其可以从http://isis.poly.edu/kulesh/stuff/src/klist/test_list.c 下载

mylist.c

1 #include < stdio.h >
2 #include < stdlib.h >
3
4 #include " list.h "
5
6
7 struct kool_list{
8 int to;
9 struct list_head list;
10 int from;
11 };
12
13 int main( int argc, char ** argv){
14
15 struct kool_list * tmp;
16 struct list_head * pos, * q;
17 unsigned int i;
18
19 struct kool_list mylist;
20 INIT_LIST_HEAD( & mylist.list);
21 /* or you could have declared this with the following macro
22 * LIST_HEAD(mylist); which declares and initializes the list
23 */
24
25 /* adding elements to mylist */
26 for (i = 5 ; i != 0 ; -- i){
27 tmp = ( struct kool_list * )malloc( sizeof ( struct kool_list));
28
29 /* INIT_LIST_HEAD(&tmp->list);
30 *
31 * this initializes a dynamically allocated list_head. we
32 * you can omit this if subsequent call is add_list() or
33 * anything along that line because the next, prev
34 * fields get initialized in those functions.
35 */
36 printf( " enter to and from: " );
37 scanf( " %d %d " , & tmp -> to, & tmp -> from);
38
39 /* add the new item 'tmp' to the list of items in mylist */
40 list_add( & (tmp -> list), & (mylist.list));
41 /* you can also use list_add_tail() which adds new items to
42 * the tail end of the list
43 */
44 }
45 printf( " \n " );
46
47
48 /* now you have a circularly linked list of items of type struct kool_list.
49 * now let us go through the items and print them out
50 */
51
52
53 /* list_for_each() is a macro for a for loop.
54 * first parameter is used as the counter in for loop. in other words, inside the
55 * loop it points to the current item's list_head.
56 * second parameter is the pointer to the list. it is not manipulated by the macro.
57 */
58 printf( " traversing the list using list_for_each()\n " );
59 list_for_each(pos, & mylist.list){
60
61 /* at this point: pos->next points to the next item's 'list' variable and
62 * pos->prev points to the previous item's 'list' variable. Here item is
63 * of type struct kool_list. But we need to access the item itself not the
64 * variable 'list' in the item! macro list_entry() does just that. See "How
65 * does this work?" below for an explanation of how this is done.
66 */
67 tmp = list_entry(pos, struct kool_list, list);
68
69 /* given a pointer to struct list_head, type of data structure it is part of,
70 * and it's name (struct list_head's name in the data structure) it returns a
71 * pointer to the data structure in which the pointer is part of.
72 * For example, in the above line list_entry() will return a pointer to the
73 * struct kool_list item it is embedded in!
74 */
75
76 printf( " to= %d from= %d\n " , tmp -> to, tmp -> from);
77
78 }
79 printf( " \n " );
80 /* since this is a circularly linked list. you can traverse the list in reverse order
81 * as well. all you need to do is replace 'list_for_each' with 'list_for_each_prev'
82 * everything else remain the same!
83 *
84 * Also you can traverse the list using list_for_each_entry() to iterate over a given
85 * type of entries. For example:
86 */
87 printf( " traversing the list using list_for_each_entry()\n " );
88 list_for_each_entry(tmp, & mylist.list, list){
89 printf( " to= %d from= %d\n " , tmp -> to, tmp -> from);
90 }
91 list_for_each_entry(tmp, & mylist.list,list){
92 if (tmp -> to == 2 )
93 break ;
94 }
95 printf( " to = %d from %d\n " ,tmp -> to,tmp -> from);
96 printf( " \n " );
97
98
99 /* now let's be good and free the kool_list items. since we will be removing items
100 * off the list using list_del() we need to use a safer version of the list_for_each()
101 * macro aptly named list_for_each_safe(). Note that you MUST use this macro if the loop
102 * involves deletions of items (or moving items from one list to another).
103 */
104 printf( " deleting the list using list_for_each_safe()\n " );
105 list_for_each_safe(pos, q, & mylist.list){
106 tmp = list_entry(pos, struct kool_list, list);
107 printf( " freeing item to= %d from= %d\n " , tmp -> to, tmp -> from);
108 list_del(pos);
109 free(tmp);
110 }
111
112 return 0 ;
113 }

编译测试

gcc mylist.c

转载于:https://www.cnblogs.com/westfly/archive/2011/04/07/2007549.html