1. 程式人生 > >Linux C 單向連結串列1

Linux C 單向連結串列1

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

       順序儲存的優點:

       順序儲存的缺點:

       連結串列就是典型的鏈式儲存,將線性表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!