双向链表专题

C++忠实粉丝

已于 2024-05-03 12:26:48 修改

阅读量759

点赞数 17

分类专栏：数据结构初阶文章标签：链表数据结构算法

于 2024-05-01 23:39:50 首次发布

本文链接：https://blog.csdn.net/wer24_25/article/details/138381355

版权

数据结构初阶专栏收录该内容

18 篇文章 38 订阅

订阅专栏

引言

之前我发布过单链表专题,其中就介绍了链表的分类,链表一共了八种,其中最常见便是单链表和今天的主题双向链表,双向链表其实就是在单链表的基础上增加一些修饰,所以单链表是基础,如果还不是很了解的宝子们,可以先去看一下这篇博客--单链表专题.

1. 双向链表的结构

注意：这⾥的“带头”跟前⾯我们说的“头节点”是两个概念，实际前⾯的在单链表阶段称呼不严谨，但是为了同学们更好的理解就直接称为单链表的头节点。

带头链表⾥的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这⾥“放哨的”

“哨兵位”存在的意义：遍历循环链表避免死循环.因为双向链表是一个循环的结构,为了确定是否遍历完整个链表,所以设立了哨兵位

2.链表的节点组成

其实就是在单链表的基础上,增加了指向前面节点的指针

代码

typedef int LTDataType;

//定义双向链表节点的结构
typedef struct ListNode {
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

这里的LTDataType和单链表,顺序表也是一样的,方便后面统一修改数据类型

注意:单链表为空时,是一个空链表,而双向链表为空时,链表中会剩下一个哨兵位,这个哨兵位不会被修改,头插也是在哨兵之后插入.

3. 双向链表的实现

3.1双向链表中的方法

跟顺序表和单链表的方法差不多

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

//初始化
void LTInit(LTNode** pphead);
//LTNode* LTInit();
//打印双向链表
int LTPrint(LTNode* phead);
//插入数据
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//删除数据
//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);
//查找数据库
LTNode* LTFind(LTNode* phead, LTDataType x);
//删除pos节点
void LTErase(LTNode* pos);
//销毁
void LTDestroy(LTNode* phead);

3.2双向链表的初始化

//申请节点
LTNode* LTBuyNode(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 = LTBuyNode(-1);
}

和单链表一样,初始化之前,先写申请节点的函数,后面需要申请的话直接调用函数,然后在对哨兵进行初始化为-1.

3.3打印双向链表

这里也和单链表一样,对链表进行遍历,不过判断条件不在是为NULL,而是不等与哨兵位

int LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

3.4双向链表插入数据

3.4.1尾插

这里和单链表不同,单链表需要进行遍历后找到最后一个节点,再进行尾插,而循环链表可以通过哨兵位直接找到最后一个节点,不需要进行一次遍历.

而且双向循环链表因为有哨兵位的存在,不需要进行判空处理

//尾插
void LTPushBack(LTNode* phead, LTDataType 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;
}

3.4.2头插

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	//phead newnode phead->next

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

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

注意:这里的尾插和头插一般是先对要插入的数据进行插入,再对链表进行完善,防止链表节点的丢失,这里你一定要注意顺序, 如果你不清楚的话,建议直接用新插入数据的指针节点或者自定义新的指针节点,下面便是头插顺序引发的问题:

3.5双向链表删除数据

3.5.1尾删

和单链表类似,单独定义要删除的节点为del,用free函数进行释放

//尾删
void LTPopBack(LTNode* phead)
{
	//链表必须有效不能为空
	assert(phead && phead->next != phead);

	LTNode* del = phead->prev;
	//phead del->prev del
	del->prev->next = phead;
	phead->prev = del->prev;

	//删除del节点
	free(del);
	del = NULL;
}

3.5.2头删

之前说了,这里跟单链表不同,双向链表的哨兵位是不会被修改的,所以头插是在哨兵位之后进行删除

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

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

	free(del);
	del = NULL;
}

3.6双向链表在指定位置之后插入数据

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

	LTNode* newnode = LTBuyNode(x);
	//pos newnode pos->next
	newnode->next = pos->next;
	newnode->prev = pos;

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

3.7查找数据

只需要遍历一遍双向链表

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

3.8删除指定节点

类似头删和尾删

//删除指定节点
void LTErase(LTNode* pos)
{
	//pos理论上来说不能为phead,但是没有参数phead,无法验证
	assert(pos);
	//pos->prev pos pos->next
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;

	free(pos);
	pos = NULL;
}

3.9销毁双向链表

//销毁
void LTDestroy(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;
}

3.10优化接口

因为双向链表有哨兵的存在,所以进行删除和插入操作时没有传入哨兵的地址,全部是用一级指针进行接收,而删除销毁操作需要对哨兵位进行更改,形参的改变要影响实参就必须要传地址,也是就需要用二级指针来进行接收,而这里为了能统一接口,全部采用一级指针来接收,但是,最后需要手动将实参置为空(NULL)~

这里将初始化进行优化:

LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

优化后,需要额外用指针进行接收