双向链表基本操作

 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

      为了练习，我这次设置了哨兵结点，哨兵结点，我个人理解就是我们一般意义上的头结点（是链表的一个附加结点，数据域不存储任何信息的），只不过是链表的两端都放了一个，所以形象的称之为“哨兵”。所以和单链表的基本操作中一样，链表的有效结点应该从第二个开始。
      哨兵节点的引入的方便性在于不需要对线性表的第一个节点单独进行处理，比如在某个位置上插入一个节点，一般的方法是找到该位置上原来节点的前一个节点，然后将新节点加在后面，如果没有哨兵节点的话，当插入位置为线性表的第一个位置的时候，需要考虑该位置上原来的节点并没有前驱节点；而如果有哨兵节点的话，线性表的每个位置的节点都有前驱节点，因此可以统一处理。（注意：哨兵节点根本不出现在线性表中，所以虽然它没有前驱，但是前面的那句话并不矛盾）

上代码：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4.   
5.   
6. typedef struct _node {  
7.     void *data;  
8.     struct _node *prior;  
9.     struct _node *next;  
10. }NODE;  
11.   
12.   
13. typedef struct DoubleLinkList {  
14.     NODE *head;  
15.     NODE *last;  
16.     int length;  
17. }DLList;  
18.   
19.   
20. DLList *CreateList();                                        // 创建双链表  
21. int AppendList(DLList *l, void *data, int size);            // 在链表后追加结点  
22. int InsertList(DLList *l, int pos, void *data, int size);   // 在 pos 位置的元素前插入
23. // 删除位置为pos的结点，并用e返回被删除的结点数据    
24. int DeleteNode(DLList *l, int pos, void *e, int size);      
25. void PrintList(DLList *l, void (*printnode)(void *));      // 打印  
26. void ClearList(DLList *l);                                  // 清空链表  
27. void DestoryList(DLList **l);                               // 销毁链表  
28.   
29.   
30. double d[5] = {10.23, 34.23, 54.65, 122, 35.5};  
31.   
32.   
33. void PrintData(void *data)  
34. {  
35.   double *d = (double *)data;  
36.   printf("d = %lf\n",*d);  
37. }  
38.   
39.   
40. int main()  
41. {  
42.   int i;  
43.   double e;  
44.   DLList *list = CreateList();  
45.   for (i = 0; i < 4; ++i){  
46.     AppendList(list, &d[i], sizeof(d[i]));  
47.   }  
48.   PrintList(list,PrintData);  
49.   printf("\n\n");  
50.   
51.   InsertList(list, 2, &d[4], sizeof(d[4]));  
52.   PrintList(list,PrintData);  
53.   printf("\n\n");  
54.   
55.   DeleteNode(list, 1, &e, sizeof(double));  
56.   printf("被删除的元素是：");  
57.   printf("%lf\n\n",e);  
58.   
59.   DestoryList(&list);  
60.     if (NULL == list)  
61.     printf("list is NULL\n");  
62.   else  
63.     printf("list not NULL\n");  
64.     return 0;  
65. }  
66.   
67.   
68. // 创建双链表  
69. DLList *CreateList()  
70. {  
71.     DLList *l = (DLList *)malloc(sizeof(DLList));  
72.     if (NULL == l)  
73.         exit(0);  
74.       
75.     l->head = (NODE *)malloc(sizeof(NODE));               // 设置哨兵结点，可方便双链表的操作  
76.     if (NULL == l->head)  
77.         exit(0);  
78.     memset(l->head, 0, sizeof(NODE));  
79.   
80.     l->last = (NODE *)malloc(sizeof(NODE));  
81.     if (NULL == l->last)  
82.         exit(0);  
83.     memset(l->last, 0, sizeof(NODE));  
84.   
85.     l->head->next = l->last;  
86.     l->last->prior = l->head;  
87.     l->length = 0;  
88.     return l;  
89. }  
90.   
91.   
92. // 在链表后追加结点  
93. int AppendList(DLList *l, void *data, int size)  
94. {  
95.     NODE *p = NULL;  
96.   
97.     if (NULL == l || NULL == data)  
98.         return 0;  
99.   
100.     p = (NODE *)malloc(sizeof(NODE));  
101.     if (NULL == p)  
102.         return 0;  
103.   
104.     p->data = malloc(size);  
105.     if (NULL == p->data){  
106.         free(p);  
107.         return 0;  
108.     }  
109.     memcpy(p->data, data, size);  
110.       
111.     p->next = l->last;  
112.     p->prior = l->last->prior;  
113.     l->last->prior->next = p;  
114.     l->last->prior = p;  
115.     l->length++;  
116.     return 1;  
117. }  
118.   
119.   
120. // 在 pos 位置的元素前插入  
121. int InsertList(DLList *l, int pos, void *data, int size)  
122. {  
123.   NODE *p = NULL, *q = NULL;  
124.   int i = 0;  
125.   
126.   if (NULL == l || NULL == data || pos < 1 || pos > l->length)  
127.     return 0;  
128.   
129.   p = (NODE *)malloc(sizeof(NODE));  
130.   if (NULL == p)  
131.     return 0;  
132.   
133.   p->data = malloc(size);  
134.   if (NULL == p->data){  
135.     free(p);  
136.     return 0;  
137.   }  
138.   memcpy(p->data, data, size);  
139.   
140.   q = l->head;  
141.   while (i < pos - 1){  
142.     q = q->next;  
143.     ++i;  
144.   }  
145.   p->next = q->next;  
146.   q->next = p;  
147.   p->prior = q;  
148.   p->next->prior = p;  
149.   l->length++;  
150.   return 1;  
151. }  
152.   
153.   
154. // 删除位置为pos的结点，并用e返回被删除的结点数据  
155. int DeleteNode(DLList *l, int pos, void *e, int size)  
156. {  
157.   NODE *p = NULL, *q = NULL;  
158.   int i = 0;  
159.   
160.   if (NULL == l || pos < 1 || pos > l->length)  
161.     return 0;  
162.   p = l->head;  
163.   // 这里遍历到了pos位置的前一个结点，还可以直接遍历到pos位置的结点上，通过prior操作删除  
     
164.   while (i < pos - 1){            
165.     p = p->next;  
166.   }  
167.   q = p->next;  
168.   memcpy(e, q->data, size);  
169.     
170.   p->next = q->next;  
171.   q->next->prior = p;  
172.   free(q->data);  
173.   free(q);  
174.   l->length--;  
175.   return 1;  
176. }  
177.   
178.   
179. // 打印  
180. void PrintList(DLList *l, void (*printnode)(void *))  
181. {  
182.     NODE *p = NULL;  
183.     int i = 0;  
184.   
185.     if (NULL == l || NULL == printnode)  
186.         return;  
187.   
188.     p = l->head;  
189.     while (i < l->length){  
190.         p = p->next;  
191.         printnode(p->data);  
192.         ++i;  
193.     }  
194. }  
195.   
196.   
197. // 清空链表  
198. void ClearList(DLList *l)  
199. {  
200.   NODE *p = NULL;  
201.   
202.   if (NULL == l->head->next)  
203.     return;  
204.   p = l->head->next;  
205.   l->head->next = p->next;  
206.   free(p);  
207.   if (l->head->next != l->last)                 // 如果p的下一个结点不是尾结点，防止删掉尾结点  
208.     ClearList(l);                               // 这里用递归  
209. }  
210.   
211.   
212. // 销毁链表  
213. void DestoryList(DLList **l)  
214. {    
215.   DLList *p = *l;  
216.   if (NULL == p)  
217.     return;  
218.   
219.   ClearList(p);  
220.   free(p->head);            // 释放哨兵结点  
221.   free(p->last);  
222.   free(p);  
223.   *l = NULL;  
224. }