Linux C 數據結構 ->單向鏈表<-（~千金散盡還復來~）

 

之前看到一篇單向鏈表的博文，代碼也看着很舒服，於是乎記錄下來，留給自己~，循序漸進，慢慢

延伸到真正的內核鏈表~（敢問路在何方?路在腳下~）

 

1. 簡介

鏈表是Linux 內核中最簡單，最普通的數據結構。鏈表是一種存放和操作可變數量元素（常稱為節點）

的數據結構，鏈表和靜態數組的不同之處在於，它所包含的元素都是動態創建並插入鏈表的，在編譯

時不必知道具體需要創建多少個元素，另外也因為鏈表中每個元素的創建時間各不相同，所以它們在

內存中無須占用連續內存區。正是因為元素不連續的存放，所以各個元素需要通過某種方式被鏈接在

一起，於是每個元素都包含一個指向下一個元素的指針，當有元素加入鏈表或從鏈表中刪除元素時，

簡單調整一下節點的指針就可以了。

 

根據它的特性，鏈表可分為：單鏈表，雙鏈表，單向循環鏈表和雙向循環鏈表，今天總結記錄的就是

最簡單的單鏈表，

 

1.1 節點類型描述

typedef struct node_t {
    data_t data;            /* 節點數據域 */
    struct node_t *next;    /* 節點的后繼指針域 */
}linknode_t, *linklist_t;

另一種寫法

struct node_t {
    data_t data;
    struct node_t *next;
}
typedef struct node_t linknode_t;
typedef struct node_t* linklist_t;

細看說明：

* linknode_t A;
* linklist_t p = &A;
*
* 結構變量A為所描述的節點，而指針變量p為指向此類型節點的指針(p值為節點的地址)
* 這樣看來 linknode_t 和 linklist_t 的作用是一樣的，那么為什么我們要定義兩個數據類
* 型(同一種)呢?  答曰：主要為了代碼的可讀性，我們要求標識符要望文識義,便於理解
*
* linknode_t *pnode  指向一個節點
* linklist_t list  指向一個整體

 

1.2 頭節點 head （~黃河之水天上來~）

在順序存儲線性表，如何表達一個空表{ }，是通過list->last = -1來表現的，所謂的空表就是

數據域為NULL，而鏈表有數據域和指針域，我們如何表現空鏈表呢？這時，就引入了頭結點

的概念，頭結點和其他節點數據類型一樣，只是數據域為NULL，head->next = NULL，下面

我們看一個創建空鏈表的函數，如何利用頭結點來創建一個空鏈表，只要頭節點在，鏈表就還在~

// 創建一個空鏈表
linklist_t 
CreateEmptyLinklist()
{
    linklist_t list;
    list = (linklist_t)malloc(sizeof(linknode_t));
    
    if(NULL != list) {
        list->next = NULL;
    }
    
    return list;
}

 

2. 鏈表基本運算的相關"算法"操作 or 操刀（~烹羊宰牛且為樂，會須一飲三百杯~）

 鏈表的運算除了上面的創建空鏈表，還有數據的插入，刪除，查找等函數，鏈表的運算有各種實現方

法，如何寫出一個高效的，封裝性較好的函數是我們要考慮的，比如數據插入函數，我們就要盡可能

考慮所有能出現的結果，比如：1）如果需插入數據的鏈表是個空表；2）所插入的位置超過了鏈表的

長度；如果我們的函數能包含所有能出現的情況，不僅能大大提高我們的開發效率，也會減少代碼的

錯誤率。下面看一個可用性較強的鏈表插入操作的函數實現~

int 
InsertLinklist(linklist_t list, int at, data_t x)
{
    linknode_t * node_prev, * node_at, * node_new;
    int pos_at;
    int found = 0;

    if (NULL == list) return -1;

    /* at must >= 0  */
    if (at < 0) return -1;
    
    /*第一步、新節點分配空間*/
    node_new = (linklist_t)malloc(sizeof(linknode_t));
    if (NULL == node_new) {
        return -1;
    }
    node_new->data = x; /* assigned value */
    /*
     *節點如果插入超過鏈表長度的位置，會接到尾節點后面，
     *這樣，node_new成了尾節點，node_new->next = NULL 
    */
    node_new->next = NULL; 

    /*第二步、定位*/
    node_prev = list; //跟隨指針，幫助我們更好的定位
    node_at = list->next; //遍歷指針
    pos_at = 0;
    while(NULL != node_at) {
        if(pos_at == at){
            found = 1; //找到正確的位置，跳出循環
            break;            
        }
        /* move to the next pos_at */
        node_prev = node_at;        //跟隨指針先跳到遍歷指針的位置
        node_at = node_at->next;    //遍歷指針跳到下一個節點的位置
        pos_at++;
    }

    /*第三步、插入*/    
    if(found) {
        /* found = 1,找到正確的位置，插入  */
        node_new->next = node_at;   //插入的節點next指向node_at
        node_prev->next = node_new; //插入節點的前一個節點
    } 
    else {
        /*若是沒找到正確的位置，即所插入位置超越了鏈表的長度，
         *則接到尾節點的后面，同樣，這樣適用於{ }即空鏈表，這樣
         *我們可以建立一個空鏈表，利用這個函數，實現鏈表的初始化
         */
        node_prev->next = node_new;
    }
    
    return 0;
}

 

3. 正文開始 Demo（~與君歌一曲，請君為我傾耳聽~）

listlink.h

#ifndef _LIST_LINK_H_
#define _LIST_LINK_H_

typedef int data_t;

typedef struct node_t {
    data_t data;            /* 節點數據域 */
    struct node_t * next;    /* 節點的后繼指針域 */
}linknode_t, * linklist_t;



/* 鏈表操作函數*/

// 創建一個空鏈表
linklist_t CreateEmptyLinklist();

// 銷毀鏈表
void DestroyLinklist(linklist_t list);

// 清空鏈表
void ClearLinklist(linklist_t list);

// 是否為空鏈表
int IsEmptyLinklist(linklist_t list);

// 鏈表長度
int LengthLinklist(linklist_t list);

// 獲去鏈表節點數據
int GetLinklist(linklist_t list, int at, data_t * x);

// 設置鏈表節點數據
int SetLinklist(linklist_t list, int at, data_t x);

// 插入節點
int InsertLinklist(linklist_t list, int at, data_t x);

// 刪除節點
int DeleteLinklist(linklist_t list, int at);

// 鏈表轉置
linklist_t ReverseLinklist(linklist_t list);

// 打印鏈表
int Display(linklist_t list);


#endif // _LIST_LINK_H_

listlink.c

#include <stdio.h>
#include <stdlib.h>
#include "listlink.h"

// 創建一個空鏈表
linklist_t 
CreateEmptyLinklist()
{
    linklist_t list;
    list = (linklist_t)malloc(sizeof(linknode_t));
    
    if(NULL != list) {
        list->next = NULL;
    }
    
    return list;
}

// 銷毀鏈表
void 
DestroyLinklist(linklist_t list)
{
    if(NULL != list) {
        ClearLinklist(list);
        free(list);
    }   
}

// 清空鏈表
void 
ClearLinklist(linklist_t list)
{
    linknode_t * node; /* pointer to the node to be remove */
    if(NULL == list) return;
    
    while(NULL != list->next) {
        node = list->next;
        list->next = node->next; //此時node->next是第二node節點元素依次往后
        free(node);
    }
    return;
}

// 是否為空鏈表
int 
IsEmptyLinklist(linklist_t list)
{
    if(NULL != list) {
        if(NULL == list->next)  // 只有頭節點
            return 1; // 返回1,是個空鏈表
        else 
            return 0; // 返回0,鏈表非空
        
    } else 
        return -1;    //  返回-1, 錯誤的類型
}

// 鏈表長度
int 
LengthLinklist(linklist_t list)
{
    int len = 0;
    linknode_t * node; // 遍歷指針
    
    if(NULL == list) return -1;
    
    node = list->next; // node指針指向第一個節點
    while(NULL != node) {
        len++;
        node = node->next;
    }
    
    return len;
}

// 獲去一個鏈表指定節點數據域的數據值
int 
GetLinklist(linklist_t list, int at, data_t * x)
{
    linknode_t *node;   // 遍歷節點的指針
    int pos;            // 用於遍歷比較
    
    if(NULL == list) return -1;
    /*at 必須要 >= 0*/
    if(at < 0) return -1;
    
    /* 從第一個元素開始 */
    node = list->next; // node指針指向一個元素
    pos = 0;
    while(NULL != node) {
        if(at == pos) {
            if(NULL != x) 
                *x = node->data;
            return 0;
        }
        // 下一個元素
        node = node->next;
        pos++;
    }
    return -1;
}

// 設置一個指定鏈表節點的數據域值
int 
SetLinklist(linklist_t list, int at, data_t x)
{
    linknode_t * node; // 遍歷鏈表
    int pos;
    int found = 0;
    
    if(!list) return -1;
    /*at 必須 >= 0*/
    if(at < 0) return -1;
    
    /* node指針指向第一個元素 */
    node = list->next;
    pos = 0;
    while(NULL != node) {
        if(at == pos) {
            found = 1; // 找到了位置
            node->data = x;
            break;
        }
        /*往后移動元素*/
        node = node->next;
        pos++;
    }
    if(1 == found)
        return 0;
    else
        return -1;
}

// 插入節點
int 
InsertLinklist(linklist_t list, int at, data_t x)
{
    /* 
     * node_at and pos_at are used to locate the position of node_at.
     * node_prev follows the node_at and always points to previous node 
     *    of node_at.
     * node_new is used to point to the new node to be inserted.
     */
    linknode_t      * node_prev, * node_at, * node_new;
    int             pos_at;
    int             found = 0;
    
    if(NULL == list) return -1;
    
    /* at 必須 >= 0 */
    if(at < 0) return -1;
    
    node_new = malloc(sizeof(linknode_t));
    if(NULL == node_new)
        return -1;
    node_new->data = x; // assigned value
    node_new->next = NULL;
    
    node_prev = list; // head
    node_at = list->next; //node_at指針指向第一元素
    pos_at = 0;
    while(NULL != node_at) {
        if(pos_at == at) {
            found = 1; // found the node ‘at'
            break;
        }
        /* move to the next pos_at */
        node_prev = node_at;
        node_at = node_at->next;
        pos_at++;    
    }
    
    if(found) {
        /* insert */
        node_new->next = node_at;
        node_prev->next = node_new;
    } else{
        /*
         * If not found,means the provided 'at'
         * exceeds the upper limit of the list, just
         * append the new node to the end of the list
         */
        node_prev->next = node_new;   
    }
    
    return 0;
}

// 刪除節點
int 
DeleteLinklist(linklist_t list, int at)
{
   /* 
    * node_at and pos_at are used to locate the position of node_at.
    * node_prev follows the node_at and always points to previous node 
    *    of node_at.
    */ 
    linknode_t      * node_prev, * node_at;
    int             pos_at;
    int             found = 0;
    
    if(!list) return -1;
    if(at < 0) return -1;
    
    node_prev = list; // node_prev指針指向鏈表頭
    node_at = list->next; // node_at指針指向第一元素
    pos_at = 0;
    
    while(NULL != node_at) {
        if(pos_at == at) {
            // found the node 'at'
            found = 1;
            break;
        }
        // move to the next pos_at
        node_prev = node_at;
        node_at = node_at->next;
        pos_at++;    
    }
    if(found) {
        // remove 
        node_prev->next = node_at->next;
        free(node_at); 
        return 0;
    }else
        return -1;   
}

// 鏈表轉置
linklist_t 
ReverseLinklist(linklist_t list)
{
    linknode_t * node;       // iterator
    linknode_t * node_prev;  // previous node of iterator
    linknode_t * node_next;  /* next node of iterator
                             * used to backup next of iterator
                             */
    if(NULL == list) return NULL;
    node_prev = NULL;
    node = list->next; // node指針指向第一個元素
    while(NULL != node) {
        /*
         * step1: backup node->next
         * due to the next of iterator will be
         * modified in step2
         */
        node_next = node->next;
        /* 
         * when iterator reaches the last node 
         * of original list, make the list head
         * point to the last node, so the original
         * last one becomes the first one.
         */
        if(NULL == node_next)
            list->next = node;
        /* 
         * step2: reverse the linkage between nodes
         * make the node pointer to the previous node,
         * not the next node
         */        
        node->next = node_prev;
        /* 
         * step3: move forward 
         */
        node_prev = node;
        node = node_next;
    }
    
    return list;
}

// 打印鏈表
int
Display(linklist_t list)
{
    linknode_t * node;
    
    if(NULL == list) return -1;
    
    node = list->next;
    while(node != NULL) {
        printf(" %d ", node->data);
        node = node->next;
    } 
    printf("\n");
    
    return 0;
}


int main(int argc, char * argv[])
{
    int i;
    data_t x;
    linklist_t p;
    
    /*創建鏈表*/
    p = CreateEmptyLinklist();
    Display(p);
    data_t a[10] = {1,3,5,7,9,11,13,15,17,19};
    
    for(i = 0; i < 10; i++) {
        /*插入鏈表*/
        InsertLinklist(p, i, a[i]);
    }
    Display(p);
    
    /*鏈表轉置*/
    ReverseLinklist(p);
    /*鏈表長度*/
    printf("The length of the list is [%d]\n", LengthLinklist(p));
    Display(p);
    
    /*獲取特定節點值*/
    GetLinklist(p, 4, &x);
    printf("The No.4 of this list is [%d]\n", x);
    
    /*設置特定節點的值*/
    SetLinklist(p, 4, 100);
    GetLinklist(p, 4, &x);
    printf("After updating! The No.4 of this list is [%d]\n", x);
    Display(p);
    
    /*刪除節點*/
    DeleteLinklist(p,5);
    printf("After delete！The length of list is [%d]\n", LengthLinklist(p));
    Display(p);
    
    /*清空鏈表*/
    ClearLinklist(p);
    if(IsEmptyLinklist(p)) 
        printf("This list is empty!\n");
    /*銷毀鏈表*/
    DestroyLinklist(p);
    printf("This list is destroyed!\n");
    
   
    return 0;
    
}

運行

 

4. 鳴謝（你動了誰的奶酪？ ^_^）

感謝下面博主的共享，本文的基石，謝謝！！

感謝：https://blog.csdn.net/zqixiao_09/article/details/50402523

 

 

5. 后記

 

行歌

 

在草長鶯飛的季節里喃喃低唱　

到處人潮洶涌還會孤獨

怎么

在燈火闌珊處竟然會覺得荒蕪

從前輕狂繞過時光