devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

链表基础知识详解（非常详细简单易懂）

作者：小小林熬夜学编程 | 2024-02-15 13:10:52

赞

踩

链表

概述：

      链表作为 C 语言中一种基础的数据结构，在平时写程序的时候用的并不多，但在操作系统里面使用的非常多。不管是RTOS还是Linux等使用非常广泛，所以必须要搞懂链表，链表分为单向链表和双向链表，单向链表很少用，使用最多的还是双向链表。单向链表懂了双向链表自然就会了。

文章目录

一、链表的概念

 链表的构成：

链表的操作:

 双向链表

链表与数组的对比

二、链表的创建

 三、链表的遍历

四、链表的释放

 五、链表节点的查找

六、链表节点的删除

七、链表中插入一个节点

八、链表排序

九、双向链表的创建和遍历

 十、双向链表插入节点

一、链表的概念

定义：

      链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。

特点：

      链表由一系列节点（链表中每一个元素称为节点）组成，节点在运行时动态生成 （malloc），每个节点包括两个部分：

     一个是存储数据元素的数据域

     另一个是存储下一个节点地址的指针域

图1 单向链表

 链表的构成：

      链表由一个个节点构成，每个节点一般采用结构体的形式组织，例如：

  1. typedef struct student｛
  2.  int num；
  3.  char name[20]；
  4.  struct student *next；
  5.  }STU;

      链表节点分为两个域

      数据域：存放各种实际的数据，如：num、score等

      指针域：存放下一节点的首地址，如：next等.

图2 节点内嵌在一个数据结构中

链表的操作:

      链表最大的作用是通过节点把离散的数据链接在一起，组成一个表，这大概就是链表 的字面解释了吧。 链表常规的操作就是节点的插入和删除，为了顺利的插入，通常一条链 表我们会人为地规定一个根节点，这个根节点称为生产者。通常根节点还会有一个节点计 数器，用于统计整条链表的节点个数，具体见图3中的 root_node。

图3带根节点的链表

 双向链表

      双向链表与单向链表的区别就是节点中有两个节点指针，分别指向前后两个节点，其 它完全一样。有关双向链表的文字描述参考单向链表小节即可，有关双向链表的示意图具体见图4

图4双向链表

链表与数组的对比

      在很多公司的嵌入式面试中，通常会问到链表和数组的区别。在 C 语言中，链表与数 组确实很像，两者的示意图具体见图5，这里以双向链表为例。

图5 链表与数组的对比

      链表是通过节点把离散的数据链接成一个表，通过对节点的插入和删除操作从而实现 对数据的存取。而数组是通过开辟一段连续的内存来存储数据，这是数组和链表最大的区 别。数组的每个成员对应链表的节点，成员和节点的数据类型可以是标准的 C 类型或者是 用户自定义的结构体。数组有起始地址和结束地址，而链表是一个圈，没有头和尾之分， 但是为了方便节点的插入和删除操作会人为的规定一个根节点。

二、链表的创建

第一步：创建一个节点

 第二步：创建第二个节点，将其放在第一个节点的后面（第一的节点的指针域保存第二个节点的地址）

第三步：再次创建节点，找到原本链表中的最后一个节点，接着讲最后一个节点的指针域保存新节点的地址，以此内推。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. //定义结点结构体
  4. typedef struct student
  5. {
  6.     //数据域
  7.     int num;		//学号
  8.     int score;      //分数
  9.     char name[20];  //姓名
  10.     //指针域
  11.     struct student *next;
  12. }STU;
  13.  
  14. void link_creat_head(STU **p_head,STU *p_new)
  15. {
  16.     STU *p_mov = *p_head;
  17.     if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
  18.     {
  19.         *p_head = p_new;
  20.         p_new->next=NULL;
  21.     }
  22.     else //第二次及以后加入链表
  23.     {
  24.         while(p_mov->next!=NULL)
  25.         {
  26.             p_mov=p_mov->next;	//找到原有链表的最后一个节点
  27.         }
  28.  
  29.         p_mov->next = p_new;	//将新申请的节点加入链表
  30.         p_new->next = NULL;
  31.     }
  32. }
  33.  
  34. int main()
  35. {
  36.     STU *head = NULL,*p_new = NULL;
  37.     int num,i;
  38.     printf("请输入链表初始个数:\n");
  39.     scanf("%d",&num);
  40.     for(i = 0; i < num;i++)
  41.     {
  42.         p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
  43.         printf("请输入学号、分数、名字:\n"); //给新节点赋值
  44.         scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
  45.  
  46.         link_creat_head(&head,p_new);	//将新节点加入链表
  47.     }
  48. }

 三、链表的遍历

第一步：输出第一个节点的数据域，输出完毕后，让指针保存后一个节点的地址

 第二步：输出移动地址对应的节点的数据域，输出完毕后，指针继续后移 

 

 第三步：以此类推，直到节点的指针域为NULL

  1. //链表的遍历
  2. void link_print(STU *head)
  3. {
  4.     STU *p_mov;
  5.     //定义新的指针保存链表的首地址，防止使用head改变原本链表
  6.     p_mov = head;
  7.     //当指针保存最后一个结点的指针域为NULL时，循环结束
  8.     while(p_mov!=NULL)
  9.     {
  10.         //先打印当前指针保存结点的指针域
  11.         printf("num=%d score=%d name:%s\n",p_mov->num,\
  12.                p_mov->score,p_mov->name);
  13.  
  14.         //指针后移，保存下一个结点的地址
  15.         p_mov = p_mov->next;
  16.     }
  17. }

四、链表的释放

重新定义一个指针q，保存p指向节点的地址，然后p后移保存下一个节点的地址，然后释放q对应的节点，以此类推，直到p为NULL为止

  1.  //链表的释放
  2.  void link_free(STU **p_head)
  3.  {
  4.    //定义一个指针变量保存头结点的地址
  5.    STU *pb=*p_head;
  6.  
  7.   while(*p_head!=NULL)
  8.   {
  9.    //先保存p_head指向的结点的地址
  10.    pb=*p_head;
  11.    //p_head保存下一个结点地址
  12.    *p_head=(*p_head)‐>next;
  13.    //释放结点并防止野指针
  14.    free(pb);
  15.    pb = NULL;
  16.   }
  17.  }

 五、链表节点的查找

      先对比第一个结点的数据域是否是想要的数据，如果是就直接返回，如果不是则继续查找下 一个结点，如果到达最后一个结点的时候都没有匹配的数据，说明要查找数据不存在

  1.  
  2. //链表的查找
  3. //按照学号查找
  4. STU * link_search_num(STU *head,int num)
  5. {
  6.     STU *p_mov;
  7.     //定义的指针变量保存第一个结点的地址
  8.     p_mov=head;
  9.     //当没有到达最后一个结点的指针域时循环继续
  10.     while(p_mov!=NULL)
  11.     {
  12.         //如果找到是当前结点的数据，则返回当前结点的地址
  13.         if(p_mov->num == num)//找到了
  14.         {
  15.             return p_mov;
  16.         }
  17.         //如果没有找到，则继续对比下一个结点的指针域
  18.         p_mov=p_mov->next;
  19.     }
  20.  
  21.     //当循环结束的时候还没有找到，说明要查找的数据不存在，返回NULL进行标识
  22.     return NULL;//没有找到
  23. }
  24.  
  25. //按照姓名查找
  26. STU * link_search_name(STU *head,char *name)
  27. {
  28.     STU *p_mov;
  29.     p_mov=head;
  30.     while(p_mov!=NULL)
  31.     {
  32.         if(strcmp(p_mov->name,name)==0)//找到了
  33.         {
  34.             return p_mov;
  35.         }
  36.         p_mov=p_mov->next;
  37.     }
  38.     return NULL;//没有找到
  39. }

六、链表节点的删除

      如果链表为空，不需要删除 如果删除的是第一个结点，则需要将保存链表首地址的指针保存第一个结点的下一个结点的 地址 如果删除的是中间结点，则找到中间结点的前一个结点，让前一个结点的指针域保存这个结 点的后一个结点的地址即可

  1. //链表结点的删除
  2. void link_delete_num(STU **p_head,int num)
  3. {
  4.     STU *pb,*pf;
  5.     pb=pf=*p_head;
  6.     if(*p_head == NULL)//链表为空，不用删
  7.     {
  8.         printf("链表为空，没有您要删的节点");\
  9.         return ;
  10.     }
  11.     while(pb->num != num && pb->next !=NULL)//循环找，要删除的节点
  12.     {
  13.         pf=pb;
  14.         pb=pb->next;
  15.     }
  16.     if(pb->num == num)//找到了一个节点的num和num相同
  17.     {
  18.         if(pb == *p_head)//要删除的节点是头节点
  19.         {
  20.             //让保存头结点的指针保存后一个结点的地址
  21.             *p_head = pb->next;
  22.         }
  23.         else
  24.         {
  25.             //前一个结点的指针域保存要删除的后一个结点的地址
  26.             pf->next = pb->next;
  27.         }
  28.  
  29.         //释放空间
  30.         free(pb);
  31.         pb = NULL;
  32.     }
  33.     else//没有找到
  34.     {
  35.         printf("没有您要删除的节点\n");
  36.     }
  37. }

七、链表中插入一个节点

链表中插入一个结点，按照原本链表的顺序插入，找到合适的位置

 情况（按照从小到大）：

      如果链表没有结点，则新插入的就是第一个结点。

      如果新插入的结点的数值最小，则作为头结点。

      如果新插入的结点的数值在中间位置，则找到前一个，然后插入到他们中间。

      如果新插入的结点的数值最大，则插入到最后。

  1. //链表的插入：按照学号的顺序插入
  2. void link_insert_num(STU **p_head,STU *p_new)
  3. {
  4.     STU *pb,*pf;
  5.     pb=pf=*p_head;
  6.     if(*p_head ==NULL)// 链表为空链表
  7.     {
  8.         *p_head = p_new;
  9.         p_new->next=NULL;
  10.         return ;
  11.     }
  12.     while((p_new->num >= pb->num)  && (pb->next !=NULL) )
  13.     {
  14.         pf=pb;
  15.         pb=pb->next;
  16.     }
  17.  
  18.     if(p_new->num < pb->num)//找到一个节点的num比新来的节点num大，插在pb的前面
  19.     {
  20.         if(pb== *p_head)//找到的节点是头节点，插在最前面
  21.         {
  22.             p_new->next= *p_head;
  23.             *p_head =p_new;
  24.         }
  25.         else
  26.         {
  27.             pf->next=p_new;
  28.             p_new->next = pb;
  29.         }
  30.     }
  31.     else//没有找到pb的num比p_new->num大的节点，插在最后
  32.     {
  33.         pb->next =p_new;
  34.         p_new->next =NULL;
  35.     }
  36. }

八、链表排序

      如果链表为空，不需要排序。

      如果链表只有一个结点，不需要排序。

      先将第一个结点与后面所有的结点依次对比数据域，只要有比第一个结点数据域小的，则交 换位置。

       交换之后，拿新的第一个结点的数据域与下一个结点再次对比，如果比他小，再次交换，依 次类推。

      第一个结点确定完毕之后，接下来再将第二个结点与后面所有的结点对比，直到最后一个结 点也对比完毕为止。

  1. //链表的排序
  2. void link_order(STU *head)
  3. {
  4.     STU *pb,*pf,temp;
  5.     pf=head;
  6.  
  7.     if(head==NULL)
  8.     {
  9.         printf("链表为空,不用排序\n");
  10.         return ;
  11.     }
  12.  
  13.     if(head->next ==NULL)
  14.     {
  15.         printf("只有一个节点，不用排序\n");
  16.         return ;
  17.     }
  18.  
  19.     while(pf->next !=NULL)//以pf指向的节点为基准节点，
  20.     {
  21.         pb=pf->next;//pb从基准元素的下个元素开始
  22.         while(pb!=NULL)
  23.         {
  24.             if(pf->num > pb->num)
  25.             {
  26.                 temp=*pb;
  27.                 *pb=*pf;
  28.                 *pf=temp;
  29.  
  30.                 temp.next=pb->next;
  31.                 pb->next=pf->next;
  32.                 pf->next=temp.next;
  33.             }
  34.             pb=pb->next;
  35.         }
  36.         pf=pf->next;
  37.     }
  38. }

九、双向链表的创建和遍历

第一步：创建一个节点作为头节点，将两个指针域都保存NULL

第二步：先找到链表中的最后一个节点，然后让最后一个节点的指针域保存新插入节点的地址，新插入节点的两个指针域，一个保存上一个节点的地址，一个保存NULL

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. //定义结点结构体
  5. typedef struct student
  6. {
  7.     //数据域
  8.     int num;		//学号
  9.     int score;      //分数
  10.     char name[20];  //姓名
  11.  
  12.     //指针域
  13.     struct student *front;  //保存上一个结点的地址
  14.     struct student *next;   //保存下一个结点的地址
  15. }STU;
  16.  
  17. void double_link_creat_head(STU **p_head,STU *p_new)
  18. {
  19.     STU *p_mov=*p_head;
  20.     if(*p_head==NULL)				//当第一次加入链表为空时，head执行p_new
  21.     {
  22.         *p_head = p_new;
  23.         p_new->front = NULL;
  24.         p_new->next = NULL;
  25.     }
  26.     else	//第二次及以后加入链表
  27.     {
  28.         while(p_mov->next!=NULL)
  29.         {
  30.             p_mov=p_mov->next;	//找到原有链表的最后一个节点
  31.         }
  32.         p_mov->next = p_new;		//将新申请的节点加入链表
  33.         p_new->front = p_mov;
  34.         p_new->next = NULL;
  35.     }
  36. }
  37.  
  38.  
  39. void double_link_print(STU *head)
  40. {
  41.     STU *pb;
  42.     pb=head;
  43.     while(pb->next!=NULL)
  44.     {
  45.         printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
  46.         pb=pb->next;
  47.     }
  48.     printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
  49.  
  50.     printf("***********************\n");
  51.  
  52.     while(pb!=NULL)
  53.     {
  54.         printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
  55.         pb=pb->front;
  56.     }
  57. }
  58.  
  59. int main()
  60. {
  61.     STU *head=NULL,*p_new=NULL;
  62.     int num,i;
  63.     printf("请输入链表初始个数:\n");
  64.     scanf("%d",&num);
  65.     for(i=0;i<num;i++)
  66.     {
  67.         p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
  68.         printf("请输入学号、分数、名字:\n");	//给新节点赋值
  69.         scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
  70.         double_link_creat_head(&head,p_new);	//将新节点加入链表
  71.     }
  72.  
  73.     double_link_print(head);
  74. }

 十、双向链表插入节点

按照顺序插入结点

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. //定义结点结构体
  5. typedef struct student
  6. {
  7.     //数据域
  8.     int num;		//学号
  9.     int score;      //分数
  10.     char name[20];  //姓名
  11.  
  12.     //指针域
  13.     struct student *front;  //保存上一个结点的地址
  14.     struct student *next;   //保存下一个结点的地址
  15. }STU;
  16.  
  17. void double_link_creat_head(STU **p_head,STU *p_new)
  18. {
  19.     STU *p_mov=*p_head;
  20.     if(*p_head==NULL)				//当第一次加入链表为空时，head执行p_new
  21.     {
  22.         *p_head = p_new;
  23.         p_new->front = NULL;
  24.         p_new->next = NULL;
  25.     }
  26.     else	//第二次及以后加入链表
  27.     {
  28.         while(p_mov->next!=NULL)
  29.         {
  30.             p_mov=p_mov->next;	//找到原有链表的最后一个节点
  31.         }
  32.         p_mov->next = p_new;		//将新申请的节点加入链表
  33.         p_new->front = p_mov;
  34.         p_new->next = NULL;
  35.     }
  36. }
  37.  
  38.  
  39. void double_link_print(STU *head)
  40. {
  41.     STU *pb;
  42.     pb=head;
  43.     while(pb->next!=NULL)
  44.     {
  45.         printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
  46.         pb=pb->next;
  47.     }
  48.     printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
  49.  
  50.     printf("***********************\n");
  51.  
  52.     while(pb!=NULL)
  53.     {
  54.         printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
  55.         pb=pb->front;
  56.     }
  57. }
  58.  
  59. //双向链表的删除
  60. void double_link_delete_num(STU **p_head,int num)
  61. {
  62.     STU *pb,*pf;
  63.     pb=*p_head;
  64.     if(*p_head==NULL)//链表为空，不需要删除
  65.     {
  66.         printf("链表为空，没有您要删除的节点\n");
  67.         return ;
  68.     }
  69.     while((pb->num != num) && (pb->next != NULL) )
  70.     {
  71.         pb=pb->next;
  72.     }
  73.     if(pb->num == num)//找到了一个节点的num和num相同，删除pb指向的节点
  74.     {
  75.         if(pb == *p_head)//找到的节点是头节点
  76.         {
  77.             if((*p_head)->next==NULL)//只有一个节点的情况
  78.             {
  79.                 *p_head=pb->next;
  80.             }
  81.             else//有多个节点的情况
  82.             {
  83.                 *p_head = pb->next;//main函数中的head指向下个节点
  84.                 (*p_head)->front=NULL;
  85.             }
  86.         }
  87.         else//要删的节点是其他节点
  88.         {
  89.             if(pb->next!=NULL)//删除中间节点
  90.             {
  91.                 pf=pb->front;//让pf指向找到的节点的前一个节点
  92.                 pf->next=pb->next; //前一个结点的next保存后一个结点的地址
  93.                 (pb->next)->front=pf; //后一个结点的front保存前一个结点的地址
  94.             }
  95.             else//删除尾节点
  96.             {
  97.                 pf=pb->front;
  98.                 pf->next=NULL;
  99.             }
  100.         }
  101.  
  102.         free(pb);//释放找到的节点
  103.  
  104.     }
  105.     else//没找到
  106.     {
  107.         printf("没有您要删除的节点\n");
  108.     }
  109. }
  110.  
  111. int main()
  112. {
  113.     STU *head=NULL,*p_new=NULL;
  114.     int num,i;
  115.     printf("请输入链表初始个数:\n");
  116.     scanf("%d",&num);
  117.     for(i=0;i<num;i++)
  118.     {
  119.         p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
  120.         printf("请输入学号、分数、名字:\n");	//给新节点赋值
  121.         scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
  122.         double_link_creat_head(&head,p_new);	//将新节点加入链表
  123.     }
  124.  
  125.     double_link_print(head);
  126.  
  127.     printf("请输入您要删除的节点的num\n");
  128.     scanf("%d",&num);
  129.     double_link_delete_num(&head,num);
  130.     double_link_print(head);
  131.  
  132. }

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/84746
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号