链表详解—单链表与双向链表

于 2024-05-11 00:15:00 发布
阅读量1k 收藏 19
点赞数 31
文章标签： 链表 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83431652/article/details/138630542
版权

一.单链表

1.链表的概念及结构

(1)概念：

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

(2)结构：

 与顺序表不同的是，链表里的每个节点都是独立申请的空间。节点的组成主要有两个部分：当前节点要保存的数据和保存下一个节点的地址（指针变量）。

图中指针变量plist保存的是第一个节点的地址，即plist“指向”第一个节点，如果我们希望plist指向第二个节点时，只需要修改plist保存的内容为0x0012FFA0。

为什么还需要指针变量来保存下一个节点的位置？

链表中每个节点都是独立申请的（即需要插入数据时才去申请一块节点的空间），我们需要通过指针变量来保存下一个节点的位置才能从当前节点找到下一个节点。

(3)每个节点对应的结构体代码

(假设当前保存的节点为整数)


//定义节点的结构
typedef struct SListNode
{
	int date;//节点数据
	struct SListNode* next;//指向下一个节点的指针
}SLTNode;

 (4)链表的打印

给定的链表结构中，如何实现链表节点从头到尾的打印？

 (5)思考

当我们想保存的数据类型为字符型，浮点型或者其他自定义类型时，该如何修改？

补充说明：

•  链表机构在逻辑上是连续的，在物理结构上不一定连续

•  节点一般是从堆上申请的

•  从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续。

 我们可以用到重命名typedef，用STDateType代替链表要保存的数据类型。当我们想保存的数据类型为字符型，浮点型或者其他自定义类型时，将int修改成我们想要的数据类型。

typedef int SLTDataType;

2.单链表的实现（无头+单向+非循环链表）

SList.h

typedef int SLTDataType;
//定义节点的结构
typedef struct SListNode
{
	SLTDataType date;
	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* phead, 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 

(1)链表的打印

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

(2)创建新节点的函数

//创建新节点的函数
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);//异常退出（非零），正常退出是（0）
	}
	newnode->date = x;
	newnode->next = NULL;
	return newnode;
}

(3)尾插

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//但*pphead可以为空，表示该节点的地址为空
	SLTNode* newnode = SLTBuyNode(x);
	//空链表和非控链表
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* ptail = *pphead;
		//找尾
		while (ptail->next)
		{
			ptail = ptail->next;
		}//ptail指向的就是最后一个节点
		ptail->next = newnode;
	}
}

(4)头插

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;//使newnode成为新的头结点！
}

(5)尾删

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//*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;
		}//ptail 为尾节点
		//prev为尾节点的前一个节点
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
	}
}

(6)头删

//头删
void SLTPopFront(SLTNode** pphead)
{
	//*pphead 也不能为空（链表不能为空），不然就没有删除的节点
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

(7)查找链表中有没有值为x的节点，如果有的话返回该节点

//查找链表中有没有值为x的节点，如果有的话返回该节点
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* ptail = phead;
	while (ptail)
	{
		if (ptail->date == x)
		{
			return ptail;
		}
		ptail = ptail->next;
	}
	//没有找到
	return NULL;
}

(8)在指定位置之前插入数据

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);//链表不能为空，不然就找不到节点pos
	assert(pos);
	//链表只有一个节点
	if (pos == *pphead)//说明是头插
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		SLTNode* ptail = *pphead;
		while (ptail->next != pos)
		{
			ptail = ptail->next;
		}//ptail为pos节点的前一个节点
		ptail->next = newnode;
		newnode->next = pos;
	}
}

(9)删除pos节点

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && pos);
	//pos为头结点——>头删
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else//po不是头结点
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}//prev 为pos 的前一个节点
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

(10)在指定位置之后插入数据

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

(11)删除pos之后的节点

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

(12)销毁链表—>销毁一个一个的节点

//销毁链表——>销毁一个一个的节点
void SListDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;//别忘记销毁头结点
}

3.链表的分类

链表结构非常多样，以下情况组合起来就有8种。

(1)单项或双向

(2)带头或不带头

(3)循环或不循环

虽然有那么多的链表结构，但我们最常用的只有两种：

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

•  带头双向循环链表：结构最复杂，一般用在单独存放数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码1实现以后会发现结构会带来很多优势。

二.双向链表

1.双向链表的结构

 注意：这里的“带头”跟前面说的“头结点”是两个概念，实际前面的在单链表讲解中称呼不严谨。

带头链表里的头结点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是“放哨”作用。

“哨兵位”存在的意义：
遍历循环链表避免死循环。

2.双向链表的实现

typedef int LTDateType;
typedef struct ListNode
{
	LTDateType date;
	struct ListNode* next;
	struct ListNode* prev;

}LTNode;

//声明双向链表中提供的方法


//双向链表初始化
LTNode* LTInit2();//1以返回值的形式初始化，为了保持接口一致性
//void LTInit(LTNode** pphead);//2

//打印双向链表
void LTPrint(LTNode* phead);


//插入数据之前，链表必须初始化到只有一个节点的情况
//不能改变哨兵位的地址，因此传一级即可
//尾插
void LTPushBack(LTNode* phead, LTDateType x);
//头插
void LTPushFront(LTNode* phead, LTDateType x);
//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);
//查找
LTNode* LTFind(LTNode* phead, LTDateType x);
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDateType x);
//删除pos节点
void LTErase(LTNode* pos);//不传二级指针原因：保持接口一致性
//双向链表的销毁
void LTDestory(LTNode* phead);


//LTErase和LTDestory参数理论上要传二级指针，因为我们需要让形参的
//改变影响实参，但是为了保持接口一致性才传的一级。
//传一级指针的问题在于，当形参phead置为NULL后，实参plist不会被修改
//为NULL，因此解决方法是：调用完方法后手动将实参置为NULL。

//plist（LTDestory的方法调用后，plist保存的空间已经被释放掉了）
//若后续还需要用plist指针就会有问题。

(1)打印双向链表

//打印双向链表
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->date);
		pcur = pcur->next;
	}
	printf("\n");
}

(2)创建一个节点

//创建一个节点
LTNode* LTBuyNode(int x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->date = x;
	node->next = node->prev = node;
}

(3)双向链表的初始化

//双向链表的初始化
//1.以返回值的形式初始化
LTNode* LTInit2()
{
	LTNode* pcur = LTBuyNode(-1);
	return pcur;
}
//2.以参数形式初始化
//void LTInit(LTNode** pphead)
//{
//	//给双向链表创建一个哨兵位
//	*pphead = LTBuyNode(-1);
//}

(4)尾插

//尾插(将新节点插到头节点（哨兵位）之前)
void LTPushBack(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	//将phead  phead->prev  newnode  正确排列
	//先用新节点
	newnode->prev = phead->prev;
	newnode->next = phead;
	//下面两行代码不能位置改变
	phead->prev->next = newnode;
	phead->prev = newnode;
}

(5)头插

//头插（在链表里第一个有效数字的前面插）（往头结点后面插）
void LTPushFront(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

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

	phead->next->prev = newnode;
	phead->next = newnode;
	//phead->next = newnode;
	//newnode->next->prev = newnode;(这两行也可以)
}

(6)尾删

//尾删
void LTPopBack(LTNode* phead)
{
	//链表必须有效且不能为空（只有一个哨兵位的情况）
	assert(phead && (phead->next) != phead);
	phead->prev = phead->prev->prev;
	phead->prev->next = phead;
	//或
	//LTNode* del = phead->prev;
	//del->prev->next = phead;
	//phead->prev = del->prev;
	删除del节点
	//free(del);
	//del == NULL;
}

(7)头删

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && (phead->next) != phead);
	phead->next = phead->next->next;
	phead->next->prev = phead;
}

(8)查找

//查找
LTNode* LTFind(LTNode* phead, LTDateType x)
{
	LTNode* pcur = phead->next;
	while(pcur != phead)
	{
		if (pcur->date == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}//没有找到
	return NULL;
}

(9)在pos位置之后插入数据

//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDateType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;

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

(10)删除pos节点

//删除pos节点
void LTErase(LTNode* pos)
{
	//理论上pos节点不能为phead，但是没有phead无法参加校验
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

(11)双向链表的销毁

//双向链表的销毁
void LTDestory(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//此时pcur指向phead，phead没有被销毁
	free(phead);
	phead = NULL;
}

 三.顺序表与链表的优缺点分析

备注：缓存利用率参考存储体系结构及局部原理性。

烦躁的大鼻嘎
关注
  • 31
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表和双链表
weixin_45926367的博客
05-04 630
链表 与数组相似，链表也是一种线性数据结构。这里有一个例子： 链表中的每个元素实际上是一个单独的对象，而所有对象都通过每个元素中的引用字段链接在一起。 链表有两种类型：单链表和双链表。上面给出的例子是一个单链表，这里有一个双链表的例子： 一 简介 - 单链表 单链表中的每个结点不仅包含值，还包含链接到下一个结点的引用字段。通过这种方式，单链表将所有结点按顺序组织起来。 1. 结点结构 在大多数...
单链表、双链表
星光之子的博客
03-08 447
单链表、双链表单链表简介访问操作添加操作删除操作链表中的(快慢)双指针双链表简介添加操作删除操作总结(重要!!!) 单链表 简介 阅读参考：https://leetcode-cn.com/leetbook/read/linked-list/jsumh/ 单链表中的每个结点不仅包含值，还包含链接到下一个结点的引用字段 通过这种方式，单链表将所有结点按顺序组织起来 访问操作 与数组不同，无法在常量时间内O(1)访问单链表中的随机元素，如果想要获得第 i 个元素，必须从头结点逐个遍历(next) 按索引来访问元素
c++单链表以及双链表
深藏功与名
05-18 1095
按照https://blog.csdn.net/langb2014/article/details/79805817最后的表的顺序进行梳理。首先看链表之前，结构体嵌套问题：结构体的自引用(self reference)，就是在结构体内部，包含指向自身类型结构体的指针。结构体的相互引用（mutual reference），就是说在多个结构体中，都包含指向其他结构体的指针。1. 自引用结构体1.1 不...
【数据结构】单链表与双链表
鲑鱼弥勒的博客
03-20 1043
1.和数组一样，链表也是一种线性表。2.从内存结构来看，链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。3.链表中的每一个内存块被称为节点Node。节点除了存储数据外，还需记录链上下一个节点的地址，即后继指针next。
数据结构，链表，单链表，双链表，循环链表，双向循环链表
最新发布
qq_52119661的博客
08-20 177
下面是单链表的基本操作，本次申请的单链表为有空头链表（头节点数据域为空，指针域指向下一个节点），也可以易申请无空头链表。- 这是双链表和循环链表的结合体。- 更多的内存使用：由于每个节点都需要额外的指针来存储下一个节点的地址，因此链表使用的内存比数组更多。- 最后一个节点的下一个指针指向第一个节点，而第一个节点的前一个指针指向最后一个节点。- 在单链表中，每个节点包含两部分：一个是数据部分，另一个是指向下一个节点的指针。- 双链表的每个节点有两个指针：一个指向下一个节点，另一个指向前一个节点。
python双向链表原理与实现方法详解
09-18
双向链表的实现提供了更多的灵活性，可以在链表的任何位置进行插入和删除操作，而不像单链表那样只能从前向后操作。这种数据结构在需要频繁地在链表中间进行操作的场景中非常有用，例如在实现LRU缓存策略时。在...
Java中双向链表详解及实例
08-30
这种特性使得双向链表在某些场景下比单链表更高效。下面将详细介绍Java中如何实现双向链表，并通过实例代码进行讲解。 首先，为了实现双向链表，我们需要定义一个内部类`Node`，用于表示链表中的每个节点。`Node`类...
Double-List.rar_双向链表
09-19
与单链表不同，双向链表的每个节点包含三个部分：数据域、向前指针（用于指向下一个节点）和向后指针（用于指向前一个节点）。这种设计使得双向链表在某些操作上具有更高的灵活性，比如向前或向后遍历。 在双向链表...
Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
09-21
循环链表与单链表类似，区别在于最后一个节点的`next`引用指向链表的头节点，形成一个闭合的循环。循环链表在遍历和某些特定算法（如Floyd判圈算法）中有其独特优势。 7. **链表的其他变体** - **双链表**：每个...
Python双链表原理与实现方法详解
09-17
双链表的一个主要优点是它可以更快地进行双向遍历，特别是在需要频繁进行插入和删除操作时，因为不必像单链表那样从头开始寻找插入或删除的位置。然而，相比于单链表，双链表占用更多的内存，因为每个节点都额外存储...
单链表，双链表和循环链表
因为不想回家，所以还是去搬砖。
05-29 784
一、单向链表或者单链表单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向表中的下一个节点，而最后一个节点则指向一个空值NULL。单向链表只可向一个方向遍历。查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。也可以提前把一个节点的位置另外保存起来，然后直接访问。二、双向链表,也叫双链表双向链表中不仅有指向后一个节点的指针，还有指向前一个节点的指针。第一个节点的...
数据结构之链表（单链表，双链表）知识汇总（包含面试题）
wujianrenn的博客
12-06 2020
一.链表总体介绍： 1.单链表：（single linked list） 每个链表有一个next指针指向下一个节点，还有一个成员用来存储数值 2.双链表：（Douuble Linked List） 在单链表基础之上，还有一个prev指针指向前一个节点。 3.小结： （1）链表是以节点的方式来存储 （2）每个节点包含data域，next域：指向下一个节点 （3）链表的每个节点都不是连续存储的 （4）链表分有头节点的和不带头节点的，根据实际需求来定 第一个节点的data域为nul..
双向链表和单链表区别
m0_73247666的博客
07-11 3516
2、单向链表：单个结点创建非常方便，普通的线性内存通常在创建的时候就需要设定数据的大小，结点的访问方便，可以通过循环或者递归的方法访问到任意数据。2、单向链表：结点的删除非常方便，不需要像线性结构那样移动剩下的数据，但是平均的访问效率低于线性表。2、单向链表：是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。1、双向链表：也叫双链表，是链表的一种，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。1、双向链表：增加删除节点复杂，需要多分配一个指针存储空间。
单链表、双链表、循环链表总结
SdustLiYang的专栏
01-12 4207
1.单链表（为升序链表，value按升序排列） #include #include typedef struct NODE { struct NODE *link; int value; } Node;//最好放在头文件中 Node *sll_creat(); int sll_length(Node *p); Node *sll_del(Node *head,int
单链表与双链表-线性表的链式表示
Arlodh的博客
02-28 276
链表有单链表和双链表两种实现形式。它通指针将表内各个节点相连，不要求逻辑上的相邻元素在内存上也相邻。同时，这也决定了链表不能随机存取表内元素。单链表的结构包含数据域和指针域。其中，数据域存放数据元素；指针域存放指向下一个结点地址的指针。【注】本贴只记录带头结点的链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值