通用双向链表的C语言实现

双向链表是一种基本的数据结构，在许多场合都会使用到。最近正在编写一个基于Linux的GUI系统，里边许多地方都要使用到双向链表，于是写了一个通用的双向链表。代码如下：

1. #ifndef __STDLIST_H__
2. #define __STDLIST_H__
4. typedef struct tagSTDNODE       STDNODE, *LPSTDNODE;
5. typedef struct tagSTDLIST       STDLIST, *LPSTDLIST;
7. // 链表数据结构
8. struct tagSTDNODE {
9.     LPSTDNODE           lpPrev;
10.     LPSTDNODE           lpNext;
11. };
13. // 链表节点结构
14. struct tagSTDLIST {
15.     LPSTDNODE           lpHead;
16.     LPSTDNODE           lpTail;
17. };
19. // 用于链表扩展的宏
20. #define NODE_INITIALIZER    ((STDNODE){ .lpPrev = NULL, .lpNext = NULL, })
21. #define LIST_INITIALIZER    ((STDLIST){ .lpHead = NULL, .lpTail = NULL, })
22. #define DECLARELISTNODE()　　STDNODE __snStdNode
23. #define INIT_LISTNODE()     __snStdNode = NODE_INITIALIZER
25. // 初始化链表
26. STATIC INLINE
27. LPSTDLIST       TWINAPI     StdListInit(
28.                             LPSTDLIST lpList
29.                             ) {
30.     lpList->lpHead  = NULL;
31.     lpList->lpTail  = NULL;
32.     return lpList;
33. }
35. // 获取链表头部节点
36. STATIC INLINE
37. LPSTDNODE       TWINAPI     StdListGetHeadNode(
38.                             LPSTDLIST lpList
39.                             ) {
40.     return lpList->lpHead;
41. }
43. // 获取链表尾部节点
44. STATIC INLINE
45. LPSTDNODE       TWINAPI     StdListGetTailNode(
46.                             LPSTDLIST lpList
47.                             ) {
48.     return lpList->lpTail;
49. }
51. // 获取给定节点的下一个节点
52. STATIC INLINE
53. LPSTDNODE       TWINAPI     StdListGetNextNode(
54.                             LPSTDNODE lpNode
55.                             ) {
56.     return lpNode->lpNext;
57. }
59. // 获取给定节点的上一个节点
60. STATIC INLINE
61. LPSTDNODE       TWINAPI     StdListGetPrevNode(
62.                             LPSTDNODE lpNode
63.                             ) {
64.     return lpNode->lpPrev;
65. }
67. // 在链表头部插入一个节点
68. STATIC INLINE
69. VOID            TWINAPI     StdListPushFront(
70.                             LPSTDLIST lpList,
71.                             LPSTDNODE lpNode
72.                             ) {
73.     lpNode->lpPrev  = NULL;
74.     lpNode->lpNext  = lpList->lpHead;
75.     if(lpList->lpHead)
76.         lpList->lpHead->lpPrev  = lpNode;
77.     else
78.         lpList->lpTail  = lpNode;
79.     lpList->lpHead  = lpNode;
80. }
82. // 在链表尾部插入一个节点
83. STATIC INLINE
84. VOID            TWINAPI     StdListPushBack(
85.                             LPSTDLIST lpList,
86.                             LPSTDNODE lpNode
87.                             ) {
88.     lpNode->lpNext  = NULL;
89.     lpNode->lpPrev  = lpList->lpTail;
90.     if(lpList->lpTail)
91.         lpList->lpTail->lpNext  = lpNode;
92.     else
93.         lpList->lpHead  = lpNode;
94.     lpList->lpTail  = lpNode;
95. }
97. // 在指定节点后插入一个节点
98. STATIC INLINE
99. VOID            TWINAPI     StdListInsert(
100.                             LPSTDLIST lpList,
101.                             LPSTDNODE lpAfter,
102.                             LPSTDNODE lpNode
103.                             ) {
104.     if(lpAfter) {
105.         if(lpAfter->lpNext)
106.             lpAfter->lpNext->lpPrev = lpNode;
107.         else
108.             lpList->lpTail  = lpNode;
109.         lpNode->lpPrev  = lpAfter;
110.         lpNode->lpNext  = lpAfter->lpNext;
111.         lpAfter->lpNext = lpNode;
112.     } else {
113.         StdListPushFront(lpList, lpNode);
114.     }
115. }
117. // 从链表头部弹出一个节点
118. STATIC INLINE
119. LPSTDNODE       TWINAPI     StdListPopFront(
120.                             LPSTDLIST lpList
121.                             ) {
122.     if(lpList->lpHead) {
123.         LPSTDNODE lpNode    = lpList->lpHead;
124.         if(lpList->lpHead->lpNext)
125.             lpList->lpHead->lpNext->lpPrev  = NULL;
126.         else
127.             lpList->lpTail  = NULL;
128.         lpList->lpHead  = lpList->lpHead->lpNext;
129.         lpNode->lpPrev  = lpNode->lpNext    = NULL;
130.         return lpNode;
131.     } else {
132.         return NULL;
133.     }
134. }
136. // 从链表尾部弹出一个节点
137. STATIC INLINE
138. LPSTDNODE       TWINAPI     StdListPopBack(
139.                             LPSTDLIST lpList
140.                             ) {
141.     if(lpList->lpTail) {
142.         LPSTDNODE lpNode    = lpList->lpTail;
143.         if(lpList->lpTail->lpPrev)
144.             lpList->lpTail->lpPrev->lpNext  = NULL;
145.         else
146.             lpList->lpHead  = NULL;
147.         lpList->lpTail  = lpList->lpTail->lpPrev;
148.         lpNode->lpPrev  = lpNode->lpNext    = NULL;
149.         return lpNode;
150.     } else {
151.         return NULL;
152.     }
153. }
155. // 从链表中删除给定节点
156. STATIC INLINE
157. LPSTDNODE       TWINAPI     StdListRemove(
158.                             LPSTDLIST lpList,
159.                             LPSTDNODE lpNode
160.                             ) {
161.     if(lpNode->lpPrev)
162.         lpNode->lpPrev->lpNext  = lpNode->lpNext;
163.     else
164.         lpList->lpHead  = lpNode->lpNext;
165.     if(lpNode->lpNext)
166.         lpNode->lpNext->lpPrev  = lpNode->lpPrev;
167.     else
168.         lpList->lpTail  = lpNode->lpPrev;
169.     return lpNode;
170. }
172. // 检查链表是否为空
173. STATIC INLINE
174. BOOL            TWINAPI     StdListIsEmpty(
175.                             LPSTDLIST lpList
176.                             ) {
177.     if(lpList->lpHead || lpList->lpTail)
178.         return FALSE;
179.     else
180.         return TRUE;
181. }
183. // 获取链表中的节点数
184. STATIC INLINE
185. LONG            TWINAPI     StdListGetSize(
186.                             LPSTDLIST lpList
187.                             ) {
188.     LONG lnSize = 0;
189.     LPSTDNODE lpNode    = StdListGetHeadNode(lpList);
190.     while(lpNode) {
191.         ++ lnSize;
192.         lpNode  = StdListGetNextNode(lpNode);
193.     }
194.     return lnSize;
195. }
197. // 合并两个链表
198. STATIC INLINE
199. LPSTDLIST       TWINAPI     StdListCombine(
200.                             LPSTDLIST lpList1,
201.                             LPSTDLIST lpList2
202.                             ) {
203.     if(!StdListIsEmpty(lpList2)) {
204.         if(!StdListIsEmpty(lpList1)) {
205.             lpList1->lpTail->lpNext = lpList2->lpHead;
206.             lpList2->lpHead->lpPrev = lpList1->lpTail;
207.             lpList1->lpTail = lpList2->lpTail;
208.         } else {
209.             lpList1->lpHead = lpList2->lpHead;
210.             lpList1->lpTail = lpList2->lpTail;
211.         }
212.         lpList2->lpHead = lpList2->lpTail   = NULL;
213.     }
214.     return lpList1;
215. }
217. #endif//__STDLIST_H__

算法本身没有什么特别的地方，为什么说这是一个通用双向链表呢？奥妙就在那四个用于扩展的宏。利用这几个宏你可以将这个双向链表扩展到任意结构。

例如，我们要实现一个消息队列，那么我们可以这样定义消息节点：

1. typedef struct tagMSGNODE {
2.     DECLARELISTNODE();
3.     HWND        hWnd;
4.     UINT        uMsg;
5.     WPARAM      wParam;
6.     LPARAM      lParam;
7. } MSGNODE, *LPMSGNODE;

而消息队列则可以直接用LISTNODE结构来表示：

1. STDLIST     lstMsgQueue;

这样我们就可以用刚刚定义的函数来对这个消息队列进行操作了：

1. // 向消息队列插入一个消息
2. LPMSGNODE lpMsgNode = MemAlloc(SIZEOF(MSGNODE));
3. lpMsgNode->INIT_LISTNODE();
4. lpMsgNode->hWnd     = hWnd;
5. lpMsgNode->uMsg     = WM_PAINT;
6. lpMsgNode->wParam   = NULL;
7. lpMsgNode->lParam   = NULL;
8. StdListPushBack(&lstMsgQueue, (LPSTDNODE)lpMsgNode);
10. // 从消息队列取出一个消息
11. LPMSGNODE lpMsgNode = (LPMSGNODE)StdListPopFront(&lstMsgQueue);
13. // 删除所有属于hWnd的消息
14. LPMSGNODE lpTemp    = (LPMSGNODE)StdListGetHeadNode(&lstMsgQueue);
15. while(lpTemp) {
16.     LPMSGNODE lpNext    = (LPMSGNODE)StdListGetNextNode(&lstMsgQueue, (LPSTDNODE)lpTemp);
17.     if(lpTemp->hWnd == hWnd) {
18.         StdListRemove(&lstMsgQueue, (LPSTDNODE)lpTemp);
19.                 MemFree(lpTemp);
20.         }
21.     lpTemp  = lpNext;
22. }

是不是很方便呢^_^。

 

备注：

由于正在编写的GUI是参考Windows的体系结构，所以代码风格采用了微软的风格。

代码中的MemAlloc,MemFree函数以及各种数据结构均在其他地方定义。