【数据结构】——双向链表详细理解和实现

已于 2024-07-24 21:58:26 修改
阅读量1.2k 收藏 32
点赞数 42
分类专栏： 【C语言】数据结构 文章标签： 链表 数据结构
于 2024-07-08 11:04:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lh__1314/article/details/140258734
版权

                                                                                         欢迎光顾我的homepage                                                              

前言

        双向链表是一种带头双向循环的链表。在双向链表中，首先存在着一个头结点；其次每个节点有指向下一个节点的指针next 和指向上一个节点的指针prev ；最后，双向链表的头结点中存放上一个节点的指针指向链表的尾节点，尾节点中存放下一个节点的指针指向链表的头结点，形成一个闭环。这样双向链表既可以从前遍历，也可以从后遍历，直到回到起点。

一、链表的分类

        链表的结构多种多样，链表呢可以是带头（不带头）、双向（单向）、循环（不循环）的，我们之前实现的单链表其实就是不带头，单向，不循环的链表。

而这些有什么区别呢？

        带头和不带头

这里带头和不带头指的是有没有头结点，这单链表的实现过程中，是直接创建一个指针变量指向链表的第一个节点（这是没有头结点的情况），而存在头结点呢，就是一个哨兵位，里面没有存放数据，存放了指向第一个节点的指针。

        可以看到，带头的链表多了一个节点（head），这个节点中没有存放任何数据，这样做可以方便对链表的节点进行统一操作。

        单向和双向

    单向是可以通过一个节点找到它的后一个节点，而双向是可以通过一个节点找到它前后的节点。

        循环和不循环

    这实现单链表的时候，我们将链表的最后一个节点next指针置位了空指针（NULL），而循环的链表中，我们会将最后一个节点的next指针指向链表的头结点，对于双向链表，将头节点的prev(上一个节点）指针指向链表的尾节点。

二、双向链表的实现

这里实现的双向链表，先来看一下双向链表的节点结构

双向链表节点

typedef int LTDataType;
//双向链表
typedef struct ListNode
{
	struct ListNode* prev;  //指向上一个节点
	struct ListNode* next;  //指向下一个节点
	LTDataType data;
}LTNode;

双向链表的功能预览

//初始化并创建头结点
void LTInit(LTNode** phead);
//LTNode* LTInit();
//输出
void LTPrint(LTNode* phead);
//创建新的节点
LTNode* LTBuyNode(LTDataType x);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);
//尾删
void LTPopBack(LTNode* phead);
//查找
LTNode* LTFind(LTNode* phead, LTDataType find);
//在pos节点之后插入数据
void LTPushAfter(LTNode* pos, LTDataType x);
//在pos节点之前插入数据
void LTPush(LTNode* pos, LTDataType x);
//删除pos节点
void LTPop(LTNode* pos);
//链表销毁
void LTDesTroy(LTNode* phead);

2.1、创建新的节点

        创建节点，和单链表一样，都是动态开辟的空间。

//创建新的节点
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* ptail = (LTNode*)malloc(sizeof(LTNode));
	if (ptail == NULL)
	{
		perror("LTBuyNode--malloc filed!");
		exit(1);
	}
	ptail->data = x;
	ptail->prev = ptail->next = NULL;
	return ptail;
}

2.2、双向链表初始化并创建头结点

        链表初始化，其实就是创建一个头节点（也叫哨兵位）；因为这里是双向链表，创建完头节点之后，让头节点的prev和next指针都指向它自己。

//初始化并创建头结点
void LTInit(LTNode** phead)
{
	*phead = LTBuyNode(-1);
	(*phead)->prev = (*phead)->next = *phead;
}

2.3、输出链表

        遍历链表并输出有效数据，这里双向链表可以从前开始遍历也可以从后开始遍历。

//输出
void LTPrint(LTNode* phead)
{
	LTNode* ptail = phead->next;
	//遍历双向链表 -- 从前开始遍历
	while (ptail != phead)
	{
		printf("%d -> ", ptail->data);
		ptail = ptail->next;
	}
	printf("\n");
}

2.4、双向链表头插数据

        从链表的头部插入数据，创建新的节点，然后将新的节点prev指针指向头节点，将next指针指向头节点的下一个节点；然后修改头节点的next指针和头节点下一个节点的prev指针即可。

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

	//修改前后节点的指针指向
	phead->next->prev = newnode;
	phead->next = newnode;
}

2.5、双向链表尾插数据

        从链表尾部插入到尾节点的后面，创建新的节点，将新节点的prev指针指向头节点的上一个节点，将next指针指向头节点，然后修改尾节点的next指针和头节点的prev指针即可。

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

	//修改前后节点指针指向
	phead->prev->next = newnode;
	phead->prev = newnode;
}

2.6、双向链表头删数据

        头删是删除头节点的后一个节点，因为是动态开辟的内存，需要内存释放；删除后，让头节点的next指针 指向下一个数据的节点。

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead != phead->next); //链表为空的话就不能进行删除
	LTNode* del = phead->next;  
	phead->next->next->prev = phead;
	phead->next = phead->next->next;
	free(del);
	del = NULL;
}

2.7、双向链表尾删数据

        尾插是删除链表的尾节点，释放内存之后，让尾节点的上一个节点next指针指向头节点，头节点的prev指针指向删除节点的上一个节点。

//尾删
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;
}

2.8、双向链表查找数据

        这里如果找到了，就返回该节点的指针，如果没有就返回NULL；方便对其进行前后插入数据和删除。

//查找
LTNode* LTFind(LTNode* phead, LTDataType find)
{
	assert(phead);
	LTNode* ptail = phead->next;
	while (ptail != phead) //遍历链表
	{
		if (ptail->data == find) {
			return ptail;
		}
		ptail = ptail->next;
	}
	return NULL;
}

2.9、在指定节点pos之前插入数据

        根据我们查找到的节点，在其之前插入数据，首先创建新节点，将新节点的prev指针指向pos的前一个节点，新节点的next指针指向pos；再修改pos的上一个节点的next指针指向和pos的prev指针指向即可；

//在pos节点之前插入数据
void LTPush(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos;
	newnode->prev = pos->prev;

	//修改pos前后节点指针的指向
	pos->prev->next = newnode;
	pos->prev = newnode;
}

        这里就可以发现双向链表的一个好处，不用像单向链表那样遍历链表来寻找pos的上一个节点。

2.10、在指定节点pos之后插入数据

        根据查找到的节点，在其之后插入数据；首先创建节点，将新节点的prev指针指向pos，新节点的next指针指向pos的下一个节点；然后修改pos的next指针指向和pos下一个节点的prev指针指向即可。

//在pos节点之后插入数据
void LTPushAfter(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;

	//修改pos前后节点指针的指向
	pos->next->prev = newnode;
	pos->next = newnode;
}

2.11、删除指定节点pos

        根据查找到的节点，然后将其删除，这里需要修改pos前后节点的指针指向。

//删除pos节点
void LTPop(LTNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

2.12、双向链表的销毁

        及时对动态开辟的内存进行释放，养成好习惯

        现在，动态开辟的链表需要进行销毁（也就是动态内存释放），这里就需要遍历链表了。

//链表销毁
void LTDesTroy(LTNode* phead)
{
	assert(phead);
	LTNode* ptail = phead->next;
	while (ptail != phead)
	{
		LTNode* del = ptail->next;
		free(ptail);
		ptail = del;
	}
	free(ptail);
	ptail = NULL;
}


代码总览

List.h

#define _CRT_SECURE_NO_WARNINGS

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

typedef int LTDataType;
//双向链表
typedef struct ListNode
{
	struct ListNode* prev;  //指向上一个节点
	struct ListNode* next;  //指向下一个节点
	LTDataType data;
}LTNode;

//初始化并创建头结点
void LTInit(LTNode** phead);
//LTNode* LTInit();
//输出
void LTPrint(LTNode* phead);
//创建新的节点
LTNode* LTBuyNode(LTDataType x);
//头插
void LTPushFront(LTNode* phead, LTDataType x);
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);
//尾删
void LTPopBack(LTNode* phead);
//查找
LTNode* LTFind(LTNode* phead, LTDataType find);
//在pos节点之后插入数据
void LTPushAfter(LTNode* pos, LTDataType x);
//在pos节点之前插入数据
void LTPush(LTNode* pos, LTDataType x);
//删除pos节点
void LTPop(LTNode* pos);
//链表销毁
void LTDesTroy(LTNode* phead);

List.c

#include"List.h"

//创建新的节点
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* ptail = (LTNode*)malloc(sizeof(LTNode));
	if (ptail == NULL)
	{
		perror("malloc filed!");
		exit(1);
	}
	ptail->data = x;
	ptail->prev = ptail->next = NULL;
	return ptail;
}
//初始化并创建头结点
void LTInit(LTNode** phead)
{
	*phead = LTBuyNode(-1);
	(*phead)->prev = (*phead)->next = *phead;
}
//输出
void LTPrint(LTNode* phead)
{
	LTNode* ptail = phead->next;
	//遍历双向链表 -- 从前开始遍历
	while (ptail != phead)
	{
		printf("%d -> ", ptail->data);
		ptail = ptail->next;
	}
	printf("\n");
}
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead;
	newnode->next = phead->next;

	//修改前后节点的指针指向
	phead->next->prev = newnode;
	phead->next = newnode;
}
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead->prev;
	newnode->next = phead;

	//修改前后节点指针指向
	phead->prev->next = newnode;
	phead->prev = newnode;
}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead != phead->next); //链表为空的话就不能进行删除
	LTNode* del = phead->next;  
	phead->next->next->prev = phead;
	phead->next = phead->next->next;
	free(del);
	del = NULL;
}
//尾删
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;
}
//查找
LTNode* LTFind(LTNode* phead, LTDataType find)
{
	assert(phead);
	LTNode* ptail = phead->next;
	while (ptail != phead) //遍历链表
	{
		if (ptail->data == find) {
			return ptail;
		}
		ptail = ptail->next;
	}
	return NULL;
}
//在pos节点之前插入数据
void LTPush(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos;
	newnode->prev = pos->prev;

	//修改pos前后节点指针的指向
	pos->prev->next = newnode;
	pos->prev = newnode;
}
//在pos节点之后插入数据
void LTPushAfter(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;

	//修改pos前后节点指针的指向
	pos->next->prev = newnode;
	pos->next = newnode;
}

感谢各位大佬支持并指出问题，

                如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！

努力学习的小廉
关注
  • 42
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
双向链表及其应用——实现多项式的加法及乘法
10-23
在IT领域，数据结构是...通过理解和掌握双向链表，不仅可以提升对数据结构的理解，也能为解决复杂问题提供有力的工具。在C++编程中，熟练运用类和抽象类可以提高代码的可读性和可维护性，这也是软件开发中的重要原则。
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
数据结构——双向链表
麦麦的博客
03-11 2154
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6386
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
Java数据结构与算法——双向链表
★★光亭★★
03-11 6109
Java数据结构与算法——双向链表
数据结构学习——双向链表
weixin_62410421的博客
05-03 5021
文章目录前言——双向链表含义一、双向链表结构（图解）二、 双向链表的实际操作1、 结构2、创建头结点3、打印4、插入5、定位6、删除完整代码运行结果 前言——双向链表含义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、双向链表结构（图解） 二、 双向链表的实际操作 1、 结构 /** * Double linked list of integ
漫话数据结构-双向链表及基本操作.pptx
11-03
本讲座主要探讨了一种特殊的数据结构——双向链表。双向链表是一种线性数据结构，它允许我们在列表中的节点之间进行双向移动，而不仅仅像单链表那样只能从前往后或从后往前。 双向链表的定义： 双向链表是由一系列...
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
插入和选择排序
c23856的博客
07-20 549
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
dab112的博客
07-24 1214
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1093
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 972
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
《数据结构：栈和队列》
2401_83305953的博客
07-19 701
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
数据结构——二叉树定义
鲸落博客
07-23 390
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
数据结构：栈
sparrowfart的博客
07-19 1199
满足栈的特性，只有先进后出的特性，不能遍历，也就不能遍历打印，也不能随机访问。
2024.7.24 作业
qq_64434282的博客
07-24 1069
【代码】2024.7.24 作业。
数据结构的概念和术语
最新发布
2303_78660417的博客
07-24 471
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
双向链表实现多级菜单
09-22
可以使用双向链表来实现多级菜单。在双向链表中，每个节点包含一个数据项和两个指针，一个指向前一个节点，一个指向后一个节点。通过这种方式，可以在多级菜单中轻松地实现上下级关系。 以下是一个使用双向链表实现多级菜单的示例代码： ```python class MenuItem: def __init__(self, label): self.label = label self.child = None self.parent = None self.next_sibling = None def create_menu(): # 创建根节点 root = MenuItem("Root") # 创建一级菜单项 level1_item1 = MenuItem("Level 1 Item 1") level1_item2 = MenuItem("Level 1 Item 2") # 将一级菜单项添加到根节点下 root.child = level1_item1 level1_item1.parent = root level1_item1.next_sibling = level1_item2 level1_item2.parent = root # 创建二级菜单项 level2_item1 = MenuItem("Level 2 Item 1") level2_item2 = MenuItem("Level 2 Item 2") # 将二级菜单项添加到一级菜单项下 level1_item1.child = level2_item1 level2_item1.parent = level1_item1 level2_item1.next_sibling = level2_item2 level2_item2.parent = level1_item1 # 创建更多菜单项... return root ``` 这样你就可以使用双向链表创建多级菜单。你可以根据需要添加更多菜单项，并设置它们之间的关系。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值