搬：一步一步教你从零开始写C语言链表

最新推荐文章于 2024-02-27 17:53:45 发布
最新推荐文章于 2024-02-27 17:53:45 发布
阅读量146 收藏 1
点赞数
分类专栏： 数据结构与算法

垃圾，又复制不了图。。。。。。。。

请点击原贴：一步一步教你从零开始写C语言链表

 

https://blog.csdn.net/morixinguan/article/details/68951912

为什么要学习链表？

链表主要有以下几大特性：

1、解决数组无法存储多种数据类型的问题。

2、解决数组中，元素个数无法改变的限制(C99的变长数组，C++也有变长数组可以实现)。

3、数组移动元素的过程中，要对元素进行大范围的移动，很耗时间，效率也不高。

先来感性的认识一下链表,我们先来认识下简单的链表:

从这幅图我们得出以下信息:

这个简单链表的构成：

头指针(Header)，若干个节点(节点包括了数据域和指针域)，最后一个节点要指向空。

实现原理：头指针指向链表的第一个节点，然后第一个节点中的指针指向下一个节点，然后依次指到最后一个节点，这样就构成了一条链表。

接下来看看链表的数据结构:

    struct  list_node
    {
        int data ; //数据域，用于存储数据
        struct list_node *next ; //指针，可以用来访问节点数据，也可以遍历，指向下一个节点
    };

那么如何来创建一个链表的一个节点呢？

我们写个程序演示一下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    struct  list_node
    {
        int data ;
        struct list_node *next ;
    };
     
    typedef struct list_node list_single ;     
     
    int main(void)
    {
        list_single *node = NULL ;          //1、首先，当然是定义一个头指针
        node = (list_single *)malloc(sizeof(list_single)); //2、然后分配内存空间
        if(node == NULL){
            printf("malloc fair!\n");
        }
        memset(node,0,sizeof(list_single)); //3、清一下
        node->data = 100 ;                    //4、给链表节点的数据赋值
        node->next = NULL ;                 //5、将链表的指针域指向空
        printf("%d\n",node->data);
        free(node);
        return 0 ;
    }

那么，这仅仅只是创建一个链表中的一个节点，为了好看，我们把创建节点封装成函数，以后想创建多少个节点，我们就可以反复调用一个函数来创建，会很方便:

    list_single *create_list_node(int data)
    {
        list_single *node = NULL ;
        node = (list_single *)malloc(sizeof(list_single));
        if(node == NULL){
            printf("malloc fair!\n");
        }
        memset(node,0,sizeof(list_single));
        node->data = 100 ;
        node->next = NULL ;
        return node ;
    }

接下来在程序上完成的程序:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    struct  list_node
    {
        int data ;
        struct list_node *next ;
    };
     
    typedef struct list_node list_single ;     
    list_single *create_list_node(int data)
    {
        list_single *node = NULL ;
        node = (list_single *)malloc(sizeof(list_single));
        if(node == NULL){
            printf("malloc fair!\n");
        }
        memset(node,0,sizeof(list_single));
        node->data = data;
        node->next = NULL ;
        return node ;
    }
    int main(void)
    {
        int data = 100 ;
        list_single *node_ptr = create_list_node(data); //创建一个节点
        printf("node_ptr->data=%d\n",node_ptr->data);   //打印节点里的数据
        printf("node_ptr->next=%d\n",node_ptr->next);  
        free(node_ptr);
        return 0 ;
    }

执行结果 ：

 

这样我们就完成一个链表节点的创建了，那么它现在的样子如下图：

链表的结构里，数据存储了100，因为这个链表只有一个节点，所以它的指针域指向了NULL。

   上面只是建立一个单链表的基本雏形，接下来咱们再来增加一点难度。如果创建多个单链表节点，实现单链表的增删改查？把单链表应用起来。
1、首先定义一个单链表的数据结构

创建节点函数原型可定义如下：
struct list *create_node(int data) ;
如何创建单链表的节点，主要分以下步骤:
(1)给当前的每个节点的数据结构配置定量的空间大小
   ep : struct list *node = malloc(sizeof(struct list));
(2)清节点数据(由于结构体变量在未初始化的时候，数据是脏的)
   ep : memset(node,0,sizeof(struct list));
(3)给节点初始化数据
   ep : node->id = data ;
(4)将该节点的指针域设置为NULL
   ep : node->next = NULL ;
2、单链表的尾插：

尾插节点函数原型可定义如下：

如何将当前链表和新的节点相连接？只要实现：
header->next = new
尾插流程如下：

(1)获取当前节点的位置，也就是访问头节点
   ep : struct list *p = header ;
(2)判断是否为最后一个节点，如果不是，移动到下一个节点，如果是，将数据插入尾部。
   ep : while(NULL != p->next) p = p->next ;
        p->next = new ;
3、单链表的头插

很好理解，头插就是把新的节点插在原来的节点和原来节点的下一个节点之间的一个节点。如图，新的节点插在头节点和节点1。
所以可以推出头插流程如下：
(1)获取当前节点的位置，也就是访问头节点
    ep : struct list *p = header ;
(2)新的节点的下一个节点设置为原来头节点的下一个节点(第一个节点)
    ep : new->next = p->next ;
(3)原来的头节点的下一个节点设置为现在新插入的头节点
    ep : p->next = new ;
4、单链表的遍历

如图为一条单向链表的模型，看图知道该链表由头节点和若干个节点组成，最后一个节点(尾节点)为NULL 。
从图中可以得出信息，如果我们要打印出各个节点的数据，要考虑以下问题：
(1)需要打印头节点吗？(头节点肯定是不用打印的，因为这是我们为了操作方便而设置的一个节点)。
(2)这条链表有多少个节点我们怎么知道？(通过判断该链表是否已经到达了尾节点，标志就是NULL)
那么可以得到流程如下：
(1)获取当前节点的位置，也就是访问头节点
    ep : struct list *p = header ;
(2)由于头节点我们不需要去打印它，这时候，初始化打印的节点需要从第一个节点开始。
    ep : p = p->next ;  
(3)判断是否为最后一个节点，如果不是，先打印第一个节点的数据(1)，然后移动到下一个节点(2),重复这两个步骤。
   如果是最后一个节点，直接打印数据即可。
    while(NULL != p->next){ printf("node:%d\n",p->data) ; p = p->next ;}
    printf("node:%d\n",p->data);
    当然还可以一句代码解决，这样就达到了先偏移，后取数据。
    while(NULL != p->next){ p = p->next ; printf("node:%d\n",p->data) ; }
 
5、单链表的删除

删除节点的函数原型可定义如下：
int detele_list_node(struct list *pH , int data);
单向链表的删除要考虑两种情况，一种的普通节点的删除(当然，头节点不能算)
还有一种是尾节点的前一个节点的删除情况，注意，删除完节点还需要释放对应节点的内存空间。

删除节点的设计流程：
(1)先定义两个指针，一个表示当前的节点，另一个表示当前节点的上一个节点。
    ep : struct list *p = header ;  //当前节点
         struct list *prev = NULL ; //当前节点的上一个节点
(2)遍历整个链表，同时保存当前节点的前一个节点
    ep : while(NULL != p->next)
        {
          //保存了当前的节点的前一个节点
          prev = p ;  
          //保存当前偏移的节点
          p = p->next ;
          return 0 ;
        }
(3)在遍历的过程中查找要删除的数据
    ep : while(NULL != p->next)
        {
          //保存了当前的节点的前一个节点
          prev = p ;  
          //保存当前偏移的节点
          p = p->next ;
          //查找到了数据
          if(p->id == data)
          {
          
          }
          return 0 ;
        }
(4)查找到了数据后，分两种情况删除
    ep : 普通节点的删除
        if(p->id == data)
        {
            prev->next = p->next ;
            free(p);
        }
    ep : 考虑尾节点的下一个节点为NULL的节点删除
        if(p->id == data)
        {
            if(p->next == NULL)
            {
                prev->next = NULL ;
                free(p);
            }
        }
6、单链表的逆序

逆序步骤：

单链表的基本操作流程咱们基本搞懂了，下面写一个程序，这将会变得非常非常的简单。

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    typedef struct slist
    {
        int id ;
        struct slist *next ;            
    }L;
     
    //创建一个节点
    L *create_node(int data)
    {
        //给每个节点分配结构体一样的空间大小
        L *p = malloc(sizeof(L));
        if(NULL == p)
        {
            printf("malloc error!\n");
            return NULL ;
        }
        //由于结构体在未初始化的时候一样是脏数据，所以要清
        memset(p,0,sizeof(L));
        //初始化第一个节点
        p->id = data ;
        //将节点的后继指针设置为NULL
        p->next = NULL ;
    }
     
    //链表的尾插
    void tail_insert(L *pH , L *new)
    {
        //获取当前的位置
        L *p = pH ;
        //如果当前位置的下一个节点不为空
        while(NULL != p->next)
        {
            //移动到下一个节点
            p = p->next ;
        }
        //如果跳出以上循环，所以已经到了NULL的这个位置
        //此时直接把新插入的节点赋值给NULL这个位置
        p->next = new ;
    }
     
    //链表的头插
    void top_insert(L *pH , L *new)
    {
        L *p = pH ;
        new->next = p->next ;
        p->next = new ;
    }
     
    //链表的遍历
    void Print_node(L *pH)
    {
        //获取当前的位置
        L *p = pH ;
        //获取第一个节点的位置
        p = p->next ;
        //如果当前位置的下一个节点不为空
        while(NULL != p->next)
        {
            //(1)打印节点的数据
            printf("id:%d\n",p->id);
            //(2)移动到下一个节点,如果条件仍为真，则重复(1)，再(2)
            p = p->next ;
        }
        //如果当前位置的下一个节点为空，则打印数据
        //说明只有一个节点
        printf("id:%d\n",p->id);
    }
     
    //删除链表中的节点
    int detele_list_node(L * pH , int data)
    {
        //获取当前头节点的位置
        L *p = pH ;
        L *prev = NULL;
        while(NULL != p->next)
        {
            //保存当前节点的前一个节点的指针
            prev = p ;
            //然后让当前的指针继续往后移动
            p = p->next ;     
            //判断，找到了要删除的数据  
            if(p->id == data)
            {
                //两种情况，一种是普通节点，还有一种是尾节点
                if(p->next != NULL)  //普通节点的情况
                {
                    prev->next = p->next ;
                    free(p);
                }
                else //尾节点的情况
                {
                    prev->next = NULL ; //将这个尾节点的上一个节点的指针域指向空
                    free(p);
                }
                return 0  ;
            }
        }
        printf("没有要删除的节点\n");
        return -1 ;
    }
     
    void trave_list(L * pH)
    {
        //保存第一个节点的位置
        L *p = pH->next;
        L *pBack;
        int i = 0 ;
        if(p->next == NULL || p == NULL)
            return ;
            
        while(NULL != p->next) //遍历链表
        {
            //保存第一个节点的下一个节点
            pBack = p->next ;
            //找到第一个有效节点,其实就是头指针的下一个节点
            if(p == pH->next)
            {
                //第一个有效节点就是最后一个节点，所以要指向NULL
                p->next = NULL ;
            }
            else
            {
                /*
                new->next = p->next ;
                p->next = new ;
                */
                p->next = pH->next ; //尾部连接
            }
            pH->next = p ; //头部连接
            p = pBack ; //走下一个节点
        }
        top_insert(pH,p); //插入最后一个节点
    }
     
    int main(int argc , char **argv)
    {
        //创建第一个节点
        int i ;
        L *header = create_node(0);
        for(i = 1 ; i < 10 ; i++)
        {
            tail_insert(header,create_node(i));
        }
        Print_node(header);
        detele_list_node(header,5);
        putchar('\n');
        Print_node(header);
        putchar('\n');
        trave_list(header);
        Print_node(header);
        return 0 ;
    }

运行结果：

当然，单链表存在一定的弊端，就是查找数据和删除数据的时候比较麻烦，而双链表的出现就是为了解决它的弊端：

双链表的引入是为了解决单链表的不足：
(1)双链表可以往前遍历，也可以往后遍历，具有两个方向
双链表的节点 = 有效数据 + 两个指针(分别指向前一个节点和后一个节点)
双向链表的图形结构描述:

struct double_list                                   struct double_list
{                                                            {
    数据域;                  ep :------->                   int data ;
    指针域(前向指针) ;                                   struct double_list *prev ;
    指针域(后向指针) ;                                   struct double_list *next ;
};                                                             };
 
1、双向链表的创建

struct list *create_node(int data) ;
创建步骤(与单链表类似，就是多了一个指针):
(1)给节点申请空间：
   ep : struct double_list *p = malloc(sizeof(struct double_list));
(2)初始化数据域
   ep : p->data = data ;
(3)初始化指针域
   ep : p->prev = NULL ;
        p->next = NULL ;
2、双向链表的尾插

双向链表尾插节点的函数可以定义如下：
void double_list_tail_insert(struct double_list *header , struct double_list *new) ;
尾插图示操作：

尾插的步骤：


(1)找到链表的尾节点
   ep : 和单链表差不多
        DL *p = header ;
        while(NULL != p->next)
            p = p->next ;
(2)将新的节点连接到尾节点的后面成为新的节点
   1.原来的next指针指向新节点的首地址。            p->next = new ;
   2.新节点的prev指针指向原来的尾节点的首地址。 new->prev = p;
 
3、双向链表的头插

双向链表头插节点的函数可以定义如下：
void double_list_top_insert(struct double_list *header , struct double_list *new) ;

4、双向链表的遍历

4.1 正向遍历
    void double_list_for_each(DL *header)
    步骤：和单链表完全一致，没什么好写的。
    
    
4.2 反向遍历
    void double_list_for_each_nx(DL *header)
    步骤：(1)和单链表一样，先循环找到最后一个节点的地址
          (2)再依靠prev指针循环往前移动
             2.1 先打印最后一个数据  ep : printf("%d ",p->data);
             2.2 向前循环遍历         ep : p = p->prev ;
             
             判断条件：header->prev != p->prev,
             header保存的是头节点的地址,
             header->prev保存的是头节点的prev的地址,
             header->next保存的是头节点的next的地址,
             头节点在创建的时候:
             header->prev = NULL ;
             header->next = NULL ;
             所以这个条件这样写header->prev = NULL也是对的。
5、双向链表节点的删除


假设需要删除节点1：    
    首先:
    (1)获取当前节点的地址：
        ep : p = header;
    (2)遍历所有的节点，找到要删除的节点：
        ep :
        while(NULL != p->next)
        {
            p = p->next ;
            if(p->data == data)
            {
            
            }
        }
    (3)找到要删除的数据以后，需要做判断，判断两种情况，这和单链表差不多
    3.1 如果找到当前节点的下一个节点不为空
    3.1.1    
        那就把当前节点的prev节点指向要删除的这个节点的prev
        因为当前的prev节点保存的是要删除的上一个节点的指针
        p->next->prev = p->prev ;
    3.1.2    
        然后将当前节点的prev指针(也就是上一个节点的指针)指向当前节点(要删除的)的下一个节点:
        p->prev->next = p->next ;
    3.1.3    
        最后释放删除指针的空间：
        free(p);
        
    3.2 如果找到当前节点的下一个节点为空
    3.2.1   
    直接把当前指针(要删除的节点)的prev指针(保存着当前指针的上一个节点的地址)的下一个next指针设置为空。
    p->prev->next = NULL ;
    3.2.2
    将删除的指针的空间释放:
    free(p);
    看来，双链表学起来比单链表容易多了！确实啊，多了一个方向，操作起来就更加容易了，但是多了一个方向，一维多了一个指针，相比增加了一定的复杂度，但是，只要牢记prev指针和next指针的指向，那么，手画一图，代码即可写出！
下面给一个案例实现一下双向链表：
 

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    //创建一个双链表的数据结构
    typedef struct __double_list
    {
        int data ;
        struct __double_list *prev ;
        struct __double_list *next ;
    }DL ;
     
    //创建双向链表并插入一个节点
    DL *create_dl_node(int data)
    {
        DL *p = malloc(sizeof(DL));
        if(NULL == p)
        {
            printf("create dl node fair!\n");
            return NULL ;
        }
        //初始化数据
        p->data = data ;
        //初始化指针
        p->next = NULL ;
        p->prev = NULL ;
    }
     
    //双向链表的尾插
    void double_list_tail_insert(DL *header , DL *new)
    {
        //取得当前节点的地址
        DL *p = header ;
        //找到链表的尾节点
        while(NULL != p->next)
        {
            //找不到接着找
            p = p->next ;
        }
        //找到了尾节点，指向新节点的首地址
        p->next = new ;
        //新节点的prev指针指向原来的尾节点的首地址。
        new->prev = p;
    }
     
    //双向链表的头插(也就是插在两个节点之间的插入方式)
    void double_list_top_insert(DL *header , DL *new)
    {
        //新节点的next指针指向原来的节点一的地址
        new->next = header->next ;
        //判断当前节点的下一个节点的地址是否为空
        if(NULL != header->next)
            header->next->prev = new ; //节点1的prev指针指向新节点的地址
        header->next = new ;
        new->prev = header ;
    }
     
    //双向链表的正向遍历
    void double_list_for_each(DL *header)
    {
        DL *p = header ;
        while(NULL != p->next)
        {
            p = p->next ;
            printf("%d ",p->data);
        }
    }
     
    //双向链表的反向遍历
    void double_list_for_each_nx(DL *header)
    {
        DL *p = header ;
        //先找到尾节点
        while(NULL != p->next)
        {
            p = p->next ;    
        }
        //已经找到了尾节点，向前遍历，注意，遍历到头节点之前
        //限制条件: != 头结点
        while(NULL != p->prev)
        {
            printf("%d ",p->data);
            p = p->prev ;
        }
    }
     
    //双向链表节点的删除
    int double_list_delete_node(DL *header , int data)
    {
        //取得当前节点
        DL *p = header;
        //遍历所有的节点
        while(NULL != p->next)
        {
            p = p->next ;
            //找到了对应要删除的数据了
            if(p->data == data)
            {
                //一样存在两种情况
                //(1)当前节点的下一个节点不为空
                if(p->next != NULL)
                {
                    //那就把当前节点的prev节点指向要删除的这个节点的prev
                    //因为当前的prev节点保存的是要删除的上一个节点的指针
                    p->next->prev = p->prev ;
                    //还要指定它的next节点
                    p->prev->next = p->next ;
                    free(p);
                }
                //(2)当前节点的下一个节点为空
                else
                {
                    //把
                    p->prev->next = NULL ;
                    free(p);
                }
                return 0 ;
            }
        }
        printf("\n没有找到对应要删除的节点，或者节点已经被删除！\n");
        return -1 ;    
    }
     
    int main(void)
    {
        int i ;
        DL *header = create_dl_node(0);
        for(i = 0 ; i < 10 ; i++)
        {
            //双向链表的尾插
            //double_list_tail_insert(header,create_dl_node(i));
            //双向链表的头插
            double_list_top_insert(header,create_dl_node(i));
        }
        //双向链表的正向遍历
        printf("双向链表的正向遍历:");
        double_list_delete_node(header,5);
        double_list_for_each(header);
    //    double_list_delete_node(header,9);
        double_list_delete_node(header,5);
        putchar('\n');
        printf("双向链表的反向遍历:");
        double_list_for_each_nx(header);
        return 0 ;
    }

运行结果：

 
---------------------  
作者：Engineer-Bruce_Yang  
来源：CSDN  
原文：https://blog.csdn.net/morixinguan/article/details/68951912  
版权声明：本文为博主原创文章，转载请附上博文链接！

nedwons
关注
专栏目录
一步一步教你从零开始写C语言链表
Bruce.yang的嵌入式之旅
04-02 18万+
完整源码获取： 微信关注：嵌入式开发圈 发送"链表"即可获取。 为什么要学习链表？ 链表主要有以下几大特性： 1、解决数组无法存储多种数据类型的问题。 2、解决数组中，元素个数无法改变的限制(C99的变长数组，C++也有变长数组可以实现)。 3、数组移动元素的过程中，要对元素进行大范围的移动，很耗时间，效率也不高。 先来感性的认识一下链表,我们先来认识下简单的链表: 从这幅图我们...
【手写数据库】从零开始手写数据库内核，行列混合存储模型，学习大纲成型了
一个追逐梦想的码农
12-19 2万+
手写数据库toadb 保姆级教程来了。
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 62万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
C语言链表
small_is_powerful , small_is_beautiful
09-27 1732
前言 本博文代码基于VC++6.0开发； 本博文只是对链表的一个简单介绍； 什么是链表 字面理解就是像链子一样的表格，表示表格环环相扣，而表格是用来存储数据的，所以链表就是一种动态进行存储分配的数据结构；（功能/优点方面）在学数组二维数组的时候都知道，二维数组的第二下标位代表全部一维数组中长度最大的一个；这里就出现一个问题，数组长度上的参差不齐导致内存的浪费；然而，链表更好可以解决这个问题，对...
链表(C语言）
weixin_61196797的博客
04-30 4240
前言 本次我们介绍链表的创建及增，删，改，查。 ` 一、链表是什么？ 首先我们来了解一下线性存储结构。线性存储结构是一种最常见的存储结构。其特点是数据元素之间存在一一对应的关系。线性存储结构又分为两种，即顺序存储结构和链式存储结构。 1.首先，我们来了解一下顺序存储结构。顺序存储的线性表称为顺序表（数组）。其原理是逻辑上相邻的元素在物理位置上也相邻。 我们可以理解为一堆按照一定顺序摆放的书。我们在知道它的排列规律之后就可以通过它的排列规律来找到我们想找到的那本书。我们也可以通过一本一本的去找，来找到我们想要
C语言 链表
最新发布
m0_68484018的博客
02-27 2385
int data;int data;} Node;上面，我们定义了链表类型，那么我们如何创建链表变量呢，一般采用以下几步：通过调试器可以看到每个数据都是相互连接的。
从零开始学c语言教程
编程论坛
12-06 1745
从零开始学c语言          第一节         c语言概述 第二节         开发环境搭建 第三节         编写hello word 程序 第四节         注释 第五节         进制 第六节         关键字和标识符 第七节         常量与变量 第八节         运算符 第九节      
从零开始学习C语言之链表（先写一点，后面想起来了再补）
m0_52295089的博客
07-15 179
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白了，链表就如同车链子一样，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再
从零开始学排序：C语言冒泡排序算法教程
[从零开始学排序：C语言冒泡排序算法教程](https://media.geeksforgeeks.org/wp-content/uploads/20230526103914/2.webp) # 1. 冒泡排序算法概述 冒泡排序算法是计算机科学领域中最基本的算法之一，以其简单直观而...
c语言链表详解
飞剑神
11-24 1万+
c语言链表 1. 链表介绍 c语言的单向链表翻转是面试官常问问题之一,故此,咱就谈一谈,链表并不是如此可怕,学不会,想不通. 链表和数组一样都是存储数据,链表是非连续,非顺序的存储结构. 链表是灵活的内存动态管理(随机分配空间),删除创建结点非常方便 链表组成:由一系列结点组成. 链表结点:实际上是结构体变量. typedef struct _LINKNODE { int dat
C语言中的链表
Innocence网的博客
09-11 3783
链表，一种常见的数据结构。
C语言：链表
白的夜的博客
08-02 231
代码】C语言：链表。
c 链表
Thinkcortex的博客
08-31 1444
  #ifndef HS_LLIST_H #define HS_LLIST_H #define LLIST_FORWARD 1 #define LLIST_BACKWARD 2 struct llist_node_st { struct llist_node_st *prev; struct llist_node_st *next; c...
C语言——链表
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
C语言—链表
weixin_73588765的博客
01-01 1万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
C程序单链表面试题详解
大头针的专栏
06-12 970
测试空间旗下大头针出品   最近C语言辅导过程中，发现有很多同学对于有关C语言链表的问题一直不是很清楚，而在最近部分临毕业学员应聘测试工作中又遇到单链表的问题而且反应不是很熟练这块的内容。今天就谈谈有关但单链表的基本用法。链表1。是由结构体和指针构成的。2。包括两个部分一个是数据域和指针域。3。链表中的结点分为两类：头结点和一般结点。头结点是没有数据域的。4。基本操作有
链表（C语言）
Joezeo
11-15 497
链表（C语言）写在前面：我在实现链表时用了两个结构体，一个是结点类型，另一个是链表类型。如果不这样设置那么你在头指针或尾指针需要移动时函数参数就需要传入头、尾指针的指针地址（&head），而不是单纯的传入指针。而使用两个结构体就不需要这样做了。
链表——C语言
jin_jue_qi的博客
09-30 336
链表是一个很常用的结构。主要分为头结点和各个结点，相互链接起来。                                                                                                                         结构如图所示                          链表的删除、增加、查找都是...
链表(c语言),链表（C语言）
weixin_36201981的博客
05-21 99
LinkList.h#define _CRT_SECURE_N0_WARNINGS 1#include #include #include typedef int DataType;typedef struct ListNode {DataType data;struct ListNode *next;}ListNode;void ListInit(ListNode * *ppFirst)/...
C语言入门：链表实现与跨平台HelloWorld教程
本资源是一份关于C语言实现简单链表的教程，结合了C语言的基础入门和实际应用案例。首先，它从C语言的概述开始，介绍了什么是语言、C语言的特点，...无论是从零开始的菜鸟，还是有一定基础的学习者，都能从中获益匪浅。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值