数据结构——链表

做人不要太理性2024-08-13 17:47

目录

链表基础知识

链表的概念

基本特点

分类

基本操作（接口）

单链表的实现

定义

创建新节点

增、删、查、改操作

双链表的实现

定义

初始化（创造哨兵节点）

增、删、查、改操作

顺序表和链表的区别

轻松无痛玩转链表

链表基础知识

链表的概念

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

基本特点

  1. 动态大小：链表的大小可以在运行时动态变化，不需要在创建时指定固定的大小。
  2. 元素连接：每个元素（通常称为节点）存储数据，并包含一个或多个指针指向列表中的其他节点。
  3. 无需连续内存：由于元素通过指针连接，它们不需要在内存中连续存放，这使得内存使用更加灵活。
  4. 插入和删除操作：在链表中插入或删除节点通常比数组更快，因为这些操作不需要移动其他元素。

分类

1.单向与非单向

2.带头与非带头（有没有哨兵节点）

哨兵节点就是一个存储非有效数据的虚拟节点，他不是数据结合的一部分，可以简化删除操作，避免空链表，统一处理逻辑。

3.循环与非循环

常见的链表就有不带头单向非循环链表 和带头双向循环链表。

基本操作（接口）

  • 插入：在链表的特定位置添加新节点。
  • 删除：移除链表中的特定节点。
  • 搜索：查找链表中的特定值。
  • 遍历：按顺序访问链表的所有节点。

所以总的来说，链表适用于当数据结合频繁变化，需要快速插入和删除，内存空间分散的场景。

单链表的实现

单链表也就是不带头单向非循环链表。

定义

cpp 复制代码 
//方便后续更改类型
typedef int SLTDataType;

//定义链表节点
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

创建新节点

cpp 复制代码 
//创建新节点
SLTNode* SLTCreateNode(SLTDataType x)
{
	//malloc出一个节点
    SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(1);
	}

    //赋值
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

增、删、查、改操作

尾插

只需要在链表末尾增添节点，修改指针就可以了。

cpp 复制代码 
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//先创造一个新节点
	SLTNode* newnode = SLTCreateNode(x);
	
	//空链表的情况
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//非空链表
		//找到尾节点
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}
}

细节：因为涉及到phead指针的修改，所以参数得传二级指针。

（*pphead == phead）

找到尾节点需要判断当前节点的下一节点是否为空。（ptail->next）

所以总的来说，尾插需要注意三点。

1.不要忘记链表为空的情况。

2.传phead的二级指针。

3.找尾节点。

头插

头插非常简单，创建新节点，然后链接在链表头部就行。

cpp 复制代码 
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//先创造一个新节点
	SLTNode* newnode = SLTCreateNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

尾删

要注意判断只有一个节点的情况和判断链表为空的情况（assert(pphead && *pphead)）。

cpp 复制代码 
//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	
	//只有一个节点的情况
	if ((*pphead)->next == NULL)//->运算符优先级高于*
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//找到尾节点以及上一个节点
		SLTNode* ptail = *pphead;
		SLTNode* prev = *pphead;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

头删

删除头节点前要把下一个节点存储起来，还是要注意判断链表为空的情况。

cpp 复制代码 
//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}

在pos位置之前插入

注意：

1.注意判断空链表，不能再空节点前插入。

2.pos不能为空。

3.pos是头节点的情况。

cpp 复制代码 
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	//链表不能为空链表，不能在一个空节点前插入一个节点
	assert(pphead && *pphead);
	//不能插入一个空节点
	assert(pos);

	//pos是头节点的情况，头插
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTCreateNode(x);

		//找到pos的前一个节点
		SLTNode* prev = *pphead;
		while (prev->next != pos)//如果pos是头节点，那么这个循环就达不到目的
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

在pos位置之后插入

cpp 复制代码 
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLTCreateNode(x);
	//下面两行代码顺序不能乱
	newnode->next = pos->next;
	pos->next = newnode;
}

注意判断pos位置不能为空。

查找

遍历链表就可以了

cpp 复制代码 
//查找
SLTNode* SLTfind(SLTNode* phead, SLTDataType x)
{
	//空节点返回null，不用assert
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

删除pos节点

找到pos的下一个节点，pos的前一个节点，更改指针，free掉pos节点就行了。

注意判断链表为空和pos节点为空的情况。

cpp 复制代码 
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);

	//pos是头节点
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)//如果pos是头节点，那么这个循环就达不到目的
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

删除pos之后的节点

注意判断pos之后的节点是不是空节点。

cpp 复制代码 
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

销毁链表

遍历链表就行，把要删除的节点提前存起来就行，注意判断链表为空的情况。

cpp 复制代码 
//销毁链表
void SLTDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
 }

双链表的实现

定义

cpp 复制代码 
typedef int LTDataType;

typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

初始化（创造哨兵节点）

cpp 复制代码 
//申请一个节点
LTNode* CreateNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	//双向链表是带头双向循环的，所以初始情况哨兵节点前指针和后指针要指向自己，不然不是循环
	node->next = node->prev = node;
	return node;
}

//初始化 创造一个哨兵位
void LTinit(LTNode** pphead)
{
	//
	*pphead = CreateNode(-1);
}

增、删、查、改操作

尾插

cpp 复制代码 
​
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	//双向链表是空链表时，指的是只有一个哨兵位
	//保证链表不是空链表
	assert(phead);

	//创造新节点
	LTNode* newnode = CreateNode(x);

	//有效节点的最后一个节点通过phead的prev指针找到
	LTNode* ptail = phead->prev;

	//新节点的前指针指向有效节点的最后一个节点ptail
	newnode->prev = ptail;
	//新节点的后指针指向头节点phead
	newnode->next = phead;

	ptail->next = newnode;
	phead->prev = newnode;
}

​

细节：这里的phead不用传二级指针，因为不涉及phead的改变，包括接下来的头插也是。

头插

头插指的是插入到第一个有效节点的前面，也就是哨兵位节点的后面。

cpp 复制代码 
//头插,插在哨兵位之后，第一个有效节点之前
void LTPushFront(LTNode* phead, LTDataType x)
{
	//保证有一个哨兵位
	assert(phead);

	LTNode* newnode = CreateNode(x);

	newnode->prev = phead;
	newnode->next = phead->next;

	phead->next->prev = newnode;
	phead->next = newnode;
}

尾删

删除有效节点的最后一个节点，注意判断链表为空的情况（没有有效节点，只有哨兵位）。

cpp 复制代码 
//尾删,删的是有效节点
void LTPopBack(LTNode* phead)
{
	//链表不能为空且得有有效节点
	assert(phead && phead->next != phead);

	LTNode* del = phead->prev;

	del->prev->next = phead;
	phead->prev = del->prev;

	free(del);
	del = NULL;
}

头删

删除有效节点的第一个节点，注意判断链表为空的情况。

cpp 复制代码 
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);

	LTNode* del = phead->next;

	del->next->prev = phead;
	phead->next = del->next;

	free(del);
	del = NULL;
}

在pos位置之后插入数据

cpp 复制代码 
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode = CreateNode(x);

	newnode->prev = pos;
	newnode->next = pos->next;

	//这里顺序不能颠倒
	pos->next->prev = newnode;
	pos->next = newnode;
}

注意后两句代码的顺序是一定不能颠倒的。

查找

寻找指定数据，返回该节点，遍历链表即可。

注意判断链表为空的情况。

cpp 复制代码 
//找指定数据
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead && phead->next != phead);

	LTNode* pcur = phead->next;

	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

删除pos节点

cpp 复制代码 
//删除pos节点
void LTErase(LTNode* pos)
{
	assert(pos);

	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(pos);
	pos = NULL;
}

销毁链表

cpp 复制代码 
//销毁链表
void LTDesTroy(LTNode* phead)
{
	//从一个有效节点开始销毁
	LTNode* pcur = phead->next;

	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
	
}

遍历链表，逐个销毁，然后销毁哨兵位就行了。

顺序表和链表的区别

拜拜，下期再见😏

摸鱼ing😴✨🎞

相关推荐
AIAdvocate24 分钟前
Pandas_数据结构详解
数据结构·python·pandas
jiao000011 小时前
数据结构——队列
c语言·数据结构·算法
kaneki_lh1 小时前
数据结构 - 栈
数据结构
铁匠匠匠1 小时前
从零开始学数据结构系列之第六章《排序简介》
c语言·数据结构·经验分享·笔记·学习·开源·课程设计
C-SDN花园GGbond1 小时前
【探索数据结构与算法】插入排序：原理、实现与分析（图文详解）
c语言·开发语言·数据结构·排序算法
CV工程师小林2 小时前
【算法】BFS 系列之边权为 1 的最短路问题
数据结构·c++·算法·leetcode·宽度优先
Navigator_Z3 小时前
数据结构C //线性表（链表）ADT结构及相关函数
c语言·数据结构·算法·链表
还听珊瑚海吗3 小时前
数据结构—栈和队列
数据结构
Aic山鱼3 小时前
【如何高效学习数据结构：构建编程的坚实基石】
数据结构·学习·算法
sjsjs113 小时前
【数据结构-一维差分】力扣1893. 检查是否区域内所有整数都被覆盖
数据结构·算法·leetcode
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07浏览器插件——ModHeader 的分享和学习08Coze扣子平台完整体验和实践（附国内和国际版对比）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CCF-CSP认证考试 202406-3 文本分词 100分题解