单链表的增删查改等基本操作的实现（C语言版）

已于 2025-04-21 11:02:07 修改
阅读量282 收藏
点赞数
分类专栏： C语言数据结构 文章标签： c语言 链表 数据结构
于 2023-03-15 17:15:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kpl_20/article/details/129557590
版权
文章详细介绍了单链表的概念、结构以及它的实现方式，包括动态申请节点、链表的插入、删除等基本操作。同时，提到了单链表的优点（如灵活插入删除）和缺点（如额外内存消耗和访问效率较低）。文章通过代码示例展示了如何在C语言中实现单链表的各种功能，并提供了测试用例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

单链表

链表的概念及结构

概念：

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

结构：

  1. 逻辑结构：是指数据对象中数据元素之间的相互关系。便于讲解使用。
    逻辑结构

  2. 物理结构：是指数据的逻辑结构在计算机中的存储形式，因此也称为存储结构是面向计算机的。
    物理结构

注意：

观察上面两张图片可以发现，链式结构在逻辑上是连续的，但是在物理上不一定连续

链表的分类

链表的结构非常多样，八种链表结构。

八种链表结构

  1. 四种单向链表组合
    单向的四种链表组合

  2. 四种双向链表组合
    四种双向链表组合

六种链表样式

  1. 单向或双向
    单向或双向链表

  2. 带头或不带头
    带头或不带头链表

  3. 循环或非循环
    循环或非循环链表

小结

虽然链表结构很多，但是我们实际中最常用的还是两种链表结构：无头单向非循环链表和带头双向循环链表。

本篇介绍的是无头单向非循环链表（结构简单）
无头单向非循环链表

单链表的实现

我们把函数的声明、实现和测试分别写在三个文件。
分别是：SLTNode.h / SLTNode.c / test.c

这里特别需要注意：因为存在修改地址的情况，所以需要传二级指针。
这里可以这样理解：改变int需要传int*，那么改变int*则需要传int**

在单链表中也不需要专门写一个初始化函数，在BuySLTNode这个函数就会对数据和指针初始化。在定义结构体变量的时候置空就可以了。

函数的声明
SLTNode.h:

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//单链表类型重定义，重定义的原因便于修改
typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;    
	struct SListNode* next;
}SLTNode;


//动态申请一个节点
SLTNode* BuySLTNode(SLTDataType x);

//单链表打印
void SLTPrint(SLTNode* phead);

//单链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);

//单链表头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//单链表的尾删
void SLTPopBack(SLTNode** pphead);

//单链表的头删
void SLTPopFront(SLTNode** pphead);

//单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//单链表在pos前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//单链表在pos位置删除
void SLTErase(SLTNode** pphead, SLTNode* pos);

//单链表在pos位置后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//单链表删除pos位置之后的值
void SLTEraseAfter(SLTNode* pos);

//单链表摧毁
void SLTDestroy(SLTNode** pphead);

函数的实现：这一部分，有些函数没有对指针进行断言，函数断言需要因地制宜，有些函数在其内部需要用NULL就不能进行断言，有些用不到就需要断言。

SLTNode.c:
//下面有些函数因为存在修改头节点的原因，所以要用二级指针

#include "SLTNode.h"

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (NULL == newnode)
	{
		perror("BuySLTNode::malloc");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}


//这里没有对phead断言，是因为要使用phead来做结束标志
void SLTPrint(SLTNode* phead)
{
	//使用头节点，需要再定义一个结构体指针，因为如果后续操作还需要头节点，方便使用。
	SLTNode* cur = phead;

	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}


void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	//这里pphead是二级指针指向phead是不能为空的，使用要进行断言
	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);
	SLTNode* tail = *pphead;
	
	//判断链表是否为空，为空直接放在头节点
	if (NULL == tail)
	{
		*pphead = newnode;
		return ;
	}
	
	//链表不为空情况
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newnode;
	
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);

	//头插不需要考虑额外情况，直接插入就行
	newnode->next = *pphead;
	*pphead = newnode;

}

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	//对*pphead进行断言的原因，是因为如果链表为空就没法删除，
	assert(*pphead);
	
	//定义两个指针，
	SLTNode* tail = *pphead;
	SLTNode* prev = *pphead;
	
	//判断链表是不是一个元素，如果是直接释放头节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		//释放后置空，保持好习惯
		*pphead = NULL;
		return;
	}
	
	//解决链表不止一个元素的情况
	while (tail->next != NULL)
	{
		//两个指针一前一后，这里遇到情况可以直接用前指针操作
		prev = tail;
		tail = tail->next;
	}

	free(prev->next);
	tail = NULL;
	prev->next = NULL;

}


void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	//对*pphead进行断言的原因，是因为如果链表为空就没法删除，
	assert(*pphead);
	
	//保存要删除的节点，链接完成后再删除
	SLTNode* save = *pphead;
	*pphead = save->next;
	free(save);
	save = NULL;
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* cur = phead;
	while (cur)
	{
		//查找函数，如果查找到，直接返回地址，找不到返回NULL
		if (cur->data != x)
		{
			cur = cur->next;
		}
		return cur;
	}
	return NULL;
}

//在pos前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	//pos不能为空，如果为空，不能查找，所以断言
	assert(pos);
	assert(pphead);

	//判断pos是不是第一个的节点，是的话头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
		return;
	}
	
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}

	SLTNode* newnode = BuySLTNode(x);
	prev->next = newnode;
	newnode->next = pos;
	
}

//删除pos
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	//同上
	assert(pphead);
	assert(pos);

	//判断pos是否是头节点，是直接头删即可
	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		//删除pos位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		
		//先链接后释放
		prev->next = pos->next;
		free(pos);
	}
}

//pos后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

//pos后删除
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//pos后不能为空，为空没意义
	assert(pos->next);

	//先保存要删除的地址，然后链接完成之后，再进行释放
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

//摧毁链表
void SLTDestroy(SLTNode** pphead)
{
	//这里因为要使用头节点，所以不对*pphead进行断言
	assert(pphead);
	
	
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* save = cur->next;
		free(cur);
		cur = NULL;
		cur = save;
	}
}

测试：建议在写的同时多进行测试，并且多些几组测试，以防出现为空或者野指针等情况。判断所写的函数有没有错误，及时测试，及时修改。

test.c:

#include "SLTNode.h"
void TestSLTNode1()
{
	SLTNode* plist = NULL;

	//尾插+打印
	SLTPushBack(&plist, 1);
	SLTPrint(plist);
	
	//尾插+打印
	SLTPushBack(&plist, 2);
	SLTPrint(plist);
	
	//尾插+打印
	SLTPushBack(&plist, 3);
	SLTPrint(plist);
	
	//尾删+打印
	SLTPopBack(&plist);
	SLTPrint(plist);
	
	//尾删+打印
	SLTPopBack(&plist);
	SLTPrint(plist);
	
	//尾删+打印
	SLTPopBack(&plist);
	SLTPrint(plist);
}


void TestSLTNode2()
{
	SLTNode* plist = NULL;
	
	//头插+打印
	SLTPushFront(&plist, 4);
	SLTPrint(plist);
	
	//头插+打印
	SLTPushFront(&plist, 3);
	SLTPrint(plist);
	
	//头插+打印
	SLTPushFront(&plist, 2);
	SLTPrint(plist);
	
	//头插+打印
	SLTPushFront(&plist, 1);
	SLTPrint(plist);

	//头删+打印
	SLTPopFront(&plist);
	SLTPrint(plist);

	//头删+打印
	SLTPopFront(&plist);
	SLTPrint(plist);

	//头删+打印
	SLTPopFront(&plist);
	SLTPrint(plist);

	//头删+打印
	SLTPopFront(&plist);
	SLTPrint(plist);

	//查找+修改+打印（一般查找函数，用于修改变量）
	SLTNode* ret = SLTFind(plist, 1);
	ret->data *= 2;
	SLTPrint(plist);

}


void TestSLTNode4()
{
	SLTNode* plist = NULL;

	//头插+打印
	SLTPushFront(&plist, 2);
	SLTPrint(plist);

	//头插+打印
	SLTPushFront(&plist, 1);
	SLTPrint(plist);

	//查找+修改+打印
	SLTNode* ret = SLTFind(plist, 1);
	ret->data *= 2;
	SLTPrint(plist);

	//在ret前插入20 + 打印
	SLTInsert(&plist, ret, 20);
	SLTPrint(plist);

	//在ret->next位置删除+打印
	SLTErase(&plist, ret->next);
	SLTPrint(plist);

	//摧毁链表
	SLTDestroy(&plist);
}

int main()
{
	//TestSLTNode1();
	//TestSLTNode2();
	TestSLTNode4();
	return 0;
}

单链表的优点和缺点

优点：

  1. 无需给出链表的初始大小。
  2. 节点的插入和删除确实非常容易。
  3. 没有空余浪费

缺点：

  1. 需要额外的内存。
  2. 访问节点所需的时间很大。尾插、尾删、pos位置插入或删除效率不高

总结

单链表一般不会单独出现，更多是作为其他数据结构的子结构。但是单链表有考点，虽然结构简单，但是需要考虑的方面很多。所以在面试中出现很多

单链表基本练习-删除
Python、C++、HTML、Java
11-07 926
【问题描述】 设有头结点单链表，实现单链表删除。 【输入形式】 第一行输入N，M；N表示单链表表长，M表示执行M次删除； 第二行输入N个整数，建立有头结点单链表； 接着输入M个整数，每个整数表示删除结点的位置（位序）。 【输出形式】 若删除成功，输出删除结点的关键字值；若删除不成功，则输出error。 最后输出执行M次删除后的单链表。
单链表 简单题（单链表基本操作）
菇凉小伙de博客
10-08 1352
题目描述： 有一个带头结点的单链表L=（a1,b1,a2,b2,......an,bn),设计一个算法将其拆分成两个带头结点的单链表L1和L2，其中L1=（a1,a2,a3...an),L2=(b1,b2,b3....bn),要求L1使用L的头结点。 解题思路： 利用原单链表L中的所有节点通过改变指针域重组成两个单链表L1和L2，由于L1中节点的相对顺序与L中的相同，所以采用尾插法建立单链表...
C语言—数据结构之链表结构体 增删改查 以及动态创建链表
最新发布
weixin_60660632的博客
06-28 1434
有两种插入方式：1、节点后面插入 2、节点前面插入。
(超详细！)【C语言】单链表的增删查改（附图解，源码）
qq_74641564的博客
03-04 2148
本文为我对链表学习的过程与理解，适合新手学习交流。内容如题，我将结合画图和截图带领大家更好的理解单链表结构，学习和使用它增删查改的功能！
【数据结构】单链表的增删查改（C语言实现）
在平淡的日子里寻找存在的价值
08-04 5004
单链表的增删查改操作（C语言实现）。
数据结构C语言版 —— 链表增删改查实现(单链表+循环双向链表)
爱敲代码的三毛的博客
12-15 895
链表是用一组任意的额存储单元存储线性表的数据元素(这组存储单元可以是连续的，也可以是不连续的)。简单来说链表是一种**物理结构上非连续**，非顺序的存储结构，数据元素的**逻辑顺序**是通过链表中的**指针链接**次序实现的。
C语言链表——增删改查
weixin_54859557的博客
03-20 3257
链表是一种数据结构，是一种数据存放的思想
C语言实现单链表的增删查改
03-25
本篇文章将深入探讨如何用C语言实现单链表的增、删、查、改四种基本操作。 ### 1. 单链表的基本结构 首先，我们需要定义一个链表节点结构体，如下所示： ```c typedef struct Node { int data; // 数据域，这里...
单链表的增删改查操作详解之C语言版
sunnyoldboy博客
10-22 3184
单链表在应用中经常用到增加新结点、删除结点、修改结点、查找结点等操作，本文针对上述基本操作做了简单汇总，并给出了详细的算法。
使用c语言实现一个单链表的增删查改基本操作代码，并且生成菜单使用它
06-03
好的，以下是使用 C 语言实现单链表的增删查改基本操作的代码，并且生成菜单使用它。 ```c #include #include // 定义链表结构体 typedef struct Node { int data; struct Node* next; } Node; // 初始化链表...
单链表 ，增删查改，视频课程，截图分享，
06-18
在C语言中，单链表可以使用结构体来实现，例如： ```c typedef struct Node { int data; struct Node* next; } Node; ``` 其中，`data`是数据域，`next`是指针域，用于指向下一个节点。 单链表的插入操作可以通过...
掌握C语言单链表操作：增删查改技巧
资源摘要信息: "C语言实现单链表的增删查改" 单链表是计算机科学中基本的数据结构之一，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。在C语言中，单链表的实现是数据结构与算法课程中常见的...
单链表的基本操作的相关题目
chenyifei___的博客
10-20 261
链表： 一种链式存储的线性表，用一组地址任意的存储单元存放线性表的 数据元素，称存储单元为一个节点。链表可以分为带头结点的单链表和不带头结点的单链表。此片文章是不带头结点的单链表 上图为单链表结构，每个节点均有数据域data和指向下一个节点的指针域pNext。 链表优缺点：在执行插入和删除操作是不需要移动元素，但在查询时必须通过头结点进行查询比较麻烦。由于存放元素的地址不连续。因此有可能...
数据结构之单链表，详细解释单链表的增删改查操作，图文并茂，分布实现
ocean&21的博客
11-15 557
数据结构之单向链表，对节点的理解、单链表的定义以及实现，实现链表基本的增删改查操作，理解链表的优缺点
C语言单链表 增 删 改 查
Cgs723的博客
04-25 2133
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。链表就...
C语言数据结构：链表的增删改查及动态创建
m0_74985965的博客
03-10 2596
把它想象成自行车链条，由n个节点组成，可以对这些节点进行“增，删，改，查”等操作，即对数据的操作。 ● 可以进行动态存储分配； ● 可以在节点中定义多种数据类型； ● 链表都有一个头指针，一般以head来表示，存放的是一个地址；● 链表中包含头结点和其它节点两种，头结点是没有数据域的； ● 链表中每个节点都分为两个区域，一个数据域，一个是指针域；
单链表的基本操作之部分习题的讲解
weixin_56169816的博客
05-05 1600
单链表的基本操作之习题篇 1、有一个线性表（a1,a2,a3,…an），n>=2，采用带头结点的单链表L存储，设计一个算法将其就地逆置，空间复杂度为O（1） 解题思路1： ​ 用指针p遍历原单链表，先将头节点L的next域置为NULL而变成一个空链表，然后节点采用头插法插入L中。 示例图： 对应算法如下： void ReverseLinkList(LinkList& L) { LNode* p = L->next, * q; L->next = NULL; //将L
数据结构单链表删除（C语言）
像鱼的博客
05-04 3064
#include <stdio.h> #include <stdlib.h> // 定义链表结构 typedef struct Node { int data; struct Node *next; }Node,*LinkList; // 初始化列表 LinkList initList() { LinkList L = (Node *) malloc (sizeof(Node)); L->next = NULL; return L;.
C语言实现单链表的删除
专业^团队的博客
04-07 4008
一.单链表的按位序删除 //按位序删除（带头结点） bool ListDelete(LinkList &L, int i, int &e) { if (i < 1) { return false; } LNode * p; int j = 0; p = L; while (p != NULL && j < i - 1) { p = p->next; j++; } if (p == NULL) return false;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kpl_20

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值