数据结构——双链表

最新推荐文章于 2024-11-10 13:26:50 发布
最新推荐文章于 2024-11-10 13:26:50 发布
阅读量1.5k 收藏 30
点赞数 46
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc0123456789_/article/details/137938852
版权
本文详细介绍了双链表的概念、结构，以及如何通过代码实现包括初始化、打印、插入、删除和销毁等基本操作。作者强调了通过画图辅助理解的重要性。
摘要由CSDN通过智能技术生成

(一).双链表的概念和结构

首先我们来认识一下什么是双链表呢？

双链表其实就是在单链表的基础上增加了一个前驱指针用来存储上一个节点的地址，同样这次在双链表中我们也增加了哨兵位，也就是头节点，但在双链表的实现其实比单链表简单得多，只要对单链表掌握的通透那么双链表就不在话下，接下来我们通过一张图纸来了解双链表。

双链表的结构就是如图所示了，带头双链表中头里面是不存放数据的，只有两个存放地址的指针，这里我们了解了双链表的概念之后我们来进行一下代码实现。 

(二).双链表的实现

在进行双链表代码实现之前我们来先进行结构体的创建，

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;

这里注意每个节点有两个指针，就是指向上一个节点地址和指向下一个节点的地址的指针。 

2.1双链表的初始化

//申请新节点
LTNode* LTbuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	while (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}

// 双链表的初始化
void LTInit(LTNode** phead)
{
	//给双链表创建一个哨兵位
	*phead = LTbuyNode(-1);//由于哨兵位里面不存放任何地址所以传一个非节点值过去
}

这里我们要注意的是创建的哨兵位要让它的的next和prev指向自己让链表循环起来。

2.2双链表的打印

//双链表的打印
void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)//这里哨兵位里面是没有存放任何值的，由于双链表是循环链表所以让它循环到
		                 //等于哨兵位是就退出
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

2.3双链表的尾插

//申请新节点
LTNode* LTbuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	while (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}
//双链表的尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	LTNode* newnode = LTbuyNode(x);
	newnode->prev = phead->prev;
	newnode->next = phead;

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

}

这里面我们需要注意的是phead->prev->next = newnode和phead->prev = newnode;不能交换顺序因为如果交换了的话phead->prev就被改变了，前面的一个式子就不成立了。 

2.4双链表的头插

//双链表的头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTbuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;

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

进行头插之前我们要先判断是否存在除了哨兵位以外的节点。 

2.5双链表的尾删

//双链表的尾删
void LTPopBack(LTNode* phead)
{
	assert(phead&&phead->next);
	LTNode* del = phead->prev;

	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

这里我们需要注意的是尾删必须要断言节点必须存在，我们可以用del来代替phead->prev这样能降低代码复杂性让我们更容易理解。

2.6双链表的头删

//双链表的头删
void LTPopFront(LTNode* phead)
{
	//断言双链表和哨兵位的下一个节点不为空
	assert(phead && phead->next);
	LTNode* del = phead->next;
	phead->next = del->next;
	del->next = phead;
}

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

 这里查找要遍历整个链表，当走到哨兵位就退出。

2.8双链表中在pos位置之后插⼊数据


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

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

 这里同样又和上面一样的问题，最下面的两个式子的顺序不能改变。

2.9双链表中删除pos节点

//删除pos节点
void LTErase(LTNode* pos)
{
	//理论上来说pos节点是不能等于哨兵位的，但没有参数phead，无法校验
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

2.10双链表的销毁

//双链表的销毁
void LTDestroy(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}

注意：理论上LTErase和LTDestroy要用二级指针来接收，因为我们要用但是为了让实参影响实参，但我们为了保持接口的一致性，所以才传的一级指针，传一级指针问题是，当形参phead置为NULL后，实参plist不会置为NULL，我们需要手动将plist置为NULL ，将plist手动置为NULL的前提是我们后面不使用plist了。

(三).代码汇总

List.h:

#pragma once
//双链表的实现
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//双链表是节点是由指向上一节点指针+存储的数据+指向下一节点的指针组成
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;


//双链表的打印
void LTPrint(LTNode* phead);
//双链表的初始化
void LTInit(LTNode** phead);
//双链表的尾插
void LTPushBack(LTNode* phead, LTDataType x);
//双链表的头插
void LTPushFront(LTNode* phead, LTDataType x);

//双链表的尾删
void LTPopBack(LTNode* phead);
//双链表的头删
void LTPopFront(LTNode* phead);
//双链表中数据的查找
LTNode* LTFind(LTNode* phead, LTDataType x);

//在pos位置之后插⼊数据
void LTInsert(LTNode* pos, LTDataType x);
//删除pos节点
void LTErase(LTNode* pos);
//双链表的销毁
void LTDestroy(LTNode* phead);

List.c:

#include"List.h"
//双链表的打印
void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)//这里哨兵位里面是没有存放任何值的，由于双链表是循环链表所以让它循环到
		                 //等于哨兵位是就退出
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

//申请新节点
LTNode* LTbuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	while (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}

// 双链表的初始化
void LTInit(LTNode** phead)
{
	//给双链表创建一个哨兵位
	*phead = LTbuyNode(-1);//由于哨兵位里面不存放任何地址所以传一个非节点值过去
}
//双链表的尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	LTNode* newnode = LTbuyNode(x);
	newnode->prev = phead->prev;
	newnode->next = phead;

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

}

//双链表的头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTbuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;

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


//双链表的尾删
void LTPopBack(LTNode* phead)
{
	assert(phead&&phead->next);
	LTNode* del = phead->prev;

	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//双链表的头删
void LTPopFront(LTNode* phead)
{
	//断言双链表和哨兵位的下一个节点不为空
	assert(phead && phead->next);
	LTNode* del = phead->next;
	phead->next = del->next;
	del->next = phead;
}

//双链表中节点的查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

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

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

//删除pos节点
void LTErase(LTNode* pos)
{
	//理论上来说pos节点是不能等于哨兵位的，但没有参数phead，无法校验
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

//双链表的销毁
void LTDestroy(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}

test.c: 

#include"List.h"

void Listtest01()
{
	LTNode* plist = NULL;
	LTInit(&plist);

	LTPushBack(plist, 1);
	LTPrint(plist);
	LTPushBack(plist, 2);
	LTPrint(plist);
	LTPushBack(plist, 3);
	LTPrint(plist);
	LTPushBack(plist, 4);
	LTPrint(plist);
	LTPushFront(plist, 66);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTNode* find=LTFind(plist, 2);
	if (find == NULL)
	{
		printf("没找到！\n");
	}
	else
	{
		printf("找到了！\n");
	}
	LTInsert(find, 99);
	LTPrint(plist);
	LTErase(find);
	LTPrint(plist);
	LTDestroy(plist);
	//free(plist);
	//plist = NULL;
	LTPrint(plist);

}




int main()
{
	Listtest01();
	return 0;
}

(四).总结

上面就是双链表的实现全过程了，总的来说双链表在我们掌握了单链表的基础上我们就非常容易实现了，双链表可能在我们就凭空去想的话可能很难想出，但只要我们多去画画图，就会发现它的指向为题很简单，我们先通过画图理清代码思路去实现起来就so easy了，好了上面就是我要与大家分享的关于双链表的全部内容。

希望各位大佬在评论区指正我写的不对的地方我一定会认真改正，大家一起加油！

树之羽
关注
算法和数据结构——链表.pdf
08-07
在标题《算法和数据结构——链表.pdf》中提到的“算法”指的是对数据的处理过程和步骤，而“数据结构”是指数据在计算机中的组织方式，二者在计算机科学中是基础且核心的概念。在数据结构的学习中，链表是实现算法的...
漫话数据结构-双向链表及基本操作.pptx
11-03
本讲座主要探讨了一种特殊的数据结构——双向链表。双向链表是一种线性数据结构，它允许我们在列表中的节点之间进行双向移动，而不仅仅像单链表那样只能从前往后或从后往前。 双向链表的定义： 双向链表是由一系列...
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
数据结构——链表的创建、插入、删除.pdf
08-07
数据结构是计算机科学与信息处理领域内的重要概念，主要研究如何组织和存储数据，以便能够高效地对数据进行访问和修改。链表是一种基础的数据结构，特别适用于那些插入、删除操作频繁的场景，它的核心优势在于动态性...
数据结构——线性链表的实现
10-26
2. 双链表：每个节点有两个指针，一个指向前驱节点，一个指向后继节点。 3. 循环链表：最后一个节点的指针返回到链表的开头，形成一个循环。 ### 三、链表的操作 1. **创建链表**：初始化一个空链表，然后根据需要...
【数据结构与算法】-空间复杂度
前鼻音的博客
11-07 981
空间复杂度是衡量算法在运行过程中临时占用存储空间大小的一个重要指标。它描述了算法所需的额外存储空间与输入数据规模之间的关系。空间复杂度通常也用大O表示法（Big O notation）来表示。递归调用栈：考虑递归调用栈的深度。动态规划：考虑中间结果的存储空间。多维数组：考虑多维数组的大小。缓存和哈希表：考虑缓存和哈希表的大小。图的遍历：考虑访问状态记录和递归调用栈的大小。
【数据结构和算法】-时间复杂度
前鼻音的博客
11-07 889
时间复杂度是衡量算法执行效率的一个重要指标，它描述了算法运行时间与输入数据规模之间的关系。时间复杂度通常用大O表示法（Big O notation）来表示。选择合适的算法：根据实际需求和数据规模选择合适的时间复杂度，以优化程序性能。分析和优化：在编写算法时，应尽量避免高时间复杂度的操作，特别是在处理大规模数据时。理解时间复杂度有助于评估和优化算法的性能，从而提高程序的效率。
数据结构---排序（下）
深夜敲代码
11-07 452
一.快速排序补充一.快速排序补充快速排序的分治部分还有其他方法，如挖坑法，快慢指针法。1.挖坑法（重要）思路：先将基准位置元素用tmp保存，假定基准位置没有值（有个坑），然后分别从前后向中间遍历，右边大于基准就减减，遇到小于基准的就放到基准值位置的坑中，左边亦然，遍历整个数组后，将基准值填入最后一个左边遍历值。细节注意：填坑不是互换。
数据结构-串
m0_63056769的博客
11-09 796
拷贝构造函数拷贝构造函数的目的是在新对象初始化时，创建一个现有对象的副本。这是 C++ 的一种机制，用于在创建新对象时复制另一个对象的内容，确保新对象获得与原对象一样的内容和状态，但存储在独立的内存中。copy() 函数copy()函数是一个普通成员函数，用于显式复制当前对象并返回一个副本。它提供了一个方法，可以在任何时候手动调用来获取当前对象的副本，而不仅限于对象初始化阶段。特性拷贝构造函数copy() 函数调用方式自动调用（创建新对象并用现有对象初始化时）手动调用主要用途。
单链表的实现(数据结构)
OKkankan的博客
11-05 2103
我们在上一篇中简单的认识了链表的组成和结构，并打印出链表，那么今天就来具体实现一下单链表对于数据增加、删减、插入等。在实现让任何代码之前，我们都因该将思路理清楚，尾插该注意什么，怎么去是实现?首先一定是要找到最后一个结点，pphead是我们的头结点，我们一贯会将pphead赋给一个新的指针pcur，使用while循环找到最后一个结点，但是如果while里面是pcur的那我们不就直接跳出循环，那我们还怎么找最后一个结点呢？
python中常见的8种数据结构之一数组的应用
最新发布
2301_81121233的博客
11-10 287
可能的类型码包括`b`（有符号整数）、`B`（无符号整数）、`u`（Unicode字符）、`h`（有符号短整数）、`H`（无符号短整数）、`i`（有符号整数）、`I`（无符号整数）、`l`（有符号长整数）、`L`（无符号长整数）、`f`（浮点数）、`d`（双精度浮点数）等。数组和列表的主要区别在于数组中的元素必须是同一种类型，而列表中的元素可以是任何类型。可以通过索引访问数组中的元素，也可以使用切片操作来获取数组的子集。3.音频处理：音频数据通常也以数组的形式存储，数组可以用来处理音频的采样值。
数据结构---排序总结
深夜敲代码
11-07 309
O(n^2)：冒泡排序，选择排序，插入排序。O(n * log(n))：堆排序，快速排序，归并排序。O(n^1.3)：希尔排序2.空间复杂度：O(n)归并排序O(log(n)) ~ O(n)：快速排序O(1)：冒泡排序，选择排序，插入排序，堆排序，希尔排序。
【万字总结】数据结构常考应用大题做法画法详解_树_哈希表_图_排序大总结
weixin_62613321的博客
11-07 1132
【万字总结】数据结构常考应用大题做法画法详解_树_哈希表_图_排序大总结
c语言归并排序
yyw_17的博客
11-07 536
归并排序、归并排序思想、归并排序c语言代码
红黑树的平衡之舞：数据结构中的优雅艺术
17的博客
11-04 7268
在计算机科学的广阔天地中，数据结构如同乐器，各具特色，共同奏响高效算法的乐章。在众多自平衡树中，红黑树以其独特的结构与高效的性能，成为了实现平衡的典范。本博文将深入探讨红黑树的原理、特点及其在实际应用中的表现，揭示这一数据结构如何在动态数据操作中保持高效与稳定。红黑树是一种自平衡的二叉搜索树，其中每个节点都被标记为红色或黑色。通过这些颜色标记以及特定的规则，红黑树能够在插入和删除节点时保持平衡，从而确保基本操作的效率。public://结点中存的键值对color _col;//结点的颜色。
Java进阶嵌套循环：十.冒泡与选择算法排序
2301_77163982的博客
11-06 357
使用冒泡与选择算法实现数组的排序
数据结构——线性表与链表
m0_72678953的博客
11-07 277
为了能够检测到sequence对象是否为空，我们会再第一个元素设置一个空的元素对象，当做虚拟头结点，放在初始化的时候。在结构体下面写一些函数，使用this指代当时实例化的对象，其再运行时确定具体值，用来引用自身属性。测试样例使用方法进行模拟，传入具体的顺序表的实例对象，即可进行添加操作。于是将线性表设计成单独的结构体，此外的元素对象单独再设计另一个结构体。这里的想法是，线性表是一个独立的个体，但是它又由多个元素组成。我们创建好结构体之后，使用 new()就可以创建一个该对象。
数据结构 —— 红黑树
hedhjd的博客
11-03 2109
新增结点标识为c(cur)，c的⽗亲标识为p(parent)，p的⽗亲标识为 g(grandfather)，p的兄弟标识为u（uncle)新增结点标识为c(cur)，c的⽗亲标识为p(parent)，p的⽗亲标识为 g(grandfather)，p的兄弟标识为u（uncle)c为红，p为红，g为⿊，u不存在或者u存在且为⿊，u不存在，则c⼀定是新增结点。c为红，p为红，g为⿊，u不存在或者u存在且为⿊，u不存在，则c⼀定是新增结点。u存在且为⿊，则c⼀定不是新增，c之前是⿊⾊的，是在c的⼦树中插⼊。
【数据结构和算法】五、贪心算法原理讲解的实战演练
weixin_45736855的博客
11-07 974
贪心算法的原理、思路介绍
数据结构-双向链表前插操作详解
这篇讲义主要讲解了数据结构中的一个重要概念——双向链表，并提供了前插操作的算法。双向链表是一种特殊的数据结构，每个节点不仅包含数据，还包含指向下一个节点和上一个节点的指针。这使得在链表中进行插入和删除...
评论 27
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值