1 #include <stdio.h>
  2 #include <malloc.h>
  3 
  4 /**
  5  * C 語言實現的雙向連結串列，能儲存任意資料。
  6  *
  7  * @author skywang
  8  * @date 2013/11/07
  9  */
 10 // 雙向連結串列節點
 11 typedef struct tag_node 
 12 {
 13     struct tag_node *prev;
 14     struct tag_node *next;
 15     void* p;
 
 16 }node;
 17 
 18 // 表頭。注意，表頭不存放元素值！！！
 19 static node *phead=NULL;
 20 // 節點個數。
 21 static int  count=0;
 22 
 23 // 新建“節點”。成功，返回節點指標；否則，返回NULL。
 24 static node* create_node(void *pval)
 25 {
 26     node *pnode=NULL;
 27     pnode = (node *)malloc(sizeof(node));
 28     if (!pnode)
 29     {
 
 30         printf("create node error!\n");
 31         return NULL;
 32     }
 33     // 預設的，pnode的前一節點和後一節點都指向它自身
 34     pnode->prev = pnode->next = pnode;
 35     // 節點的值為pval
 36     pnode->p = pval;
 37 
 38     return pnode;
 39 }
 40 
 41 // 新建“雙向連結串列”。成功，返回0；否則，返回-1。
 42 int create_dlink()
 
 43 {
 44     // 建立表頭
 45     phead = create_node(NULL);
 46     if (!phead)
 47         return -1;
 48 
 49     // 設定“節點個數”為0
 50     count = 0;
 51 
 52     return 0;
 53 }
 54 
 55 // “雙向連結串列是否為空”
 56 int dlink_is_empty()
 57 {
 58     return count == 0;
 59 }
 60 
 61 // 返回“雙向連結串列的大小”
 62 int dlink_size() {
 63     return count;
 64 }
 65 
 66 // 獲取“雙向連結串列中第index位置的節點”
 67 static node* get_node(int index) 
 68 {
 69     if (index<0 || index>=count)
 70     {
 71         printf("%s failed! index out of bound!\n", __func__);
 72         return NULL;
 73     }
 74 
 75     // 正向查詢
 76     if (index <= (count/2))
 77     {
 78         int i=0;
 79         node *pnode=phead->next;
 80         while ((i++) < index) 
 81             pnode = pnode->next;
 82 
 83         return pnode;
 84     }
 85 
 86     // 反向查詢
 87     int j=0;
 88     int rindex = count - index - 1;
 89     node *rnode=phead->prev;
 90     while ((j++) < rindex) 
 91         rnode = rnode->prev;
 92 
 93     return rnode;
 94 }
 95 
 96 // 獲取“第一個節點”
 97 static node* get_first_node() 
 98 {
 99     return get_node(0);
100 }
101 
102 // 獲取“最後一個節點”
103 static node* get_last_node() 
104 {
105     return get_node(count-1);
106 }
107 
108 // 獲取“雙向連結串列中第index位置的元素”。成功，返回節點值；否則，返回-1。
109 void* dlink_get(int index)
110 {
111     node *pindex=get_node(index);
112     if (!pindex) 
113     {
114         printf("%s failed!\n", __func__);
115         return NULL;
116     }
117 
118     return pindex->p;
119 
120 }
121 
122 // 獲取“雙向連結串列中第1個元素的值”
123 void* dlink_get_first()
124 {
125     return dlink_get(0);
126 }
127 
128 // 獲取“雙向連結串列中最後1個元素的值”
129 void* dlink_get_last()
130 {
131     return dlink_get(count-1);
132 }
133 
134 // 將“pval”插入到index位置。成功，返回0；否則，返回-1。
135 int dlink_insert(int index, void* pval) 
136 {
137     // 插入表頭
138     if (index==0)
139         return dlink_insert_first(pval);
140 
141     // 獲取要插入的位置對應的節點
142     node *pindex=get_node(index);
143     if (!pindex) 
144         return -1;
145 
146     // 建立“節點”
147     node *pnode=create_node(pval);
148     if (!pnode)
149         return -1;
150 
151     pnode->prev = pindex->prev;
152     pnode->next = pindex;
153     pindex->prev->next = pnode;
154     pindex->prev = pnode;
155     // 節點個數+1
156     count++;
157 
158     return 0;
159 }
160 
161 // 將“pval”插入到表頭位置
162 int dlink_insert_first(void *pval) 
163 {
164     node *pnode=create_node(pval);
165     if (!pnode)
166         return -1;
167 
168     pnode->prev = phead;
169     pnode->next = phead->next;
170     phead->next->prev = pnode;
171     phead->next = pnode;
172     count++;
173     return 0;
174 }
175 
176 // 將“pval”插入到末尾位置
177 int dlink_append_last(void *pval) 
178 {
179     node *pnode=create_node(pval);
180     if (!pnode)
181         return -1;
182     
183     pnode->next = phead;
184     pnode->prev = phead->prev;
185     phead->prev->next = pnode;
186     phead->prev = pnode;
187     count++;
188     return 0;
189 }
190 
191 // 刪除“雙向連結串列中index位置的節點”。成功，返回0；否則，返回-1。
192 int dlink_delete(int index)
193 {
194     node *pindex=get_node(index);
195     if (!pindex) 
196     {
197         printf("%s failed! the index in out of bound!\n", __func__);
198         return -1;
199     }
200 
201     pindex->next->prev = pindex->prev;
202     pindex->prev->next = pindex->next;
203     free(pindex);
204     count--;
205 
206     return 0;
207 }    
208 
209 // 刪除第一個節點
210 int dlink_delete_first() 
211 {
212     return dlink_delete(0);
213 }
214 
215 // 刪除組後一個節點
216 int dlink_delete_last() 
217 {
218     return dlink_delete(count-1);
219 }
220 
221 // 撤銷“雙向連結串列”。成功，返回0；否則，返回-1。
222 int destroy_dlink()
223 {
224     if (!phead)
225     {
226         printf("%s failed! dlink is null!\n", __func__);
227         return -1;
228     }
229 
230     node *pnode=phead->next;
231     node *ptmp=NULL;
232     while(pnode != phead)
233     {
234         ptmp = pnode;
235         pnode = pnode->next;
236         free(ptmp);
237     }
238 
239     free(phead);
240     phead = NULL;
241     count = 0;
242 
243     return 0;
244 }