单链表的增删改查

已于 2024-02-27 19:50:30 修改
阅读量904 收藏 16
点赞数 21
分类专栏： 数据结构 文章标签： 数据结构
于 2024-02-02 15:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71964451/article/details/135894912
版权
本文详细介绍了链表的基本概念，结构（包括单链表和带头双向循环链表），以及增删改查等操作的实现步骤，包括插入（头插、尾插）、删除（头删、尾删）和查找功能。
摘要由CSDN通过智能技术生成

小伙伴们，顺序表的增删改查已经学会了，今天我们学习比顺序表还难“亿”点点的链表，也需要增删改查。跟顺序表一样，还是需要创建三个文件SList.h,SList.c和test.c，然后做一些准备工作，具体文件的说明跟顺序表一样，忘了的小伙伴们可以去看一下哦。好了，进入单链表的学习吧。

1. 链表的概念及结构

概念：链表是⼀种物理存储结构上非连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。
链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只需要将⽕⻋⾥的某节⻋厢去掉/加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。
车厢是独⽴存在的，且每节⻋厢都有车门。想象⼀下这样的场景，假设每节⻋厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从⻋头⾛到⻋尾？
最简单的做法：每节车厢⾥都放⼀把下⼀节车厢的钥匙。

 在链表⾥，每节“⻋厢”是什么样的呢？

与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“结点/节点”
节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。
图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希
望plist“指向”第⼆个节点时，只需要修改plist保存的内容为0x0012FFA0。
为什么还需要指针变量来保存下⼀个节点的位置？
链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。
结合前⾯学到的结构体知识，我们可以给出每个节点对应的结构体代码：
假设当前保存的节点为整型： 
struct SListNode
{
 int data; //节点数据
 struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};
当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数
据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的钥匙）就可以了。
给定的链表结构中，如何实现节点从头到尾的打印？
还是先对int类型取一个别名，方便后期对类型进行修改。
SList.h 
typedef int SLTDataType;//修改别名
//链表是由节点组成
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//typedef struct SListNode SLTNode;

void SLTPrint(SLTNode* phead);//phead是第一个节点

SList.c

void SLTPrint(SLTNode* phead) {
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

test.c

void SlistTest01() {
	//一般不会这样去创建链表，这里只是为了给大家展示链表的打印
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 1;
	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	node2->data = 2;
	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	node3->data = 3;
	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
	node4->data = 4;

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;

	SLTNode* plist = node1;
	SLTPrint(plist);//实参
}

Ok，打印链表已经完成了。根据图来看逻辑还是挺清楚的，应该很好理解。
好了，接下来实现链表的增删改查吧。

2.插入数据

尾插：分为2种情况，链表为空和不为空，当链表为空的时候，如图所示，就是把新插入的数据的next指向NULL，然后新插入的4就作为第一个节点。当链表不为空的时候就让节点3的next指向新插入的节点4的data，然后next指向NULL。

根据这个逻辑可能会有小伙伴们这样写。（我就直接画图解释，为了节省篇幅）

结果是NULL，不应该是1->NULL吗？解释如下（我可能说的不是很清楚，也不好理解，因为二级指针还没完全学懂，但是在这里的解释应该是没有问题的，厉害的小伙伴们可以自己想想看）

如果小伙伴们还不明白的话，可以这么理解：

OK,这么改就没有问题了，正确代码如下：

void SLTPushBack(SLTNode** pphead, SLTDataType x);

void SLTPushBack(SLTNode** pphead, SLTDataType x) {
	assert(pphead);//不能传空

	//SLTNode* newnode = SLTBuyNode(x);
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	//链表为空，新节点作为phead
	if (*pphead == NULL) {
		*pphead = newnode;
		return;
	}
	//链表不为空，找尾节点
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptail就是尾节点
	ptail->next = newnode;
}

接下来试着测试一下

运行成功。插入操作都需要判断是否要申请新的节点，所以把申请节点写成一个函数，如下

SLTNode* SLTBuyNode(SLTDataType x) {
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL) {
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

头插：也是2种情况，链表为空和不为空。不为空时就要把新节点的next指向phead，然后把原来第一个节点也就是phead的位置变成新节点，也就是新的头。为空的情况与尾插一样，把新节点指向phead，此时phead就是新的节点。（注意：图中是phead，与代码中不同，是因为图中的头不是pphead，只是为了方便理解，但是意思一样，具体的运行参考代码即可）

void SLTPushFront(SLTNode** pphead, SLTDataType x);

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

	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

测试

3.删除数据

尾删：当链表为空不能进行删除，不为空时分为2种情况，有多个节点和只有一个节点。

void SLTPopBack(SLTNode** pphead);

void SLTPopBack(SLTNode** pphead) {
	assert(pphead);
	//链表不能为空
	assert(*pphead);

	//链表不为空
	//链表只有一个节点/有多个节点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;//prve是前驱节点
	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}

	prev->next = NULL;
	//销毁尾结点
	free(ptail);
	ptail = NULL;
}

测试

头删：先让头节点走向下一个节点，让第二个节点成为新的头节点，然后释放第一个节点

void SLTPopFront(SLTNode** pphead);

void SLTPopFront(SLTNode** pphead) {
	assert(pphead);
	//链表不能为空
	assert(*pphead);

	//让第二个节点成为新的头
	//把旧的头结点释放掉
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

测试

经过测试可知不能对空节点进行删除 。

4.查找数据

SLTNode* SLTFind(SLTNode** pphead, SLTDataType x);

SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) {
	assert(pphead);

	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur) //等价于pcur != NULL
	{
		if (pcur->data == x) {
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

测试

 5.指定位置之前插入数据

解决问题的关键就是找到pos的前驱节点prev。对prev,newnode,pos修改对应的指针连接即可。

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pphead);
	assert(pos);
	//要加上链表不能为空，因为pos是链表里的有效节点
	//链表如果为空，pos也为空
	assert(*pphead);

	SLTNode* newnode = SLTBuyNode(x);
	//pos刚好是头结点
	if (pos == *pphead) {
		//头插
		SLTPushFront(pphead, x);
		return;
	}

	//pos不是头结点的情况
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//prev -> newnode -> pos
	prev->next = newnode;
	newnode->next = pos;
}

测试

6.指定位置之后插入数据

void SLTInsertAfter(SLTNode* pos, SLTDataType x);

void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);

	//pos newnode pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}

测试

7.删除指定位置节点

void SLTErase(SLTNode** pphead, SLTNode* pos);

void SLTErase(SLTNode** pphead, SLTNode* pos) {
	assert(pphead);
	assert(*pphead);
	assert(pos);

	//pos刚好是头结点，没有前驱节点，执行头删
	if (*pphead == pos) {
		//头删
		SLTPopFront(pphead);
		return;
	}

	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//prev pos pos->next
	prev->next = pos->next;//先改方向，再释放节点
	free(pos);
	pos = NULL;
}

测试

8.删除指定位置之后的节点

void SLTEraseAfter(SLTNode* pos);

void SLTEraseAfter(SLTNode* pos) {
	assert(pos);
	//pos->next不能为空
	assert(pos->next);

	//pos  pos->next  pos->next->next
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

8.销毁链表

void SListDesTroy(SLTNode** pphead);

void SListDesTroy(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

OK，写到这里就是全部完成了。接下来介绍一下链表的分类

9.链表的分类

链表的结构⾮常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：
链表的说明：
这里的头节点简单来说是哨兵位，只是起放哨作用，不保存任何数据。
虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构： 单链表 和 双向带头循环链表
1. ⽆头单向⾮循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结
构的⼦结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。
2. 带头双向循环链表：结构最复杂，⼀般⽤在单独存储数据。实际中使⽤的链表数据结构，都
是带头双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带
来很多优势，实现反⽽简单了，后⾯我们代码实现了就知道了。
到这里单链表算是完成了，希望小伙伴们可以认真的看完并理解。后面我们更新更多的知识点。如果觉得这些对你有帮助的话，帮忙点点赞并关注一下，感谢各位。
持之以恒的天秤
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值