【数据结构/C语言】深入理解双向链表

💓 博客主页：倔强的石头的CSDN主页

📝Gitee主页：倔强的石头的gitee主页

⏩ 文章专栏：数据结构与算法

在阅读本篇文章之前，您可能需要用到这篇关于单链表详细介绍的文章

【数据结构/C语言】深入理解单链表-CSDN博客

一、双向链表的基本概念

双向链表的简介

双向链表的特点

双向链表的优缺点

二、双向链表的结构

双向链表节点的结构

双向链表的整体结构

三、双向链表的实现方法

1.双向链表的初始化

2.双向链表的头插

3.双向链表的尾插

4.双向链表的头删

5.双向链表的尾删

6.查找节点

7.在指定位置之前插入节点

8.删除指定位置节点

9.打印链表数据

10.双向链表销毁

四、C语言实现代码及测试

DouSlist.h 双链表头文件

DouSList.c 双链表源文件

test.c 测试文件及测试结果

五、双向链表的应用场景

一、双向链表的基本概念

双向链表的简介

双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。

一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。

以下是常见的单链表与双链表的图示及区别

双向链表的特点

双向遍历：由于每个节点都包含指向前一个节点和下一个节点的指针，因此我们可以从链表的任何一个节点开始，向前或向后遍历链表。
插入和删除操作：在双向链表中插入或删除节点通常比单向链表更加高效，因为我们可以直接访问要插入或删除节点的前一个和/或后一个节点，从而避免了对链表的遍历。
空间效率：与数组相比，双向链表在内存使用上更加灵活。链表可以在运行时动态地分配和释放内存，而不需要预先分配固定大小的内存块。

双向链表的优缺点

优点

动态分配内存，空间效率高。
插入和删除操作效率高，特别是当知道要操作节点的位置时。
可以从两个方向遍历链表。

缺点

相对于数组，链表在内存使用上可能不够紧凑，因为每个节点都需要额外的空间来存储指针。
访问链表中特定位置的元素需要从头或尾开始遍历链表，这可能导致效率较低（尽管可以使用哈希表等数据结构来优化访问速度）。

二、双向链表的结构

双向链表节点的结构

双向链表中的每个节点通常包含以下部分：

数据元素：可以是任何类型的数据，如整数、浮点数、字符串或对象。
prev 指针：指向前一个节点的指针。
next 指针：指向下一个节点的指针。

typedef int LTDataType;//数据类型重定义，可以是任意数据类型
typedef struct ListNode//双向链表节点结构
{
	LTDataType data;//数据
	struct ListNode* prev;//指向前一个节点的指针
	struct ListNode* next;//指向下一个节点的指针
}LTNode;

双向链表的整体结构

相比单链表只有独立存在的每个节点，双向链表多了哨兵位节点，该节点作为头结点，不存储有效数据，只有指向第一个有效节点的next指针和指向尾节点的prev指针。
只要链表存在，哨兵位节点就存在

三、双向链表的实现方法

1.双向链表的初始化

双向链表的初始化也就是创建一个哨兵位节点，所以实现初始化之前需要先封装一个节点申请函数

单独封装的申请节点函数

动态申请节点大小的空间
判空
通过形参接受的数据初始化节点数据部分
next指针和prev指针都指向自身（因为双向链表是循环链表）
返回节点地址

LTNode* NewNode(LTDataType x)//申请节点
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("NewNode\n");
		exit(1);
	}
	newnode->data = x;//根据参数初始化数据
	newnode->next = newnode->prev = newnode;//两个指针初始都指向自身
	return newnode;
}

双向链表初始化

调用申请节点函数创建一个哨兵位节点，作为链表的头结点
返回链表头结点地址

注意：

双向链表因为有哨兵位的存在，链表始终不为空，哨兵位节点不会被改变，所以不再需要传递地址，以及用二级指针接收。这一点区别于单链表实现

LTNode* LTInit()            //链表初始化
{
	LTNode* newnode = NewNode(-1);
	return newnode;
}

2.双向链表的头插

双向链表头插

头插就是将新节点插入到哨兵位节点和第一个有效节点之间
形参接收一个哨兵位地址和要插入的数据
首先对哨兵位地址判空，判断链表结构是否正常
申请新节点，存入要插入的数据
接下来是移动指针
一般情况下应当先调整新节点的指针，因为新节点指针调整不会影响到原链表:
新节点prev指向哨兵位，next指向哨兵位的next所指向节点
然后，调整第一个有效节点的prev指针，不再指向哨兵位而是指向新节点；调整哨兵位next指针，不再指向原来的第一个有效节点，而是指向新节点
新节点插入完成

void LTPushFront(LTNode* phead, LTDataType x)//头插
{
	assert(phead);//判空
	LTNode* newnode = NewNode(x);//申请节点

	newnode->next = phead->next;//改变新节点指针指向
	newnode->prev = phead;

	phead->next->prev = newnode;//改变原链表相关节点指针指向
	phead->next = newnode;

}

3.双向链表的尾插

双向链表尾插

尾插就是将新节点插入到原链表最后一个节点和哨兵位之间
首先对哨兵位地址判空，判断链表结构是否正常
申请新节点，存入要插入的数据
调整指针:
新节点next指向哨兵位节点，prev指向原链表最后一个有效节点（哨兵位prev所指向的节点）
原链表最后一个有效节点的next指向新节点
哨兵位prev指向新节点
新节点尾差完成

void LTPushBack(LTNode* phead, LTDataType x)//尾插
{
	assert(phead);//判空
	LTNode* newnode = NewNode(x);//申请节点

	newnode->next = phead;//改变新节点指针指向
	newnode->prev = phead->prev;

	phead->prev->next = newnode;//改变原链表相关节点指针指向
	phead->prev = newnode;
}

4.双向链表的头删

双向链表头删

头删就是将双向链表第一个有效节点删除
（头删的前提是链表至少存在一个有效节点）
首先创建一个指针del指向要删除的节点（哨兵位节点next指向的节点）
然后将第二个有效节点的prev指针指向哨兵位节点
哨兵位节点的next指针指向第二个有效节点
指针修改完成，此时第二个有效节点成为链表的第一个有效节点，释放del指向的节点
（如果删除之前链表只有一个节点，删除完之后只剩下一个哨兵位节点，两个指针都指向自己）

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;
}

5.双向链表的尾删

双向链表尾删

尾删就是将双向链表的最后一个有效节点删除
（尾删的前提是至少存在一个有效节点）
首先创建一个指针del指向要删除的节点（哨兵位prev指向节点）
然后将倒数第二个节点的next指针指向哨兵位
将哨兵位的prev指针指向倒数第二个节点
指针修改完成，此时倒数第二个节点成为最后一个节点，释放del指向的节点
（如果删除之前链表只有一个节点，删除完之后只剩下一个哨兵位节点，两个指针都指向自己）

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;
}

6.查找节点

双向链表查找（根据数据查找节点）

首先对哨兵位地址判空，否则可能对空地址解引用
创建一个遍历链表的指针，从第一个有效节点开始，将节点数据与要查找的数据进行比对，如果相同返回节点地址
出循环，说明未找到，返回NULL

LTNode* LTFind(LTNode* phead, LTDataType x)//查找节点
{
	assert(phead);//判空

	LTNode* pcur = phead->next;//遍历链表的指针

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

7.在指定位置之前插入节点

双向链表在指定位置之前插入节点：

插入的前提是指定位置存在
申请新节点，存入要插入的数据
调整指针:
临时创建一个指针prev指向指定位置节点的perv指向节点
新节点next指针指向指定位置节点，prev指针指向prev节点
然后再修改原链表指针:
指定位置节点的prev指针指向新节点，prev节点的next指针指向新节点
新节点插入完成

void LTInsert(LTNode* pos, LTDataType x)//在pos位置之前插入数据
{
	assert(pos);//判空
	LTNode* newnode = NewNode(x);//申请新节点

	newnode->next = pos;//改变新节点指针指向
	newnode->prev = pos->prev;

	pos->prev->next = newnode;//改变原链表相关节点指针指向
	pos->prev = newnode;

}

8.删除指定位置节点

双向链表删除指定位置节点

删除指定节点的前提是该节点必须存在
首先创建一个指针del指向要删除的节点
然后将该节点的前一个结点的next指针指向它的后一个节点，后一个节点的prev指针指向他的前一个节点
释放该节点
（如果删除之前链表只有一个节点，删除完之后只剩下一个哨兵位节点，两个指针都指向自己）

void LTErase(LTNode* pos)//删除指定位置节点
{
	assert(pos);//判空
	pos->next->prev = pos->prev;//改变要删除节点的前后节点指针指向
	pos->prev->next = pos->next;

	free(pos);
	pos = NULL;

}