单向链表的C语言实现与基本操作

最新推荐文章于 2024-08-10 06:30:00 发布
最新推荐文章于 2024-08-10 06:30:00 发布
阅读量435 收藏 18
点赞数 6
分类专栏： C

本文的主要内容目录：

一、单向链表的C语言实现

二、单向链表的基本操作


一、单向链表的C语言实现

链表作为一种基本的数据结构在程序开发过程当中经常会使用到。对C语言来说链表的实现主要依靠结构体和指针，所以本文相关内容和程序需要有C语言当中指针和结构体的基础。

链表是一种线性存储数据的结构，存储内容在逻辑上连续的，在物理上却不一定连续。单向链表的组成包括一个链表头（head）和若干链表元素（node），对链表的基本操作其实就是增、删、改、查。

首先说说单向链表的C语言实现方法。为了实现一个单向链表，首先定义一个结构体：

[cpp] view plain copy
  1. /* 定义一个表示链表的结构体指针 */  
  2. struct list {  
  3.     int id;         /* 标识这个元素方便查找 */  
  4.     char data[20];      /* 链表中包含的元素 */  
  5.     struct list *next;  /* 指向下一个链表的指针 */  
  6. };  
下面来编写程序实现一个链表的基本操作。该程序的功能是首先分配若干个链表元素（node），然后对这些链表元素进行赋初值，赋完初值之后将这些链表元素依次加入到链表当中，最后把这些元素的data字段依次打印出来。（注意 ：本程序实现的链表头结点（head）当中是存放数据的；为了保证每一个元素的id字段都不相同，所以定义了一个全局静态数据成员list_id；使用linux下的gcc进行编译）。程序如下：
[cpp] view plain copy
  1. /* 包含的头文件 */  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4.   
  5. /* 定义一个表示链表的结构体指针 */  
  6. struct list {  
  7.     int id;         /* 标识这个元素方便查找 */  
  8.     char data[20];      /* 链表中包含的元素 */  
  9.     struct list *next;  /* 指向下一个链表的指针 */  
  10. };  
  11.   
  12. /* 定义一个链表头部 */  
  13. static struct list *list_head = NULL;  
  14.   
  15. /* 为了保证每一个链表元素的id不同，特意把id定义成一个全局静态变量 */  
  16. static int list_id = 0;  
  17.   
  18. /** 将指定元素插入到聊表尾部 
  19.   *     head    : 表示要插入元素的链表的头部的地址 
  20.   * list    : 表示要插入到链表中的元素 
  21.   */  
  22. static void list_add(struct list **head, struct list *list)  
  23. {  
  24.     struct list *temp;  
  25.   
  26.     /* 判断链表是否为空 */  
  27.     if(NULL == *head)  
  28.     {  
  29.         /* 为空 */  
  30.         *head = list;  
  31.         (*head)->next = NULL;  
  32.     }  
  33.     else  
  34.     {  
  35.         /* 不为空 */  
  36.         temp = *head;  
  37.         while(temp)  
  38.         {  
  39.             if(NULL == temp->next)  
  40.             {  
  41.                 temp->next = list;  
  42.                 list->next = NULL;  
  43.             }  
  44.             temp = temp->next;  
  45.         }  
  46.     }  
  47. }  
  48.   
  49. /** 遍历一个链表，打印链表中每个元素所包含的数据 
  50.   * head : 表示要遍历的链表的头部的指针 
  51.   */  
  52. static void list_print(struct list **head)  
  53. {     
  54.     struct list *temp;  
  55.   
  56.     temp = *head;  
  57.   
  58.     printf("list information :\n");  
  59.     while(temp)  
  60.     {  
  61.         printf("\tlist %d : %s\n", temp->id, temp->data);  
  62.         temp = temp->next;  
  63.     }  
  64. }  
  65.   
  66. /* 主函数，程序的入口 */  
  67. int main(int argc, char *argv[])  
  68. {  
  69.     int i = 0;  
  70.     struct list *lists = NULL;  
  71.   
  72.     /* 分配10个元素 */  
  73.     lists = malloc(sizeof(struct list) * 10);  
  74.     if(NULL == lists)  
  75.     {  
  76.         printf("malloc error!\n");  
  77.         return -1;  
  78.     }  
  79.   
  80.     /* 将分配的10个元素依次填充数据并加入到链表当中 */  
  81.     for(i = 0; i < 10; i++)  
  82.     {  
  83.         lists[i].id = list_id++;  
  84.         sprintf(lists[i].data, "TECH-PRO - %d", i);  
  85.   
  86.         list_add(&list_head, &lists[i]);  
  87.     }  
  88.   
  89.     /* 遍历链表，把链表中每个元素的信息都打印出来 */  
  90.     list_print(&list_head);  
  91.   
  92.     return 0;  
  93. }  
程序的运行结果如下所示：


二、单向链表的基本操作

链表的基本操作其实就是对链表中元素的操作。链表的基本操作包括链表中结点元素的添加、删除、修改和查看，简单来说就是增、删、改、查。

2.1 单向链表中元素添加

在链表中添加元素时首先判断链表是否为空，为空时直接把要添加的元素赋值给链表头部，否者就要对链表进行遍历找到下一个为空的结点，然后把元素插入到链表尾部。

实现链表插入的程序代码：

[cpp] view plain copy
  1. /** 将指定元素插入到聊表尾部 
  2.   *     head    : 表示要插入元素的链表的头部的地址 
  3.   * list    : 表示要插入到链表中的元素 
  4.   */  
  5. static void list_add(struct list **head, struct list *list)  
  6. {  
  7.     struct list *temp;  
  8.   
  9.     /* 判断链表是否为空 */  
  10.     if(NULL == *head)  
  11.     {  
  12.         /* 为空 */  
  13.         *head = list;  
  14.         (*head)->next = NULL;  
  15.     }  
  16.     else  
  17.     {  
  18.         /* 不为空 */  
  19.         temp = *head;  
  20.         while(temp)  
  21.         {  
  22.             if(NULL == temp->next)  
  23.             {  
  24.                 temp->next = list;  
  25.                 list->next = NULL;  
  26.             }  
  27.             temp = temp->next;  
  28.         }  
  29.     }  
  30. }  
在main函数中田间如下代码：
[cpp] view plain copy
  1. struct list temp_list;  
  2.   
  3. /* 填充这个结构体并加入链表当中 */  
  4.     temp_list.id = list_id++;  
  5.     sprintf(temp_list.data, "temp_list");  
  6.     list_add(&list_head, &temp_list);  
对程序进行编译，结果如下：

2.2 在单向链表中删除元素

在链表删除一个元素结点是链表基本操作中相对复杂的。首先需要判断链表是否为空，当链表不为空时，要再次判断要删除的元素是否是头结点（head），如果是直接将下一个元素赋值给头结点，不过不是就需要遍历整个链表找到要删除的结点元素。（注：本算法实现的删除是通过对元素结点的id字段进行的）。

删除链表结点的程序代码：

[cpp] view plain copy
  1. /** 将指定元素从链表尾部删除 
  2.   *     head    : 表示要删除元素的链表的头部的地址 
  3.   * id      : 表示要删除元素的标识 
  4.   * 返回值  : 0-成功，-1-失败 
  5.   */  
  6. static int list_del(struct list **head, int id)  
  7. {  
  8.     struct list *temp, *p;  
  9.     temp = *head;  
  10.   
  11.     if(NULL == temp)  
  12.     {  
  13.         /* 链表为空 */  
  14.         printf("链表为空!\n");  
  15.         return -1;  
  16.     }  
  17.     else  
  18.     {  
  19.         /* 判断匹配的元素是否为链表头部的元素 */  
  20.         if(id == temp->id)       /* 是链表头部 */  
  21.         {  
  22.             *head = temp->next;  
  23.             return 0;  
  24.         }  
  25.         else                    /* 不是链表头部 */  
  26.         {  
  27.             while(temp->next)  
  28.             {  
  29.                 p = temp;  
  30.                 temp = temp->next;  
  31.   
  32.                 if(id == temp->id)  
  33.                 {  
  34.                     p->next = temp->next;  
  35.                     return 0;  
  36.                 }  
  37.             }     
  38.             return -1;  
  39.         }  
  40.     }  
  41.   
  42.     return -1;  
  43. }  
在main函数中添加如下代码：
[cpp] view plain copy
  1. /* 删除链表中开始位置、中间位置、尾部的元素 */  
  2.     list_del(&list_head, 0);  
  3.     list_del(&list_head, 5);  
  4.     list_del(&list_head, 10);  
对程序进行编译结果如下所示，第0、5、10号元素都被删除：


2.3 在单向链表中修改指定的元素

在链表中修改元素，通过对链表中元素进行遍历，找到要修改的元素对其内容分进行修改即可，实现链表元素的修改是相对容易的。（注 ：对要修改的元素的定位是通过id字段来完成的）

链表中修改元素的程序如下：

[cpp] view plain copy
  1. /** 将指定id的元素所定义的内容进行修改 
  2.   *     head    : 表示要改变元素的链表的头部的地址 
  3.   * id      : 表示要改变元素的标识 
  4.   * content : 表示要改变的内容 
  5.   * 返回值  : 0-成功，-1-失败 
  6.   */  
  7. static int list_chg(struct list **head, int id, char *content)  
  8. {  
  9.     struct list *temp;  
  10.   
  11.     temp = *head;   /* 将链表的头部赋值给临时聊表变量 */  
  12.   
  13.     while(temp)     /* 对链表进行轮询 */  
  14.     {  
  15.         if(id == temp->id)  
  16.         {  
  17.             memset(temp->data, 0, sizeof(temp->data));  
  18.             sprintf(temp->data, "%s", content);  
  19.             temp->data[strlen(content)] = '\0';  
  20.             return 0;  
  21.         }  
  22.         temp = temp->next;  
  23.     }  
  24.     return -1;  
  25. }  
在main函数中添加如下代码：
[cpp] view plain copy
  1. /* 改变id为4的元素所对应的值为 "change!!!" */  
  2.     list_chg(&list_head, 4, "change!!!");  
编译程序，运行结果如下所示：


2.4 对单向链表的元素进行查询操作

在链表中查询一个元素，根据链表头部对链表进行遍历即可。

链表中查询的程序代码：

[cpp] view plain copy
  1. /** 将指定id的元素所定义的内容进行查找 
  2.   *     head    : 表示要查询元素的链表的头部的地址 
  3.   * id      : 表示要查询元素的标识 
  4.   * 返回值  : 0-成功，-1-失败 
  5.   */  
  6. static int list_query(struct list **head, int id)  
  7. {  
  8.     struct list *temp;  
  9.   
  10.     temp = *head;   /* 将链表的头部赋值给临时聊表变量 */  
  11.   
  12.     while(temp)     /* 对链表进行轮询 */  
  13.     {  
  14.         if(id == temp->id)  
  15.         {  
  16.             printf("list %d : %s\n", temp->id, temp->data);  
  17.             return 0;  
  18.         }  
  19.         temp = temp->next;  
  20.     }  
  21.   
  22.     /* 没有找到元素 */  
  23.     printf("not finding!\n");  
  24.       
  25.     return -1;  
  26. }  
程序运行结果：



附录：单向链表的基本操作已经说完，附上一个完整的程序。

[cpp] view plain copy
  1. /* 包含的头文件 */  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <string.h>  
  5.   
  6. /* 定义一个表示链表的结构体指针 */  
  7. struct list {  
  8.     int id;             /* 标识这个元素方便查找 */  
  9.     char data[20];      /* 链表中包含的元素 */  
  10.     struct list *next;  /* 指向下一个链表的指针 */  
  11. };  
  12.   
  13. /* 定义一个链表头部 */  
  14. static struct list *list_head = NULL;  
  15.   
  16. /* 为了保证每一个链表元素的id不同，特意把id定义成一个全局静态变量 */  
  17. static int list_id = 0;  
  18.   
  19. /** 将指定元素插入到链表尾部 
  20.   *     head    : 表示要插入元素的链表的头部的地址 
  21.   * list    : 表示要插入到链表中的元素 
  22.   */  
  23. static void list_add(struct list **head, struct list *list)  
  24. {  
  25.     struct list *temp;  
  26.   
  27.     /* 判断链表是否为空 */  
  28.     if(NULL == *head)  
  29.     {  
  30.         /* 为空 */  
  31.         *head = list;  
  32.         (*head)->next = NULL;  
  33.     }  
  34.     else  
  35.     {  
  36.         /* 不为空 */  
  37.         temp = *head;  
  38.         while(temp)  
  39.         {  
  40.             if(NULL == temp->next)  
  41.             {  
  42.                 temp->next = list;  
  43.                 list->next = NULL;  
  44.             }  
  45.             temp = temp->next;  
  46.         }  
  47.     }  
  48. }  
  49.   
  50. /** 遍历一个链表，打印链表中每个元素所包含的数据 
  51.   * head : 表示要遍历的链表的头部的指针 
  52.   */  
  53. static void list_print(struct list **head)  
  54. {     
  55.     struct list *temp;  
  56.   
  57.     temp = *head;  
  58.   
  59.     printf("list information :\n");  
  60.     while(temp)  
  61.     {  
  62.         printf("\tlist %d : %s\n", temp->id, temp->data);  
  63.         temp = temp->next;  
  64.     }  
  65. }  
  66.   
  67. /** 将指定元素从链表尾部删除 
  68.   *     head    : 表示要删除元素的链表的头部的地址 
  69.   * id      : 表示要删除元素的标识 
  70.   * 返回值  : 0-成功，-1-失败 
  71.   */  
  72. static int list_del(struct list **head, int id)  
  73. {  
  74.     struct list *temp, *p;  
  75.     temp = *head;  
  76.   
  77.     if(NULL == temp)  
  78.     {  
  79.         /* 链表为空 */  
  80.         printf("链表为空!\n");  
  81.         return -1;  
  82.     }  
  83.     else  
  84.     {  
  85.         /* 判断匹配的元素是否为链表头部的元素 */  
  86.         if(id == temp->id)       /* 是链表头部 */  
  87.         {  
  88.             *head = temp->next;  
  89.             return 0;  
  90.         }  
  91.         else                    /* 不是链表头部 */  
  92.         {  
  93.             while(temp->next)  
  94.             {  
  95.                 p = temp;  
  96.                 temp = temp->next;  
  97.   
  98.                 if(id == temp->id)  
  99.                 {  
  100.                     p->next = temp->next;  
  101.                     return 0;  
  102.                 }  
  103.             }     
  104.             return -1;  
  105.         }  
  106.     }  
  107.   
  108.     return -1;  
  109. }  
  110.   
  111. /** 将指定id的元素所定义的内容进行修改 
  112.   *     head    : 表示要改变元素的链表的头部的地址 
  113.   * id      : 表示要改变元素的标识 
  114.   * content : 表示要改变的内容 
  115.   * 返回值  : 0-成功，-1-失败 
  116.   */  
  117. static int list_chg(struct list **head, int id, char *content)  
  118. {  
  119.     struct list *temp;  
  120.   
  121.     temp = *head;   /* 将链表的头部赋值给临时聊表变量 */  
  122.   
  123.     while(temp)     /* 对链表进行轮询 */  
  124.     {  
  125.         if(id == temp->id)  
  126.         {  
  127.             memset(temp->data, 0, sizeof(temp->data));  
  128.             sprintf(temp->data, "%s", content);  
  129.             temp->data[strlen(content)] = '\0';  
  130.             return 0;  
  131.         }  
  132.         temp = temp->next;  
  133.     }  
  134.     return -1;  
  135. }  
  136.   
  137. /** 将指定id的元素所定义的内容进行查找 
  138.   *     head    : 表示要查询元素的链表的头部的地址 
  139.   * id      : 表示要查询元素的标识 
  140.   * 返回值  : 0-成功，-1-失败 
  141.   */  
  142. static int list_query(struct list **head, int id)  
  143. {  
  144.     struct list *temp;  
  145.   
  146.     temp = *head;   /* 将链表的头部赋值给临时聊表变量 */  
  147.   
  148.     while(temp)     /* 对链表进行轮询 */  
  149.     {  
  150.         if(id == temp->id)  
  151.         {  
  152.             printf("list %d : %s\n", temp->id, temp->data);  
  153.             return 0;  
  154.         }  
  155.         temp = temp->next;  
  156.     }  
  157.   
  158.     /* 没有找到元素 */  
  159.     printf("not finding!\n");  
  160.       
  161.     return -1;  
  162. }  
  163.   
  164.   
  165. /* 主函数，程序的入口 */  
  166. int main(int argc, char *argv[])  
  167. {  
  168.     int i = 0;  
  169.     struct list *lists = NULL;  
  170.   
  171.     struct list temp_list;  
  172.   
  173.     /* 分配10个元素 */  
  174.     lists = malloc(sizeof(struct list) * 10);  
  175.     if(NULL == lists)  
  176.     {  
  177.         printf("malloc error!\n");  
  178.         return -1;  
  179.     }  
  180.   
  181.     /* 将分配的10个元素依次填充数据并加入到链表当中 */  
  182.     for(i = 0; i < 10; i++)  
  183.     {  
  184.         lists[i].id = list_id++;  
  185.         sprintf(lists[i].data, "TECH-PRO - %d", i);  
  186.   
  187.         list_add(&list_head, &lists[i]);  
  188.     }  
  189.   
  190.     /* 填充这个结构体并加入链表当中 */  
  191.     temp_list.id = list_id++;  
  192.     sprintf(temp_list.data, "temp_list");  
  193.     list_add(&list_head, &temp_list);  
  194.   
  195.     /* 删除链表中开始位置、中间位置、尾部的元素 */  
  196.     list_del(&list_head, 0);  
  197.     list_del(&list_head, 5);  
  198.     list_del(&list_head, 10);  
  199.   
  200.     /* 改变id为4的元素所对应的值为 "change!!!" */  
  201.     list_chg(&list_head, 4, "change!!!");  
  202.   
  203.     /* 查询链表中id为4的元素结点的内容 */  
  204.     list_query(&list_head, 4);  
  205.   
  206.     return 0;  
  207. } 
C语言——单向链表
2301_79695216的博客
07-21 1020
线性表的链式存储结构，我们叫做链表。将线性表L=(a0,a1,……,an-1)中各元素分布在存储器中的不同存储区域，线性表中的各元素称为结点，通过地址或指针建立结点之间的联系，所得到的存储结构为链表 结构。
C语言单向链表的基本操作12个
03-06
本篇将详细介绍C语言中单向链表的12个基本操作，这些操作对于理解和应用链表至关重要。 1. **创建链表**: 创建链表首先需要定义一个节点结构体，通常包含数据域和指向下一个节点的指针。然后，我们需要一个头指针来...
单向链表的C语言实现
11-07
C语言指针实现单向链表 初学者看，非常简单。 时间非常多的功能不同位置的插入、删除、查找；
C语言单向链表的实现
无界编程
10-30 5万+
一个简单结点的结构体表示为：    struct note    {       int  data；              /*数据成员可以是多个不同类型的数据*/       struct  note  *next；      /*指针变量成员只能是-个*/    }；  一个简单的单向链表的图示 1．链表是结构、指针相结合的-种应用,它是由头、中间、尾多个链环组成的单方向可伸缩的链表,链
C语言的链表实现
weixin_73728044的博客
10-16 2649
C语言各种链表学习记录
C语言实现链表
最新发布
m0_74506452的博客
08-10 1027
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表分为:带哨兵位/不带哨兵位双向/单向循环/不循环。
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
链表的实现(C语言)
编程技巧分享
02-03 7693
链表的意义
C语言链表的实现
m0_49151977的博客
07-27 623
title: C语言链表的实现 date: 2021-07-26 20:13:53 tags: c语言、链表 本文实现了数据结构中链表的c语言表达，本且尝试创建一个完整文件而非单一的.c文件。使用的IDE是VS2019，作为c语言的初学者，许多地方做的不够完善还请海涵。在代码过程中遇到的问题与解答已附在代码中。个人博客：https://guotianyu-2020.github.io，欢迎关注。 1.文件之间的“沟通” 设置main.c文件作为主文件，single dir.c存放链表的各种函数，he.
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 64万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
链表C语言实现
m0_51765966的博客
12-20 257
主函数内 #include<stdio.h> #include"list.h" #include<malloc.h> //双向带头循环链表 void test() { List lst; ListInit(&lst); printf("尾插：\n"); ListPushBack(&lst, 1); Print(&lst); ListPushBack(&lst, 2); Print(&lst); ListPushBack(&a
链表 --- C语言实现
qq_72916130的博客
07-20 2474
本篇文章来详细介绍一下数据结构中的链表。
链表的c语言实现,链表c语言实现
weixin_27645199的博客
05-19 142
View Code#include #include #define MAX_SIZE 50#define MIN_SIZE 32struct role{int number;char name[MAX_SIZE];char sex[MIN_SIZE];char address[MAX_SIZE];int age;struct role *next;};struct role *cr...
C语言-链表(单向链表、双向链表)
12-17 886
在前面章节已经学习了数组的使用，数组的空间是连续空间，数组的大小恒定的，在很多动态数据存储的应用场景下，使用不方便；而这篇文章介绍的链表结构，支持动态增加节点，释放节点，比较适合存储动态数据的应用场景，而且链表的空间是存储在堆上面的，可以动态分配，释放。从效率上来讲，数组的空间是连续的，查询、读取数据数组占优势；链表的优势在于节点可以动态增加、动态删除，删除支持任意位置的节点删除。
C语言系列(7) --- C语言之链表的实现
Fug_Lee的博客
05-21 1306
一：链表的概念 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 二：链表的结构 （1）单链表 （2）带头结点的单链表 （3）双向链表 （4）循环单链表 （5）双向循环链表 注释： （1）无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 （2）带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代
链表（c语言实现）
zjq_love的博客
03-30 2万+
1.链表的分类 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： （1）单向或者双向 （2）带头或者不带头 （3）循环或者非循环 虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构： 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。 2.无头单向非循环链表的实现 // ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值