【数据结构】—— 双向链表

已于 2024-07-10 18:32:44 修改
阅读量1.2k 收藏 25
点赞数 45
分类专栏： # 线性表 文章标签： 数据结构 链表
于 2024-07-10 18:28:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xasdf338/article/details/140317478
版权

文章目录

1、双向链表的概念

双向链表（Doubly Linked List）是一种常见的链表数据结构，它与普通的单向链表不同之处在于，每个节点除了存储数据元素外，还存储着指向前一个节点和后一个节点的指针（或引用）。

与单链表的区别：双向链表中可以通过节点本身直接访问其前驱节点和后继节点，而不需要像单向链表那样只能从头节点开始顺序访问。

2、双向链表的接口实现

在这里插入图片描述

2.1结构

  • 双向链表的一个节点由三部分构成
    1）当前节点的数据——date
    2）前驱指针——prev
    3）后驱指针——next
//定义双向链表中节点的结构
typedef int LDateType;
typedef struct ListNode {
	LDateType date;
	struct ListNode* prev;
	struct ListNode* next;
}LNode;

带头双向链表:

  • 双向链表带有哨兵位，插入数据之前必须要初始化哨兵位
  • 哨兵节点（头节点）：本身不存储有效数据，它的存在只是为了简化边界条件的处理。

这里我用双向带头循环链表来实现

2.2初始化

申请节点

对申请节点功能进行封装，方便调用。

//申请节点
LNode* LBuyNode(LDateType x) {
	LNode* newnode = (LNode*)malloc(sizeof(LNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	newnode->date = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}

直接调用申请节点函数创建哨兵位

LNode* LInit()
{
	//创建一个哨兵位
	LNode* phead = LBuyNode(-1);
	return phead;
}

2.3插入数据

尾插

当双向链表进行尾插的时候，无需像单链表那样循环找尾节点，双向链表中的尾节点与哨兵位相连，可以直接获取:

ptail = phead->prev

  • 思路：在修改指针连接时，优先对newnode的前驱和后驱进行修改，避免影响链表原来的指向，随后对ptail的后驱和phead的前驱进行修改
void LPushBack(LNode* phead, LDateType x)
{
	assert(phead);
	LNode* newnode = LBuyNode(x);//申请节点
	//phead phead->prev(ptail) newnode 修改指针连接
	newnode->next = phead;
	newnode->prev = phead->prev;

	(phead->prev)->next = newnode;
	phead->prev = newnode;
}
头插

在这里插入图片描述

与尾插相似，修改对应指针连接即可

void LPushFront(LNode* phead, LDateType x)
{
	assert(phead);
	LNode* newnode = LBuyNode(x);
	// phead newnode phead->next 修改这三个节点的连接
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;
}
指定位置之后插入数据

对插入数据的位置前驱后驱节点修改指针连接即可
pos-> newnode-> pos->next

void LInsert(LNode* pos, LDateType x) {
	assert(pos);
	LNode* newnode = LBuyNode(x);
	//pos newnode pos->next
	newnode->next = pos->next;
	newnode->prev = pos;

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

2.4删除数据

  • 思路：修改指针连接，free函数释放被删除节点即可
尾删
void LPopBack(LNode* phead) {
	assert(phead);
	//若哨兵位节点的next指针或prev指针指向的是自己，则链表为空
	assert(phead->next != phead);
	LNode* del = phead->prev;
	LNode* prev = del->prev;
	//实现结果一致，无需分情况讨论，
	prev->next = phead;
	phead->prev = prev;
	free(del);
	del = NULL;
}
头删
void LPopFront(LNode* phead) {
	assert(phead);
	assert(phead->next != phead);

	LNode* del = phead->next;
	LNode* next = del->next;
	//改变指针指向，删除指定节点即可
	next->prev = phead;
	phead->next = next;
	free(del);
	del = NULL;
}
指定位置删除
void LErase(LNode* pos) {
	assert(pos);

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

	free(pos);
	pos = NULL;
}

2.5查找

  • 功能 ：查找指定节点并返回节点
  • 实现思路：创建节点指针pcur指向链表中第一个节点(phead->next),
    遍历链表，查找指定节点，如果找到直接返回节点，停止条件为当pcur指向哨兵位，当跳出循环则链表中不存在指定节点，返回NULL
LNode* LFind(LNode* phead, LDateType x) {
	assert(phead);
	LNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->date == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

2.6打印

  • 思路：创建节点指针pcur指向链表中第一个节点(phead->next),
    遍历链表，停止条件为当pcur指向哨兵位，当pcur指向哨兵位则遍历完成
void LPrint(LNode* phead) {
	assert(phead);
	LNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->date);
		pcur = pcur->next;
	}
	printf("\n");
}

2.7销毁

  • 思路：通过遍历删除每个有效节点，最后删除哨兵位
void LDestroy(LNode** pphead) {
	assert(pphead);
	//哨兵位不能为空
	assert(*pphead);

	LNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		LNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//最后链表只剩哨兵位
	//销毁哨兵位
	free(*pphead);
	*pphead = NULL;
}

3、链表和顺序表的区别

在这里插入图片描述

4、问题与思考

Q：二级指针和一级指针应该什么时候用，如何选择？
在单链表和双向链表中，二级指针和一级指针的选择在于是否需要修改(删除)头节点/头指针（在双向链表中叫哨兵位）
在这里插入图片描述
在实际应用中：

  • 一级指针：直接操作变量和简单数据结构
  • 二级指针：用于处理复杂的数据结构(多级链表等)、动态内存分配以及需要改变指针本身(值)指向的情况

代码文件

.h文件

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//定义双向链表中节点的结构
typedef int LDateType;
typedef struct ListNode {
	LDateType date;
	struct ListNode* prev;
	struct ListNode* next;
}LNode;

//注意，双向链表带有哨兵位，插入数据之前必须要初始化哨兵位
/*void LInit(LNode** plist);*///初始化哨兵位
LNode* LInit();//无需传参初始化哨兵位（函数里面创建哨兵位）

//申请节点
LNode* LBuyNode(LDateType x);

//不需要改变哨兵位，则不需要传二级指针
void LPushBack(LNode* pphead, LDateType x);//尾插

void LPushFront(LNode* phead, LDateType x);//头插(在第一个有效节点之前插入)

//打印双向链表
void LPrint(LNode* phead);

//头删
void LPopFront(LNode* phead);

//尾删
void LPopBack(LNode* phead);

//指定位置之后插入数据
void LInsert(LNode* pos, LDateType x);

//删除pos位置的数据
void LErase(LNode* pos);

//查找
LNode* LFind(LNode* phead, LDateType x);

//链表销毁
void LDestroy(LNode** pphead);//这里是用二级指针销毁
//推荐一级 ——>（保持接口一致性）

.c文件

#include "List.h"

//void LInit(LNode** pphead)
//{
//	*pphead = (LNode*)malloc(sizeof(LNode));
//	if (*pphead == NULL)
//	{
//		perror("malloc fail!");
//		exit(1);
//	}
//	(*pphead)->date = -1;//该数据无作用
//	(*pphead)->next = (*pphead)->prev = *pphead;//或者NULL
//}

LNode* LInit()
{
	//创建一个哨兵位
	LNode* phead = LBuyNode(-1);
	return phead;
}

//申请节点
LNode* LBuyNode(LDateType x) {
	LNode* newnode = (LNode*)malloc(sizeof(LNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	newnode->date = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}

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

//尾插和头插
void LPushBack(LNode* phead, LDateType x)
{
	assert(phead);//双向链表第一个节点不可能为空，无需assert*phead
	LNode* newnode = LBuyNode(x);
	//phead phead->prev(ptail) newnode 修改指针连接
	newnode->next = phead;
	newnode->prev = phead->prev;

	(phead->prev)->next = newnode;
	phead->prev = newnode;
}
void LPushFront(LNode* phead, LDateType x)
{
	assert(phead);
	LNode* newnode = LBuyNode(x);
	// phead newnode phead->next 修改这三个节点的连接
	newnode->next = phead->next;
	newnode->prev = phead;

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

void LPopBack(LNode* phead) {
	assert(phead);
	//若哨兵位节点的next指针或prev指针指向的是自己，则链表为空
	assert(phead->next != phead);
	LNode* del = phead->prev;
	LNode* prev = del->prev;
	//实现结果一致，无需分情况讨论，
	prev->next = phead;
	phead->prev = prev;
	free(del);
	del = NULL;
}

void LPopFront(LNode* phead) {
	assert(phead);
	assert(phead->next != phead);

	LNode* del = phead->next;
	LNode* next = del->next;
	//改变指针指向，删除指定节点即可
	next->prev = phead;
	phead->next = next;
	free(del);
	del = NULL;
}


LNode* LFind(LNode* phead, LDateType x) {
	assert(phead);
	LNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->date == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

void LInsert(LNode* pos, LDateType x) {
	assert(pos);
	LNode* newnode = LBuyNode(x);
	//pos newnode pos->next
	newnode->next = pos->next;
	newnode->prev = pos;

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

void LErase(LNode* pos) {
	assert(pos);

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

	free(pos);
	pos = NULL;
}

void LDestroy(LNode** pphead) {
	assert(pphead);
	//哨兵位不能为空
	assert(*pphead);

	LNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		LNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//最后链表只剩哨兵位
	//销毁哨兵位
	free(*pphead);
	*pphead = NULL;
}

测试文件

#include "List.h"

//void ListTest01() {
//	LNode* plist = NULL;
//	LInit(&plist);
//}

void ListTest02() {
	LNode* plist = LInit();//初始化
	//尾插
	LPushBack(plist, 1);
	LPushBack(plist, 3);
	LPushBack(plist, 5);
	LPrint(plist);
}

void ListTest03() {
	LNode* plist = LInit();//初始化
	//尾插
	LPushFront(plist, 1);
	LPushFront(plist, 3);
	LPushFront(plist, 5);
	LPrint(plist);
	LPopBack(plist);
	LPrint(plist);
	LPopBack(plist);
	LPrint(plist);
	LPopBack(plist);
	LPrint(plist);
}

void ListTest04() 
{
	LNode* plist = LInit();//初始化
	//尾插
	LPushFront(plist, 1);
	LPushFront(plist, 3);
	LPushFront(plist, 5);
	LPrint(plist);
	LPopFront(plist);
	LPrint(plist);
	LPopFront(plist);
	LPrint(plist);
	LPopFront(plist);
	LPrint(plist);
}

void ListTest05()
{
	LNode* plist = LInit();//初始化
	//尾插
	LPushFront(plist, 1);
	LPushFront(plist, 3);
	LPushFront(plist, 5);
	LPrint(plist);
	LNode* findRet1 = LFind(plist, 2);
	if (findRet1 == NULL) printf("未找到！\n");
	else printf("找到了！\n");
	LNode* findRet2 = LFind(plist, 3);
	if (findRet2 == NULL) printf("未找到！\n");
	else printf("找到了！\n");
}

void ListTest06()
{
	LNode* plist = LInit();//初始化
	//尾插
	LPushFront(plist, 1);
	LPushFront(plist, 3);
	LPushFront(plist, 5);
	LPrint(plist);
	LNode* findRet1 = LFind(plist, 3);
	LInsert(findRet1, 666);
	LPrint(plist);
	LNode* findRet2 = LFind(plist, 666);
	LErase(findRet2);
	LPrint(plist);
	LDestroy(&plist);
}

int main()
{
	//ListTest01();//由传址的哨兵位初始化
	//ListTest02();//初始化＋尾插
	//ListTest03();//头插+尾删
	//ListTest04();//头删
	//ListTest05();//查找
	ListTest06();//在指定位置之后插入数据,删除数据,销毁链表
	return 0;
}
ElvInR
关注
专栏目录
redis的数据结构——双向链表
jkzyx123的博客
08-20 931
Redis的双向链表数据结构详解
数据结构——双向链表
Labrador_Katie的博客
01-03 959
双向链表
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 8704
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
数据结构——双向链表PTA习题
流楚丶格念的博客
12-17 5977
文章目录单选题函数题6-1 链式表操作集 (20分)各个操作函数的定义为：输入样例：输出样例：代码6-2 带头结点的链式表操作集 (20分)输入样例：输出样例：代码6-4 共享后缀的链表 (25分)输入样例：输出样例：代码 单选题 题号 题目 答案 1 设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是： t->next=h; h=t; 2 带头结点的单链表h为空的判定条件是： h->next == NULL; 3 对于一非空的循环单链表，h和p分别
数据结构-5.2.树的性质
ADCvbV的博客
10-12 108
一个分支中，如父结点B，两个子结点为E和F，结点B的度的值为2，等于子结点数量，加上这一个父结点(父结点只能有一个)，就是结点B，E，F组成的树的总结点数即结点数 = 总度数 + 1高度为h的m叉树至少有h个结点(每层至少一个结点，共h层，所以至少共h个结点)；高度为h，度为m的树至少有h+m-1个结点(首先度为m，表明至少要有m个分支，最少时一个分支上只有一个结点，此时有m个结点，这些分支占一层，此外有h-1层，每层最少1个结点，因此这h-1层至少h-1个结点，所以整个树至少h-1+m个结点)为了达到最小
【数据结构-栈】【贪心】力扣2434. 使用机器人打印字典序最小的字符串
sjsjs11的博客
10-12 268
我们可以思考，将t想象成一个栈，先进后出，然后当栈顶元素的值，也就是t的末尾的值比字符串s中的任何一个字符都要小的时候，那么我们就要将栈顶元素推入p中，也就是写出来的字符串，这样才能保证最小字典序列。，由于0代表a，1代表b…执行第一个操作四次，得到 p=“” ，s=“” ，t=“bdda”。执行第一个操作三次，得到 p=“” ，s=“” ，t=“zza”。执行第一个操作，得到 p=“ab” ，s=“” ，t=“c”。执行第二个操作，得到 p=“abc” ，s=“” ，t=“”。
数据结构：双向带头链表
qq_71391318的博客
10-12 539
双向带头链表简易代码
数据结构编程实践20讲(Python版)—09B树
AnFany
10-12 683
数据结构编程实践20讲(Python版)—09B树
【关系模型】关系数据结构、基本关系代数运算
lin_miao_2023的博客
10-07 748
昨天补充了DBMS概况的存储管理层面，今天来详细介绍数据库管理系统中常见且应用广泛的关系型数据库（简称关系数据库），比如postgreSQL、MySQL、Oracle Database。
初识数据结构--时间复杂度 和 空间复杂度
2303_79266237的博客
10-05 1228
数据结构是计算机存储、组织数据的方式(指相互之间存在一种或多种特定关系的数据元素的集合。。
Java.数据结构.HashMap
TJKFYY的博客
10-05 1047
1基本概念键值对（key-value）的方式存储数据插入顺序和遍历顺序可能不同2数据结构HashMap的底层实现优化为数组+链表或红黑树假如我们输入1,4,5,6,7,9这串数字，那么其内部就是这样的结构。3。
【数据结构】邻接表
Eristic0618的博客
10-12 436
邻接表结构和数组模拟实现邻接表
数据结构编程实践20讲(Python版)—05二叉树
AnFany
10-08 1015
数据结构编程实践20讲(Python版)-05二叉树
数据结构-C语言顺序栈功能实现
m0_60984906的博客
10-12 71
数据结构C语言顺序栈功能实现（push压栈pop出栈打印栈）
iMeta: 南医大余光创组ggtree最新文章-系统发育树存储与可视化的数据结构
悟道西方
10-12 363
除了系统发育树树本身之外，使用 ggtree 中提出的方法在系统发育树上映射和可视化的所有信息都是可重用的，包括呈现为视觉特征以显示系统发育树的数据和用于生成与树对齐的图形的相关数据。ggtree对象本身是一个图形对象，一方面其可以渲染成静态图像，更重要的是，可视化中的系统发育树与相关数据可以从该图形对象中提取出来，使得ggtree能够成为发布系统发育树（图像、树与数据在一个对象中）的理想数据结构，从而增强数据的重用性，分析的可重复性以及促进综合和比较研究。汕头大学病毒学联合研究所。
数据结构-5.7.二叉树的层次遍历
ADCvbV的博客
10-12 88
注：1.最好初始化一个链队列(不是顺序队列)，因为被访问的二叉树难以得知有几个结点，也就难以得知队列要存几个元素(链队列方便增删)；2.链式队列结点结构体中存结点指针而不是结点数据，因为保存结点指针要比保存结点本身省空间；3.上述的visit函数就是用来访问出队结点的，函数体不固定，可以遍历结点值，也可以改变结点数据等；
八大排序--08快速排序
最新发布
m0_74977981的博客
10-12 280
7.以基准数为起始点，分为左右两部分，重复上述1-6步骤，直至数据都被拆分开结束。6.基准数和相遇位置的数据进行交换，交换完后的基准数到达正确位置；2.定义j游标，从后向前移动找到第一个比基准数小的值停下；3.定义i游标，从后向前移动找到第一个比基准数大的值停下；1.定义待排序数组中的第一个值为基准数；5.重复2-4步骤直到i和j相遇；4.i和j数值交换；
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值