Linux 中的链表list 使用示例

转：http://www.cnblogs.com/westfly/archive/2011/04/07/2007549.html

学习链表的实现，还是觉得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 }