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 = ;
 
    if (NULL == list) return -;
 
    /* at must >= 0  */
    if (at < ) return -;
 
    /*第一步、新节点分配空间*/
    node_new = (linklist_t)malloc(sizeof(linknode_t));
    if (NULL == node_new) {
        return -;
    }
    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 = ;
    while(NULL != node_at) {
        if(pos_at == at){
            found = ; //找到正确的位置，跳出循环
            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 ;
}

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,是个空链表
         else
             return ; // 返回0,链表非空
 
     } else
         return -;    //  返回-1, 错误的类型
 }
 
 // 链表长度
 int
 LengthLinklist(linklist_t list)
 {
     int len = ;
     linknode_t * node; // 遍历指针
 
     if(NULL == list) return -;
 
     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 -;
     /*at 必须要 >= 0*/
     if(at < ) return -;
 
     /* 从第一个元素开始 */
     node = list->next; // node指针指向一个元素
     pos = ;
     while(NULL != node) {
         if(at == pos) {
             if(NULL != x)
                 *x = node->data;
             return ;
         }
         // 下一个元素
         node = node->next;
         pos++;
     }
     return -;
 }
 
 // 设置一个指定链表节点的数据域值
 int
 SetLinklist(linklist_t list, int at, data_t x)
 {
     linknode_t * node; // 遍历链表
     int pos;
     int found = ;
 
     if(!list) return -;
     /*at 必须 >= 0*/
     if(at < ) return -;
 
     /* node指针指向第一个元素 */
     node = list->next;
     pos = ;
     while(NULL != node) {
         if(at == pos) {
             found = ; // 找到了位置
             node->data = x;
             break;
         }
         /*往后移动元素*/
         node = node->next;
         pos++;
     }
     if( == found)
         return ;
     else
         return -;
 }
 
 // 插入节点
 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 = ;
 
     if(NULL == list) return -;
 
     /* at 必须 >= 0 */
     if(at < ) return -;
 
     node_new = malloc(sizeof(linknode_t));
     if(NULL == node_new)
         return -;
     node_new->data = x; // assigned value
     node_new->next = NULL;
 
     node_prev = list; // head
     node_at = list->next; //node_at指针指向第一元素
     pos_at = ;
     while(NULL != node_at) {
         if(pos_at == at) {
             found = ; // 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 ;
 }
 
 // 删除节点
 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 = ;
 
     if(!list) return -;
     if(at < ) return -;
 
     node_prev = list; // node_prev指针指向链表头
     node_at = list->next; // node_at指针指向第一元素
     pos_at = ;
 
     while(NULL != node_at) {
         if(pos_at == at) {
             // found the node 'at'
             found = ;
             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 ;
     }else
         return -;
 }
 
 // 链表转置
 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 -;
 
     node = list->next;
     while(node != NULL) {
         printf(" %d ", node->data);
         node = node->next;
     }
     printf("\n");
 
     return ;
 }
 
 int main(int argc, char * argv[])
 {
     int i;
     data_t x;
     linklist_t p;
 
     /*创建链表*/
     p = CreateEmptyLinklist();
     Display(p);
     data_t a[] = {,,,,,,,,,};
 
     for(i = ; i < ; 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, , &x);
     printf("The No.4 of this list is [%d]\n", x);
 
     /*设置特定节点的值*/
     SetLinklist(p, , );
     GetLinklist(p, , &x);
     printf("After updating! The No.4 of this list is [%d]\n", x);
     Display(p);
 
     /*删除节点*/
     DeleteLinklist(p,);
     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 ;
 
 }

运行

4. 鸣谢（你动了谁的奶酪？ ^_^）

感谢下面博主的共享，本文的基石，谢谢！！
 
感谢：https://blog.csdn.net/zqixiao_09/article/details/50402523

5. 后记

行歌

在草长莺飞的季节里喃喃低唱　

到处人潮汹涌还会孤独

怎么

在灯火阑珊处竟然会觉得荒芜

从前轻狂绕过时光