数据结构——单链表

于 2024-04-06 11:30:00 发布
阅读量1.3k 收藏 9
点赞数 26
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_76613753/article/details/137410775
版权
本文详细介绍了单链表的结构、节点操作，包括打印链表、头部和尾部插入、删除节点以及销毁链表的方法。重点讲解了如何使用指针操作实现链表的基本功能。

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

目录

一、链表

二、单链表的实现

2.1 打印单链表的内容

2.2 开辟新的节点

2.3 单链表的尾插

2.4 单链表的头插

2.5 单链表的尾删

2.6 单链表的头删

2.7 单链表的查找

2.8 在指定位置之前插入数据

2.9 在指定位置之后插入数据

2.10 删除指定的节点

2.11 删除指定的节点之后节点

2.12.销毁单链表

三、完整代码

总结

前言

之前我们了解了数据结构中线性表的顺序表的知识，今天我们来了解线性表中链表的知识。

一、链表

  链表是⼀种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。
  链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加⼏节。只需要将火车⾥的某节车厢去掉/加上，不会影响其他车厢，每节车厢都是独立存在的。、
链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉/加上，不会影响其他⻋厢，每节车厢都是独立存在的。
⻋厢是独立存在的，且每节车厢
都有车门。想象⼀下这样的场景，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从车头走到车尾？
最简单的做法：每节车厢里都放⼀把下⼀节车厢的钥匙。
在链表⾥，每节“车厢”是什么样的呢？
补充说明：
1、链式机构在 逻辑上是连续 的，在 物理结构上不⼀定连续
2、节点⼀般是从 堆上 申请的
3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续
链表中每个节点都是独立申请的（即需要插入数据时才去申请⼀块节点的空间），我们需要通过指针变量来 保存下⼀个节点位置 才能从当前节点找到下⼀个节点。
结合前面学到的结构体知识，我们可以给出每个节点对应的结构体代码：
假设当前保存的节点为整型 
struct SListNode
{
 int data; //节点数据
 struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};
当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数
据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
当我们想要从第⼀个节点走到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的钥匙）就可以了。

二、单链表的实现

单链表也是链表的一种，表示不带头单向不循环链表。
主要接口： 
//SList.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//打印单链表的内容
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** pphead, SLTDataType x);
//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SListDesTroy(SLTNode** pphead);

以上是我们单链表的主要接口，同时我们要定义一个单链表的结构：

//Slist.h

typedef int SLTDataType;//存放数据的类型

typedef struct SListNode {
	SLTDataType data;
	struct SListNode* next;//下一个节点的地址
}SLTNode;

2.1 打印单链表的内容

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

通过pcur来实现对整个链表的遍历，但最后一个节点时，此时pucr->next=NULL，再赋值给pucr，所以跳出循环。然后每次循环打印每个节点中的数据。

2.2 开辟新的节点

对于插入操作，我们需要一个新的节点：

//新的节点
SLTNode* SLTBuyNode(SLTDataType x) {
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL) {
		perror("malloc fail!");
		exit(1);
	}
	newnode->data =x;//节点数据为x
	newnode->next = NULL;///指针变量⽤保存下⼀个节点的地址为空

	return newnode;
}

2.3 单链表的尾插

void SLTPushBack(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* newnode=SLTBuyNode(x);//要插入新的节点

	if (*pphead == NULL) {//如果链表为空
		*pphead = newnode;//头节点为新节点
		return;
	}
	SLTNode* pucr = *pphead;//pucr遍历链表
	while (pucr->next)//如果为最后一个节点
	{
		pucr = pucr->next;//遍历
	}
	pucr->next = newnode;//最后一个节点的next为新节点
}

尾插法就是遍历整个链表，找到最后一个节点，然后再插入同时要考虑链表为空的情况。

2.4 单链表的头插

void SLTPushFront(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;//把新节点的下一个节点设为以前的头节点
	*pphead = newnode;//头节点变为新节点

}

头插法比尾插相比更加快速，因为不用遍历整个链表。

2.5 单链表的尾删

void SLTPopBack(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);//链表不为空
	if ((*pphead)->next == NULL) {//只有一个节点
		free(*pphead);
		*pphead = NULL;
		return;
	}
	SLTNode* ptail = *pphead;//遍历整个链表
	SLTNode* prev = NULL;//遍历时前一个节点
	while (ptail->next != NULL) {//最后一个节点
		prev = ptail;
		ptail = ptail->next;
	}
	prev->next = NULL;//尾删
	free(ptail);//释放最后一个节点
	ptail = NULL;
}

尾删与尾插一样，都是遍历整个链表，找到最后一个节点，只不过操作不一样。

2.6 单链表的头删

void SLTPopFront(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);//链表不为空
	SLTNode* ptail = *pphead;
	*pphead = ptail->next;//头节点为下一个节点
	free(ptail);//释放头节点
	ptail = NULL;

}

我们需要一个指针来存放以前头节点的地址，不然到时候释放找不到地址了。

2.7 单链表的查找

SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* pucr =* pphead;//遍历
	while (pucr) {//直到最后一个节点
		if (pucr->data == x) {
			return pucr;//找到了返回节点
		}
		pucr = pucr->next;
	}
	return NULL;//没找到返回空
}

找到了我们返回的是SLTNode*的节点类型。

2.8 在指定位置之前插入数据

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pphead);
	assert(pos);//节点不为空
	assert(*pphead);//节点不为空了，链表也不能为空

	SLTNode* newNode=SLTBuyNode(x);//插入的新的节点
	if (pos == *pphead) {//在第一个节点插入
		SLTPushFront(pphead, x);//调用头插操作
		return;
	}
	SLTNode* prev = *pphead;//遍历
	while(prev->next != pos){//直到找到了目标节点之前的节点
		prev = prev->next;
	}
    //修改对应的指针连接
	prev->next = newNode;
	newNode->next = pos;
}

如图：

2.9 在指定位置之后插入数据

void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
	assert(pos);
	SLTNode* newNode = SLTBuyNode(x);
    
    //直接修改pos后的节点链接
	newNode->next = pos->next;
	pos->next = newNode;
}
注意：我们要先链接newNode后的链接，不能先把pos和newNode链接，不然会找不到pos后面的节点。

2.10 删除指定的节点

void SLTErase(SLTNode** pphead, SLTNode* pos) {
	assert(pphead);
	assert(pos);//删除节点不为空
	assert(*pphead);//链表不为空
	SLTNode* prev = *pphead;
	if (prev == pos) {//如果删除头节点
		SLTPopFront(pphead);//调用头删
		return;
	}
	while (prev->next != pos) {//找到删除前的节点
		prev = prev->next;
	}
    //删除节点之前的节点链接到删除节点之后的节点
	prev->next = pos->next;
	//释放删除节点
    free(pos);
	pos = NULL;
}

我们要注意不能先释放，不然找不到pos的下一个节点

2.11 删除指定的节点之后节点

void SLTEraseAfter(SLTNode* pos) {
	assert(pos);
	assert(pos->next);//删除节点之后的节点不为空

	SLTNode* del = pos->next;//保存之后的节点
	pos->next = pos->next->next;//pos的下一个节点为下下个节点
	//释放之前保存的节点
    free(del);
	del = NULL;
}

要保存目标节点之后的节点，不然释放就会出现问题。

2.12.销毁单链表

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

	SLTNode* pucr = *pphead;
	while (pucr) {//循环销毁
		SLTNode* next = pucr->next;
		free(pucr);
		pucr =next;
	}
	*pphead = NULL;

}

由于每个节点都是我们动态开辟出来的，所以我们要进行依次的销毁

三、完整代码

Slist.h

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

typedef int SLTDataType;

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

//打印单链表的内容
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** pphead, SLTDataType x);
//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SListDesTroy(SLTNode** pphead);

Slist.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Slist.h"

//打印单链表的内容
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL");
}

//新的节点
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;
}

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* newnode=SLTBuyNode(x);

	if (*pphead == NULL) {
		*pphead = newnode;
		return;
	}
	SLTNode* pucr = *pphead;
	while (pucr->next)
	{
		pucr = pucr->next;
	}
	pucr->next = newnode;
}

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;

}

//尾删
void SLTPopBack(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;
	while (ptail->next != NULL) {
		prev = ptail;
		ptail = ptail->next;
	}
	prev->next = NULL;
	free(ptail);
	ptail = NULL;
}

//头删
void SLTPopFront(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);
	SLTNode* ptail = *pphead;
	*pphead = ptail->next;
	free(ptail);
	ptail = NULL;

}


//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* pucr =* pphead;
	while (pucr) {
		if (pucr->data == x) {
			return pucr;
		}
		pucr = pucr->next;
	}
	return NULL;
}

在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pphead);
	assert(pos);
	assert(*pphead);

	SLTNode* newNode=SLTBuyNode(x);
	if (pos == *pphead) {
		SLTPushFront(pphead, x);
		return;
	}
	SLTNode* prev = *pphead;
	while(prev->next != pos){
		prev = prev->next;
	}
	prev->next = newNode;
	newNode->next = pos;
}

//在指定位置之后插⼊数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
	assert(pos);
	SLTNode* newNode = SLTBuyNode(x);
	
	newNode->next = pos->next;
	pos->next = newNode;
}

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos) {
	assert(pphead);
	assert(pos);
	assert(*pphead);
	SLTNode* prev = *pphead;
	if (prev == pos) {
		SLTPopFront(pphead);
		return;
	}
	while (prev->next != pos) {
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos) {
	assert(pos);
	assert(pos->next);

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

//销毁链表
void SListDesTroy(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);

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

}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Slist.h"

void Slisttest1()
{
	SLTNode * pf =NULL;
	SLTPushBack(&pf, 1);
	SLTPushBack(&pf, 2);
	SLTPushBack(&pf, 3);
	SLTPushBack(&pf, 4);
	SLTPushFront(&pf, 5);
	SLTPushFront(&pf, 7);
	SLTPushFront(&pf, 6);
	SLTPushFront(&pf, 8);
	//SLTPopFront(&pf);
	SLTNode *p=SLTFind(&pf,8);
	//在指定位置前后插入数据
	//SLTInsert(&pf, p, 0);
	//SLTInsertAfter(p, 5);

	//SLTErase(&pf, p);
	//SLTEraseAfter(p);

	SListDesTroy(&pf);
	
	SLTPrint(pf);
}


int main() {
	Slisttest1();
	return 0;
}

总结

上述文章我们讲了单链表的实现，希望对你有所帮助。

回首o
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值