線性表儲存結構分為順序儲存、鏈式儲存。

       順序儲存的優點：

       順序儲存的缺點：

       連結串列就是典型的鏈式儲存，將線性表L = （a0,a1,a2,........an-1）中個元素分佈在儲存器的不同儲存塊，成為結點（Node），通過地址或指標建立他們之間的練習，所得到的儲存結構為連結串列結構。表中元素ai的結點形式如下：

其中，結點的data域存放資料元素ai,而next域是一個指標，指向ai的直接後繼a(i+1)所在的結點。於是，線性表L=（a0,a1,......an-1）的結構如圖：

 

一、節點型別描述：

[cpp] view plain copy

1. typedef struct node_t  
2. {  
3.     data_t data; //節點的資料域  
4.     struct node_t *next;//節點的後繼指標域  
5. }linknode_t,*linklist_t;  

也可這樣表示：

[cpp] view plain copy

1. struct node_t  
2. {  
3.     data_t data;   
4.     struct node_t *next;  
5. }  
6. typedef struct node_t linknode_t;  
7. typedef struct node_t *linklist_t;  

若說明

linknode_t  A;

linklist_t p  = &A;

則結構變數A為所描述的節點，而指標變數P為指向此型別節點的指標（p的值為節點的地址）；

這樣看來 linknode_t  linklist_t 的作用是一樣的，那為什麼我們要定義兩個資料型別（同一種）呢？主要為了程式碼的可讀性，我們要求識別符號要望文識義，便於理解；

1、linknode_t  *pnode  指向一個節點；

2、linklist_t list  指向一個整體

二、頭結點 head

        我們在前篇提到的順序儲存線性表，如何表達一個空表{ }，是通過list->last = -1來表現的，所謂的空表就是資料域為NULL，而我們的連結串列有資料域和指標域，我們如何表現空連結串列呢？這時，就引入了頭結點的概念，頭結點和其他節點資料型別一樣，只是資料域為NULL，head->next = NULL，下面我們看一個建立空連結串列的函式，如何利用頭結點來建立一個空連結串列：

[cpp] view plain copy

1. linklist_t CreateEmptyLinklist()  
2. {  
3.     linklist_t list;  
4.   
5.     list = (linklist_t)malloc(sizeof(linknode_t));  
6.     if (NULL != list) {  
7.         list->next = NULL;  
8.     }  
9.     return list;  
10. }  

只要頭結點，連結串列就還在！

 

三、連結串列基本運算的相關演算法

         連結串列的運算除了上面的建立空連結串列，還有資料的插入，刪除，查詢等函式，連結串列的運算有各種實現方法，如何寫出一個高效的，封裝性較好的函式是我們要考慮的，比如資料插入函式，我們就要儘可能考慮所有能出現的結果，比如：1）如果需插入資料的連結串列是個空表；2）所插入的位置超過了連結串列的長度；如果我們的函式能包含所有能出現的情況，不僅能大大提高我們的開發效率，也會減少程式碼的錯誤率。下面，我們來看看下面的這個連結串列的插入函式的實現：

[cpp] view plain copy

1. int InsertLinklist(linklist_t list, int at, data_t x)  
2. {  
3.     linknode_t *node_prev, *node_at, *node_new;  
4.     int pos_at;  
5.     int found = 0;  
6.   
7.     if (NULL == list) return -1;  
8.   
9.     /* at must >= 0  */  
10.     if (at < 0) return -1;  
11.       
12.     /*第一步、分配空間*/  
13.     node_new = malloc(sizeof(linknode_t));  
14.     if (NULL == node_new)   
15.     {  
16.         return -1;  
17.     }  
18.     node_new->data = x; /* assigned value */  
19.     node_new->next = NULL; /*節點如果插入超過連結串列長度的位置，會接到尾節點後面，這樣，node_new成了尾節點，node_new->next = NULL */  
20.   
21.     /*第二步、定位*/  
22.     node_prev = list;//跟隨指標，幫助我們更好的定位  
23.     node_at = list->next; //遍歷指標  
24.     pos_at = 0;  
25.     while (NULL != node_at)   
26.     {  
27.         if (pos_at == at)  
28.         {  
29.             found = 1; //找到正確的位置，跳出迴圈  
30.             break;            
31.         }  
32.   
33.         /* move to the next pos_at */  
34.         node_prev = node_at; //跟隨指標先跳到遍歷指標的位置  
35.         node_at = node_at->next;//遍歷指標跳到下一個節點的位置  
36.         pos_at++;  
37.     }  
38.   
39.     /*第三步、插入*/    
40.     if (found)   
41.     {  
42.         /* found = 1,找到正確的位置，插入  */  
43.         node_new->next = node_at;//插入的節點next指向node_at  
44.         node_prev->next = node_new;//插入節點的前一個節點  
45.     }   
46.     else   
47.     {  
48.         /*若是沒找到正確的位置，即所插入位置超越了連結串列的長度，則接到尾節點的後面，同樣，這樣適用於{ }即空連結串列，這樣我們可以建立一個空連結串列，利用這個函式，實現連結串列的初始化*/  
49.         node_prev->next = node_new;  
50.     }  
51.       

這個插入函式可利用性就非常高。

 

下面講一個完整連結串列程式碼貼出：

listlink.h

[cpp] view plain copy

1. #ifndef _LNK_LIST_H_  
2. #define _LNK_LIST_H_  
3.   
4. typedef int data_t;  
5.   
6. typedef struct node_t {  
7.     data_t data;  
8.     struct node_t *next;  
9. } linknode_t, *linklist_t;  
10.   
11. linklist_t CreateEmptyLinklist();  
12.   
13. void DestroyLinklist(linklist_t list);  
14.   
15. void ClearLinklist(linklist_t list);  
16.   
17. int EmptyLinklist(linklist_t list);  
18.   
19. int LengthLinklist(linklist_t list);  
20.   
21. int GetLinklist(linklist_t list, int at, data_t *x);  
22.   
23. int SetLinklist(linklist_t list, int at, data_t x);  
24.   
25. int InsertLinklist(linklist_t list, int at, data_t x);  
26.   
27. int DeleteLinklist(linklist_t list, int at);  
28.   
29. linklist_t ReverseLinklist(linklist_t list);  
30.   
31. #endif /* _LNK_LIST_H_ */  

linklist.c

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include "linklist.h"  
4.   
5. linklist_t CreateEmptyLinklist()  
6. {  
7.     linklist_t list;  
8.     list = (linklist_t)malloc(sizeof(linknode_t));  
9.   
10.     if (NULL != list) {  
11.         list->next = NULL;  
12.     }  
13.   
14.     return list;  
15. }  
16.   
17. void DestroyLinklist(linklist_t list)  
18. {  
19.     if (NULL != list) {  
20.         ClearLinklist(list);  
21.         free(list);  
22.     }  
23. }  
24.   
25. void ClearLinklist(linklist_t list)  
26. {  
27.     linknode_t *node; /* pointer to the node to be removed */  
28.     if (NULL == list) return;  
29.   
30.     while (NULL != list->next) {  
31.         node = list->next;  
32.         list->next = node->next;  
33.         free(node);  
34.     }  
35.     return;  
36. }  
37.   
38. int LengthLinklist(linklist_t list)  
39. {  
40.     int len = 0;  
41.     linknode_t *node; //iterate pointer  
42.   
43.     if (NULL == list) return -1;  
44.   
45.     node = list->next; // node points to the first data node  
46.     while (NULL != node) {  
47.         len++;  
48.         node = node->next;  
49.     }  
50.     return len;  
51. }  
52.   
53. int EmptyLinklist(linklist_t list)  
54. {  
55.     if (NULL != list) {  
56.         if (NULL == list->next) {  
57.             return 1;  
58.         } else {  
59.             return 0;  
60.         }  
61.     } else {  
62.         return -1;  
63.     }  
64. }  
65.   
66. int GetLinklist(linklist_t list, int at, data_t *x)  
67. {  
68.     linknode_t *node;   /* used for iteration */  
69.     int pos;        /* used for iteration and compare with */  
70.   
71.     if (NULL == list) return -1;  
72.     /* at must >= 0 */  
73.     if (at < 0) return -1;  
74.     /* start from the first element */  
75.     node = list->next;  
76.     pos = 0;  
77.     while (NULL != node) {  
78.         if (at == pos) {  
79.             if (NULL != x) {  
80.                 *x = node->data;  
81.             }  
82.             return 0;             
83.         }  
84.         /* move to the next */  
85.         node = node->next;  
86.         pos++;  
87.     }  
88.     return -1;  
89. }  
90.   
91.   
92.   
93. int SetLinklist(linklist_t list, int at, data_t x)  
94. {  
95.     linknode_t *node; /* used for iteration */  
96.     int pos;  
97.     int found = 0;  
98.   
99.     if (!list) return -1;  
100.     /* at must >= 0 */  
101.     if (at < 0) return -1;  
102.     /* start from the first element */  
103.     node = list->next;  
104.     pos = 0;  
105.     while (NULL != node) {  
106.         if (at == pos) {   
107.             found = 1; /* found the position */  
108.             node->data = x;  
109.             break;            
110.         }  
111.         /* move to the next */  
112.         node = node->next;  
113.         pos++;  
114.     }  
115.     if (1 == found) {  
116.         return 0;  
117.     } else {  
118.         return -1;  
119.     }  
120. }  
121.   
122. int InsertLinklist(linklist_t list, int at, data_t x)  
123. {  
124.     /*  
125.      * node_at and pos_at are used to locate the position of node_at. 
126.      * node_prev follows the node_at and always points to previous node  
127.      *  of node_at. 
128.      * node_new is used to point to the new node to be inserted. 
129.      */  
130.     linknode_t  *node_prev, *node_at, *node_new;  
131.     int     pos_at;  
132.     int         found = 0;  
133.   
134.     if (NULL == list) return -1;  
135.   
136.     /* at must >= 0 */  
137.     if (at < 0) return -1;  
138.   
139.     node_new = malloc(sizeof(linknode_t));  
140.     if (NULL == node_new) {  
141.         return -1;  
142.     }  
143.     node_new->data = x; /* assigned value */  
144.     node_new->next = NULL;  
145.   
146.     node_prev = list;  
147.     node_at = list->next;  
148.     pos_at = 0;  
149.     while (NULL != node_at) {  
150.         if (pos_at == at) {  
151.             /*  
152.              * found the node 'at' 
153.              */   
154.             found = 1;  
155.             break;            
156.         }  
157.         /* move to the next pos_at */  
158.         node_prev = node_at;  
159.         node_at = node_at->next;  
160.         pos_at++;  
161.     }  
162.       
163.     if (found) {  
164.         /* insert */  
165.         node_new->next = node_at;  
166.         node_prev->next = node_new;  
167.     } else {  
168.         /*  
169.          * If not found, means the provided "at" 
170.          * exceeds the upper limit of the list, just  
171.          * append the new node to the end of the list. 
172.          */  
173.         node_prev->next = node_new;  
174.     }  
175.     return 0;  
176. }  
177.   
178. int DeleteLinklist(linklist_t list, int at)  
179. {  
180.     /*  
181.      * node_at and pos_at are used to locate the position of node_at. 
182.      * node_prev follows the node_at and always points to previous node  
183.      *  of node_at. 
184.      */  
185.   
186.     linknode_t  *node_prev, *node_at;  
187.     int     pos_at;  
188.     int         found = 0;  
189.   
190.     if (!list) return -1;  
191.     /* at must >= 0 */  
192.     if (at < 0) return -1;  
193.   
194.     node_prev = list;  
195.     node_at = list->next;  
196.     pos_at = 0;   
197.   
198.     while (NULL != node_at) {  
199.         if (pos_at == at) {  
200.             /*  
201.              * found the node 'at' 
202.              */   
203.             found = 1;  
204.             break;            
205.         }  
206.         /* move to the next pos_at */  
207.         node_prev = node_at;  
208.         node_at = node_at->next;  
209.         pos_at++;  
210.     }  
211.     if (found) {  
212.         /* remove */  
213.         node_prev->next = node_at->next;  
214.         free(node_at);  
215.         return  0;  
216.     } else {  
217.         return -1;  
218.     }  
219. }  
220.   
221. linklist_t ReverseLinklist(linklist_t list)  
222. {  
223.     linknode_t *node;   /* iterator */  
224.     linknode_t *node_prev;  /* previous node of iterator */  
225.     linknode_t *node_next;  /* next node of iterator,  
226.                  * used to backup next of iterator  
227.                  */  
228.     if (NULL == list) return NULL;  
229.     node_prev = NULL;  
230.     node = list->next;  
231.     while (NULL != node) {  
232.         /* 
233.          * step1: backup node->next 
234.          * due to the next of iterator will be 
235.          * modified in step2 
236.          */  
237.         node_next = node->next;  
238.         /*  
239.          * when iterator reaches the last node  
240.          * of original list, make the list head 
241.          * point to the last node, so the original 
242.          * last one becomes the first one. 
243.          */  
244.   
245.         if (NULL == node_next) {  
246.             list->next = node;  
247.         }  
248.   
249.         /*  
250.          * step2: reverse the linkage between nodes 
251.          * make the node pointer to the previous node, 
252.          * not the next node 
253.          */       
254.         node->next = node_prev;        
255.         /*  
256.          * step3: move forward  
257.          */  
258.   
259.         node_prev = node;  
260.         node = node_next;  
261.     }  
262.     return list;  
263. }  

main.c

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include "linklist.h"  
4.   
5. int main()  
6. {  
7.     int i;  
8.     data_t x;  
9.     linklist_t p;  
10.     p = CreateEmptyLinklist();  
11.     data_t a[10] = {1,3,5,7,9,11,13,15,17,19};  
12.   
13.     for(i = 0;i < 10;i++)  
14.     {  
15.         InsertLinklist(p,i,a[i]);  
16.     }  
17.   
18.     ReverseLinklist(p);  
19.     printf("The length of the list is:%d\n",LengthLinklist(p));  
20.       
21.     GetLinklist(p,4,&x);  
22.     printf("The NO.4 of this list is:%d\n",x);  
23.   
24.     SetLinklist(p,4,100);  
25.     GetLinklist(p,4,&x);  
26.     printf("After updating!The No.4 0f this list is:%d\n",x);  
27.   
28.     DeleteLinklist(p,4);  
29.     printf("After updating!The length of the list is:%d\n",LengthLinklist(p));  
30.     GetLinklist(p,4,&x);  
31.     printf("After updating!The No.4 0f this list is:%d\n",x);  
32.   
33.     ReverseLinklist(p);  
34.       
35.     ClearLinklist(p);  
36.     if(EmptyLinklist(p))  
37.         printf("This list is empty!\n");  
38.     DestroyLinklist(p);  
39.     printf("This list is destroyed!\n");  
40.   
41.     return 0;  
42.       
43. }  

執行結果如下：

[cpp] view plain copy

1. [email protected]:~/qiang/list/list2$ ./Test  
2. The length of the list is:10  
3. The NO.4 of this list is:11  
4. After updating!The No.4 0f this list is:100  
5. After updating!The length of the list is:9  
6. After updating!The No.4 0f this list is:9  
7. This list is empty!  
8. This list is destroyed!