数据结构（二）：链表

已于 2022-03-13 11:15:28 修改
阅读量3.1k 收藏 25
点赞数 25
分类专栏： 数据结构 C语言 文章标签： c语言
于 2021-05-02 13:47:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51983604/article/details/116352940
版权

文章目录

一、链表的概念及其结构

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

实际中链表的结构非常多样，以下情况组合起来有8种链表结构：
（1）单向、双向（是否支持向前访问）
（2）带头、不带头（在链表开头是否有一个不存放数据的头结点）
（3）循环、非循环（是否能通过链表的尾结点直接访问到链表的第一个结点）

虽然有这么多的链表的结构，但是实际中最常用的还是下面两种结构：

（1）不带头单向非循环链表

结构如下（逻辑结构）：
在这里插入图片描述
每个结点都是一个结构体，分为两个部分，前一个部分存放数据（数据域），后一个部分存放指向下一个结点的指针（指针域）。

这种链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

（2）带头循环双向链表

结构如下（逻辑结构）：
在这里插入图片描述
每个结点都是一个结构体，分为三个部分，第一个部分存放指向前一个结点的指针，中间部分存放数据，最后一个部分存放指向下一个结点的指针。

这种链表结构最复杂，一般用来单独存储数据。实际中使用的链表数据结构，大多数是带头双向循环链表。这个结构虽然结构复杂，但是使用代码实现以后会带来很多优势，实现起来反而更加简单。

二、单链表的实现

实现不带头单向非循环链表

链表的结构：

typedef int DataType;

typedef struct ListNode
{
	DataType a;
	struct ListNode* next;
}ListNode;

1.单链表的访问

通常我们有链表的第一个结点的地址（plist），那么如何遍历访问每一个结点呢？
只需在每次操作后将plist更新为plist->next，这就让plist向后走了一个结点。

代码如下（示例）：

void ListNodePrint(ListNode* plist)
{
	while (plist != NULL)
	{
		printf("%d->", plist->a);
		plist = plist->next;
	}
	printf("NULL\n");
}

2.单链表头部插入数据

可以很轻松地写出如下代码。

代码如下（示例）：

void ListNodePushFront(ListNode* plist, DataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->a = x;
	newnode->next = plist;
}

但是这段代码执行结束后虽然在链表头部插入了数据为a的新结点，但是plist指向的仍是链表中原来的头结点，plist没有随着头插更新。

注意这里由于需要更新头结点，也就是需要在函数中对一级指针的值进行修改，所以传参时需要传递二级指针（之后的代码同理）。

（由于创建一个值为x的结点的过程需要使用多次，所以这里将其封装为BuyListNode）

代码如下（示例）：

//创建一个值为x的新结点并返回其地址
ListNode* BuyListNode(DataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->a = x;
	newnode->next = NULL;
	return newnode;
}

//头插
void ListNodePushFront(ListNode** pplist, DataType x)
{
	if (*pplist == NULL)
		return;
	ListNode* newnode = BuyListNode(x);
	newnode->next = *pplist;//将newnode与第一个结点连接
	*pplist = newnode;//更新第一个结点
}

3.单链表尾部插入数据

不带头单向非循环链表在找尾结点时需从头遍历，时间复杂度为O(N)，这也是它的缺点。

代码如下（示例）：

void ListNodePushBack(ListNode** pplist, DataType x)
{
	ListNode* newnode = BuyListNode(a);
	if (*pplist == NULL)//链表为空
	{
		*pplist = newnode;
		return;
 	}
	ListNode* cur = *pplist;//从头开始遍历
	while (cur->next != NULL)//找到最后一个结点，注意循环结束的判断条件
		cur = cur->next;//迭代来让cur指针向后遍历
	cur->next = newnode;
}

4.单链表头部删除数据

由于链表可以直接访问头部，所以对头部的操作比较简单。
这里只需要先保存第一个结点的下一个结点next，释放第一个结点，然后将链表的头变为next。

（注意这里的next与链表结构体中的next无关）

代码如下（示例）：

void ListNodePopFront(ListNode** pplist)
{
	//1.链表中没有结点
	if (*pplist == NULL)
		return;

	//2.链表中有多个结点
	else
	{
		ListNode* next = (*pplist)->next;//加小括号保证先进行解引用操作
		free(*pplist);//将第一个结点释放
		*pplist = next;//更新链表的第一个结点
	}
}

5.单链表尾部删除数据

这一步骤情况较多：
（1）链表为空，直接返回
（2）链表中只有一个结点，则删除该节点并将链表的头置为NULL
（3）链表中有多个结点，遍历到尾结点并将其删除

代码如下（示例）：

void ListNodePopBack(ListNode** pplist)
{
	//1.没有结点
	if (*pplist == NULL)
		return;
		
	//2.只有一个结点
	else if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
		return;
	}
	
	//3.多个结点
	ListNode* tail = *pplist;	
	ListNode* prev = *pplist;
	//遍历找到尾结点
	//由于需要得到尾结点的前一个结点（这个结点是新的尾结点），这里用prev表示它的前一个结点
	while (tail->next != NULL)
	{
		prev = tail;
		tail = tail->next;
	}
	
	//删除尾结点
	free(tail);
	tail = NULL;
	//将新的尾结点的next置为NULL
	prev->next = NULL;
}

6.查找单链表中值为x的结点

这一功能只需从头遍历函数，当碰到（第一个）值为x的结点，直接返回它的地址，若找不到则返回NULL。

代码如下（示例）：

ListNode* ListNodeFind(ListNode* plist, DataType x)
{
	ListNode* cur = plist;
	while (cur != NULL)
	{
		if (cur->a == x)
			return cur;//找到直接返回

		cur = cur->next;
	}
	return NULL;//找不到返回NULL
}

7.在某一结点的后面插入一个结点

这个函数通常和ListNodeFind函数一起用，即用ListNodeFind函数来找到“某一结点”，然后在这一结点后插入一个新的结点。

（这里实现的是在某一结点的后面插入新结点，如果要在其前面插入新结点，由于当前链表结构无法访问前一个结点，实现时会非常麻烦）

代码如下（示例）：

//在pos结点的后面插入一个结点
void ListNodeInsertAfter(ListNode* pos, DataType x)
{
	assert(pos);
	ListNode* next = pos->next;
	ListNode* cur = BuyListNode(x);
	//将三个结点连接起来
	pos->next = cur;
	cur->next = next;
}

8.在某一结点的后面删除一个结点

这一函数与ListNodeInsertAfter相似。

代码如下（示例）：

void ListNodeEraseAfter(ListNode* pos)
{
	assert(pos);
	if (pos->next == NULL)
		return;
	ListNode* next = pos->next->next;//得到被删除结点的下一个结点的地址
	free(pos->next);
	pos->next = next;//将链表连接起来
}

三、单链表的优劣

单链表的优势：
（1）可在O(1)的时间复杂度内插入和删除数据，操作时只需要改变指针的指向即可。
（2）动态分配内存空间，用多少开辟多少，不会出现内存浪费的情况，内存利用率高。

单链表的劣势：
（1）以结点为单位存储，在对任意位置进行插入和删除操作时的时间复杂度为O(N)。

四、 带头循环双向链表的实现

上述单链表的功能由于其结构简单，有些地方实现起来较麻烦。下面的双向链表虽然结构复杂一些，但是实现其功能时非常方便。下面实现双向链表的基本功能。

双向链表的结构

typedef int DLData;

typedef struct DListNode
{
	struct DListNode* prev;//指向前一个结点的指针
	struct DListNode* next;//指向后一个结点的指针
	DLData val;//存储数据
}DListNode;

1.双向链表的初始化

这里实现两个函数，初始化一个双向链表和创建一个新结点。

代码如下（示例）：

//创建一个新结点
DListNode* BuyDListNode(DLData x)
{
	DListNode* newnode = (DListNode*)malloc(sizeof(DListNode));
	newnode->val = x;
	newnode->prev = NULL;
	newnode->next = NULL;

	return newnode;
}

//初始化一个双向链表
DListNode* DListNodeInit()
{
	DListNode* newnode = (DListNode*)malloc(sizeof(DListNode));
	newnode->val = -1;//这里可随意赋值，因为双向链表在访问时不会访问头结点的值
	//初始把头结点的prev和next指针都指向自己
	newnode->next = newnode;
	newnode->prev = newnode;

	return newnode;
}

2.双向链表尾部插入数据

代码如下（示例）：

void DListNodePushBack(DListNode* phead, DLData x)
{
	assert(phead);
	DListNode* newnode = BuyDListNode(x);//创建新结点

	DListNode* tail = phead->prev;//找尾，头结点的prev指针就是尾结点

	//连接原来的尾结点和新结点
	tail->next = newnode;//原来的尾结点的next指向新结点
	newnode->prev = tail;//新结点的prev指向原来的尾结点
	
	//连接诶头结点和新结点
	phead->prev = newnode;//头结点的prev指向新结点（也是新的尾结点）
	newnode->next = phead;//新结点的next指向头结点
}

3.双向链表头部插入数据

注意双向链表头部插入数据是指在头结点的下一个结点的位置插入数据。

代码如下（示例）：

void DListNodePushFront(DListNode* phead, DLData x)
{
	assert(phead);

	DListNode* newnode = BuyDListNode(x);

	DListNode* first = phead->next;//找到头结点的下一个结点

	//将新结点前后的结点与新结点连接
	first->prev = newnode;
	newnode->next = first;
	newnode->prev = phead;
	phead->next = newnode;
}

4.双向链表尾部删除数据

代码如下（示例）：

void DListNodePopBack(DListNode* phead)
{
	assert(phead);
	assert(phead == phead->next);//防止链表中只有一个phead，没有别的结点

	DListNode* tail = phead->prev;//找到尾结点
	DListNode* tailPrev = phead->prev->prev;//找到尾结点的前一个结点（这将是新的尾结点）
	free(tail);

	//连接头结点和新的尾结点
	tailPrev->next = phead;
	phead->prev = tailPrev;
}

5.双向链表头部删除数据

代码如下（示例）：

void DListNodePopFront(DListNode* phead)
{
	assert(phead);
	assert(phead == phead->next);

	DListNode* first = phead->next;
	DListNode* firstNext = phead->next->next;//找到新的连接在头结点后的结点
	free(first);

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

6.寻找双向链表中值为x的结点

这里返回的仍是链表从前往后第一个值为x的结点，一旦找到立刻结束。

代码如下（示例）：

DListNode* DListNodeFind(DListNode* phead, DLData x)
{
	assert(phead);
	DListNode* cur = phead->next;

	//从头结点的下一个结点开始遍历寻找
	while (cur != phead)
	{
		if (cur->val == x)
			return cur;
		cur = cur->next;
	}

	//找不到返回空
	return NULL;
}

7.在pos位置前插入一个结点

实现单链表时提到，在某一个位置前插入结点很麻烦，因为单链表的结构决定了它很难访问前面的结点。但到了双向链表就可以很轻松地访问前后的结点，所以在某一个位置前插入结点也很容易实现。

代码如下（示例）：

void DListNodeInsertBefore(DListNode* pos, DLData x)
{
	assert(pos);

	DListNode* newnode = BuyDListNode(x);
	DListNode* prev = pos->prev;//找到pos位置的前一个结点

	//连接新结点，pos结点，pos原来的前一个结点
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

8.删除pos结点

代码如下（示例）：

void DListNodeErase(DListNode* pos)
{
	assert(pos);

	//找到pos的前后两个结点
	DListNode* prev = pos->prev;
	DListNode* next = pos->next;

	//连接这两个结点
	prev->next = next;
	next->prev = prev;
	free(pos);
}

9.得到链表的结点个数

代码如下（示例）：

//判断链表是否为空
int DListNodeEmpty(DListNode* phead)
{
	//如果头结点的下一个还是头结点，说明双向链表中只有这一个结点，认为是空
	return (phead->next == phead);
}

//得到链表的结点个数
int DListNodeSize(DListNode* phead)
{
	assert(phead);

	int size = 0;
	DListNode* cur = phead->next;

	//从第一个结点开始遍历即可
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}

	return size;
}

感谢阅读，如有错误请批评指正

山舟
关注
专栏目录
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 5270
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
数据结构：链表(linked-list)
热门推荐
蜗牛君的奋斗史
05-09 5万+
链表分为单向链表(Singly linked lis)、双向链表(Doubly linked list)、循环链表(Circular Linked list)。
数据结构——链表
最新发布
2301_80373479的博客
08-13 1614
轻松无痛玩转链表
【数据结构】链表
ikun66666的博客
09-05 2138
C语言实现单链表、带头循环链表
链表数据结构
li123128的博客
11-03 459
　　第五章 链表 　　 　　链表数据结构 　　 　　创建链表 　　 　　双向链表 　　 　　循环链表 　　 　　小结 　　 　　这一章你将会学会如何实现和使用链表这种动态的数据结构，这意味着我们可以从中任意添加或移除项，它会按需进行扩张。 　　 　　本章内容 　　 　　链表数据结构 　　 　　向链表添加元素 　　 　　从链表移除元素 　　 　　使用 LinkedList 类 　　 　　双向链表 　...
C++(数据结构)：链表
08-03
C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 C++(数据结构)：链表 ...
数据结构：链表.ppt
09-17
链表数据结构 链表是一种基本的数据结构，它是一种线性表的链接存储表示。链表的每个元素（结点）由结点（Node）构成，每个结点包含数据域和链域，链域指向下一个结点。链表的特点是每个元素可以连续或不连续存储，...
数据结构：链表的合并与直接插入排序
04-03
本人数据结构课设题目：《链表的合并与直接插入排序》
数据结构课设一：链表实现大数相加
04-24
在这个课设“数据结构课设一：链表实现大数相加”中，我们主要关注的是链表这一基本数据结构以及如何利用它来解决实际问题，即进行大数的相加运算。 链表是一种线性数据结构，与数组不同，它不连续存储元素，而是...
swift代码-Swift数据结构: 链表(Linked List)
07-14
链表是一种重要的数据结构，它的实现方式与数组不同，它不连续存储元素，而是通过节点之间的引用链接来存储。本篇文章将深入探讨Swift中的链表（Linked List）及其相关知识点。 ### 链表的基本概念 链表由一系列...
数据结构--链表
weixin_30381317的博客
09-09 78
数据结构--链表 链表的种类 单链表 循环链表 双链表 链表的操作 单链表的节点删除 单链表的节点插入 双链表节点的删除 双链表的节点插入 链表的比较 转载于:https://www.cnblogs.com/szm2019/p/7535615.html...
数据结构-链表结构
wumanxin2018的博客
12-08 645
数据结构-链表结构
数据结构（链表）
weixin_48206333的博客
01-22 629
一：什么是链表？ 1.链表是以节点的方式来储存 2.每个节点包含data域，next域：指向下一个节点。 3.链表的各个节点不一定是连续存储。 4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。 二：单链表的应用实例 使用带head头的单向链表实现-水浒传英雄排列榜管理 1.完成对英雄人物的增删改查操作 2.第一种方法在添加英雄时，直接添加到链表的尾部 3.第二种方式在添加英雄时，根据排名将英雄插入到指定位置 ...
数据结构 链表
小胡同的诗
03-30 3万+
链表的生成上学期学链表的时候掌握了点皮毛，马马虎虎写了不带头结点的链表，这学期学数据结构觉得写代码要规范点才行，于是写了带头结点的链表。链表，顾名思义就是一串像链子的表格串接起来，当你不够用了，再开辟块内存接在这个链表的尾部，这时，就可以动态得分配内存大小，既不用担心拿多了内存造成浪费，也不用“处心积虑”地去考虑要存的数据到底需要多少。但是，相对于顺序表，链表的弊端还是有的，没错，就是要查哪个位置...
数据结构-链表
张文军
09-02 223
单链表 文章目录单链表简述：代码实现：测试：结果： 简述： 链表是一种最简单的动态数据结构，它能够辅助组成其它的数据结构，链表中的元素可存储在内存中的任何地方（不需要连续的内存，这一点和数组具有很大的区别，数组需要连续的内存），链表中的每个元素都存储了下一个元素的地址，从而使一系列随机的内存地址串接在一起。 存储链表的数据的我们一般称为节点（Node），节点一般分为两部分，一部分存储我们真正的数据...
链表
qq_41965731的博客
10-04 485
根据尚硅谷的韩顺平老师的数据结构视频总结的笔记 观看视频的网址 一、链表的介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 二、单链表 1、单链表介绍 单链表（带头节点）逻辑结构如下图： 2、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 ..
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

山舟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值