【探索数据结构】线性表之单链表

池央

已于 2024-05-26 15:28:53 修改

阅读量1.5k

点赞数 60

分类专栏：数据结构文章标签：开发语言学习数据结构 c语言

于 2024-05-19 21:40:16 首次发布

本文链接：https://blog.csdn.net/2301_80840905/article/details/139022681

版权

数据结构专栏收录该内容

12 篇文章 0 订阅

订阅专栏

🎉🎉🎉欢迎莅临我的博客空间，我是池央，一个对C++和数据结构怀有无限热忱的探索者。🙌

🌸🌸🌸这里是我分享C/C++编程、数据结构应用的乐园✨

🎈🎈🎈期待与你一同在编程的海洋中遨游，探索未知的技术奥秘💞

📝专栏指路:

📘【C++】专栏：深入解析C++的奥秘，分享编程技巧与实践。

📘【数据结构】专栏：探索数据结构的魅力，助你提升编程能力。

前言

回顾：线性表之顺序表

顺序表的问题及思考

1.中间/头部的插入删除，时间复杂度为0(N)

2.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

3.增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100,满了以后增容到200,我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

思考：如何解决以上问题呢?

是否存在一种数据结构，能够解决以上顺序表表现出来的问题：

1)中间/头部的插入删除，可以一步到位，不需要挪动数据

2)不需要扩容

3)不会造成空间

答案是本篇主角——(单)链表

文章重点介绍:不带头节点不循环的单链表

一、链表

链表是一种物理存储单元上非连续、非顺序的存储结构，其数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点组成，每个结点都包含两个部分：数据域和指针域。数据域用于存储数据元素的信息，而指针域则存储着指向下一个结点的地址信息。有单链表、双链表、循环链表

优点：动态内存分配、插入和删除高效、空间利用率高

缺点：访问元素效率低、有额外的空间开销、缓存不优好

二、单链表

1.概念

单链表是一种线性数据结构，其中元素在逻辑上按照线性顺序排列，但在物理内存中通过指针进行链接。每个元素（称为节点/结点）都包含两部分信息：数据域和指针域。数据域存储节点的值或数据，而指针域则包含指向下一个节点的指针。

2.分类

（1）带头节点

在单链表中，第一个节点之前通常有一个头指针（或称为头节点），它指向链表中的第一个数据节点。如果链表为空，则头指针通常指向空（NULL）。链表的最后一个节点的指针域被设置为空（NULL），以表示链表的结束。

（2）不带头节点

不带头节点的单链表，我们直接通过头指针指向第一个数据节点，而不需要额外的头节点作为起始点。

3.代码示例

创建单链表结构

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

三、对单链表的操作

（0）打印

//打印
void SLTPrint(SLTNode* phead)
{
	//创建指向第一个节点的指针的指针，让phead无需改变
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

（1）创建一个新节点

//创建一个新节点
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);//申请空间成功会返回0
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

（2）尾插

有链表为空和非空两种情况

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//*pphead是指向第一个节点的指针， 存放第一个节点的地址
	//创建一个新节点
	SLTNode* newnode = SLTBuyNode(x);
	//空链表
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{//非空链表，找尾
	 //创建指向第一个节点的指针的指针，让*phead无需改变
	SLTNode * ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//新节点变为链表的新尾巴
	ptail->next = newnode;
	}
}

思考：为什么要用二级指针来接收实参？

简单来说，想要改变实参，传值无法改变，要通过传实参的地址给形参，形参的改变才会影响实参

（3）头插

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//*pphead是指向第一个节点的指针， 存放第一个节点的地址
	//创建一个新节点
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

（4）查找

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	//不改变头结点，防止要多次遍历时找不到头结点
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

（5）头删

//头删
void SLTDelFront(SLTNode** pphead)
{
	assert(pphead && *pphead);//链表不能为空
	//无论有几个节点都适用
	SLTNode* next = (*pphead)->next;//保存第二个节点的地址
	free(*pphead);
	*pphead = NULL;
	*pphead = next;//原本的第二个节点成为新头结点
}

（6）尾删

//尾删
void SLTDelBack(SLTNode** pphead)
{
	//可能会修改头节点地址所以还是使用二级指针
	assert(pphead && *pphead);//链表不能为空
	//链表只有一个节点
	if ((*pphead)->next == NULL)//->优先级高于*
	{
		free(*pphead);
		*pphead = NULL;
	}
	//多个节点
	SLTNode* ptail = *pphead;
	SLTNode* prev = *pphead;
	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}
	prev->next = NULL;
	free(ptail);
	ptail = NULL;
}

（7）指定位置之前插入

//指定位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);//链表不能为空
	assert(pos);
	//创建一个新节点
	SLTNode* newnode = SLTBuyNode(x);
	//相当于头插
	if ((*pphead) == pos)
	{
		//pphead存放指向第一个节点指针的地址
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//prev->newnode->pos
		newnode->next = pos;
		prev->next = newnode;
	}
}

（8）指定位置之后插入

//指定位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	//为什么不需要头结点，因为在指定位置插入是这样的逻辑
	//pos-newnode-pos->next,通过pos我们就能找到他的下一个节点
	assert(pos);
	//创建一个新节点
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
	//思考：上面两行代码顺序互换可以吗？
}

不相同，不可以互换位置，第二中代码pos->next指针先指向了newnode那么原先pos的下一个节点的地址就会找不到

（9）删除指定节点

//删除指定节点pos
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);//链表不能为空
	assert(pos);
	if ((*pphead) == pos)
	{
		//相当于头删
		SLTDelFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next!=pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

（10）删除指定节点之后的数据

// 删除指定节点pos之后的数据
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	//如果没有用del来存放pos->next会怎么样？
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

（11）销毁

一个一个销毁

/销毁
void SLTDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);//链表不能为空
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		//如果没有保存pcur->next的地址
		// 在pcur释放掉后，剩余节点找不到了，无法销毁
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

四、测试（仅供参考）

#include"SList.h"
void STListTest01()
{
	//创建节点
	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;
	//链接节点
	node1->next = node2;
	node2->next = node3;
	node3->next = NULL;
	//创建指向第一个节点的指针，让node1无需改变
	SLTNode* plist = node1;
	//调用打印
	SLTPrint(plist);
	
}
void STListTest02()
{
	SLTNode* plist = NULL;
	SLTNode* p = NULL;
	//尾插
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&p, 3);
	plist->next->next = p;
	SLTPushBack(&p, 4);
	SLTPrint(plist);
	//头插
	SLTPushFront(&plist, 5);
	SLTPrint(plist);
	//尾删
	SLTDelBack(&plist);
	SLTPrint(plist);
	//头删
	SLTDelFront(&plist);
	SLTPrint(plist);
	SLTNode*find=SLTFind(plist, 3);
	//指定位置之前插入
	SLTInsert(&plist, find, 5);
	SLTPrint(plist);
	//指定位置之后插入
	SLTInsertAfter(find, 10);
	SLTPrint(plist);
	//删除指定节点
	/*SLTErase(plist, find);*/
	//删除指定节点之后数据
	SLTEraseAfter(find);
	SLTPrint(plist);
	//销毁链表
	SLTDestroy(&plist);
	SLTPrint(plist);

}
int main()
{
	//STListTest01();
	STListTest02();
}

下回预告：线性表之双链表

持续更新中...

敬请期待