【数据结构】-----双链表（小白必看！！！）

最新推荐文章于 2024-11-08 14:08:42 发布
最新推荐文章于 2024-11-08 14:08:42 发布
阅读量1.6k 收藏 28
点赞数 59
分类专栏： C语言数据结构 文章标签： 数据结构 c++ c# 开发语言 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bhbcdxb123/article/details/137676068
版权

9efbcbc3d25747719da38c01b3fa9b4f.gif

 c语言中的小小白-CSDN博客c语言中的小小白关注算法,c++,c语言,贪心算法,链表,mysql,动态规划,后端,线性回归,数据结构,排序算法领域.https://blog.csdn.net/bhbcdxb123?spm=1001.2014.3001.5343

给大家分享一句我很喜欢我话：

知不足而奋进，望远山而前行！！！

铁铁们，成功的路上必然是孤独且艰难的，但是我们不可以放弃，远山就在前方，但我们能力仍然不足，所有我们更要奋进前行！！！

今天我们更新了双链表内容，

🎉 欢迎大家关注🔍点赞👍收藏⭐️留言📝

什么是双链表？

双链表的定义
 为什么引入双链表？

 单链表的结点中只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，访问后驱结点的复杂度为O(1)，访问前驱结点的复杂度为O(n)。为了克服上述缺点，引入了双链表。

 双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。

 双链表中结点类型的描述：

typedef int ListDataType;

struct ListNode 
{
	ListDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;


typedef struct ListNode LTNode;

这里可以看到我们把int变为ListNodeType类型，因为我们这个节点不一定就是int类型，用ListData代替int，就可以存储别的类型的数据了。啥时候用啥时候换。

然后用LTNode代替struct ListNode，这样更方便一些。

双链表上的操作：

1.1双链表的初始化：

在初始化之前，我们这里先说一下如何创建一个新节点。因为刚开始数据为空，因此我们先要创建新节点才可以。

//创建新节点
LTNode* BuyNode(ListDataType x)
{
	LTNode* newhead = (LTNode*)malloc(sizeof(LTNode));
	if (newhead == NULL)
	{
		perror("malloc fail !!!");
	}

	newhead->next = newhead->prev = NULL;
	newhead->data = x;
	return newhead;
}

这就是创建新节点的代码。

下面我们来看一下初始化的代码：

//初始化
LTNode* InitNode()
{
	LTNode* phead = BuyNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

这样我们就完成了第一步，链表的初始化。这里记住我们创建出来的第一个节点，不能直接去使用，而是要指向本身才可以。否则会将自身变为NULL。

1.2打印链表：

这里也是非常简单，就是我们遍历链表即可。

void ListNodeprint(LTNode* head)
{
	assert(head);
	LTNode* cur = head->next;
	while (cur != head)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

这里要注意的就是，while循环中条件不能是cur，否则这样就会无限的进行下去，我们要令cur！=head。这里的head就是我们的第一个节点，我们也叫它为哨兵位。

1. 3后插

后插相对来说也是比较简单的，下面我们来看一下代码。

//后插
void LTNPushBack(LTNode* phead, ListDataType x)
{
	assert(phead);
	LTNode* newhead = BuyNode(x);
	LTNode* Tail = phead->prev;

	Tail->next = newhead;
	newhead->prev = Tail;

	newhead->next = phead;
	phead->prev = newhead;

}

首先我们要对phead进行断言，防止传过来的是空指针。

然后这个交换的过程需要大家自己慢慢去琢磨，原理很简单，就是将原本的最后一个变成新的节点，哨兵位的上一个变成新的节点。只是存在一些细节需要大家去注意一下。

1.4前插

//前插
void LTPushFront(LTNode* phead, ListDataType x)
{
	assert(phead);
	LTNode* newhead = BuyNode(x);

	LTNode* Tail = phead->next;

	newhead->next = Tail;
	Tail->prev = phead;
	
	phead->next = newhead;
	newhead->prev = phead;


}

这个是前插的代码，原理和后插也大差不差，还是将哨兵位的下一个变成新节点，原本的第一个节点变成第二个节点。

1.5头删

//头删
void LTPopFront(LTNode* head)
{
	assert(head);
	assert(head->next != head);

	LTNode* Next = head->next;
	head->next = Next->next;

	Next->prev = head;

	free(Next);
	Next = NULL;

}

头删就是一定要断言head和head的下一个，如果只有一个哨兵位也无法进行删除。

然后剩下的就是把哨兵位的下一个变成第二个节点，第二个节点的上一个变成哨兵位，最后将原本的第一个节点释放掉，置为NULL。

1.6尾删

/尾删
void LTPopBack(LTNode* head)
{
	assert(head);
	assert(head->next != head);

	LTNode* cur = head->prev;
	head->prev = cur->prev;
	head->prev->next = head;
	free(cur);
	cur = NULL;
}

依然是对head和他的下一个进行断言。然后思路与前面的头删大致相同。只是是对哨兵位的上一个进行操作。

1.7任意插入

//任意插入
void LTInsert(LTNode* pos, ListDataType x)
{
	assert(pos);
	LTNode* newhead = BuyNode(x);
	LTNode* posPrev = pos->prev;

	newhead->prev = posPrev;
	posPrev->next = newhead;

	pos->prev = newhead;
	newhead->next = pos;

}

这里的任意插入我们需要事先找到我们要插入的数的位置，然后在这个位置的后面进行插入。这就需要一个find函数，这个我们后面会讲到，暂时不用去管，我们先弄清楚任意插入的思路，就是将创建一个新的节点，然后将pos的下一个变成它，后面的节点的前一个变成他。

1.8任意位置删除

//pos删除
void LTErase(LTNode* pos)
{
	//pos理论上不能为phead，但是没有参数phead，无法增加校验
	assert(pos);

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

	free(pos);
	pos = NULL;

这个依然要用到Find函数，还是先不用去管，我们先看一下这个的思路，思路也是很简单，就是将pos前面的节点指向pos后面，pos后面的节点指向pos前面。

1.9寻找

LTNode* LTFind(LTNode* head, ListDataType x)
{
	assert(head);
	assert(head->next != NULL);

	LTNode* cur = head->next;
	while (cur != head)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	printf("找不到\n");
	return NULL;
}

这里就是我们find函数的代码了，我们首先要对head和head->next进行断言，防止其是NULL，然后创建一个cur，进行while循环，条件依旧是cur!=head，然后找到的话就返回这个节点，找不到就返回空指针。

1.10链表的销毁

最后我们来说一下链表的销毁，这里我们要对每一个节点都要销毁。

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

这个就要相对简单一些了，就是令pcur等于head->next,然后遍历，最后对phead进行销毁。

全部代码

List.h:

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


typedef int ListDataType;

struct ListNode 
{
	ListDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;


typedef struct ListNode LTNode;

//初始化
LTNode* InitNode();

//创建新节点
LTNode* BuyNode(ListDataType x);


//打印
void ListNodeprint(LTNode* head);

//后插
void LTNPushBack(LTNode* phead, ListDataType x);

//前插
void LTPushFront(LTNode* phead, ListDataType x);

//头删
void LTPopFront(LTNode* head);

//尾删
void LTPopBack(LTNode* head);


//任意点插入
void LTInsert(LTNode* pos, ListDataType x);

//任意点删除
void LTErase(LTNode* pos);

//查找
LTNode* LTFind(LTNode* head, ListDataType x);


//链表的销毁
void LTDestroy(LTNode* phead);

List.c:

#include"List.h"


//创建新节点
LTNode* BuyNode(ListDataType x)
{
	LTNode* newhead = (LTNode*)malloc(sizeof(LTNode));
	if (newhead == NULL)
	{
		perror("malloc fail !!!");
	}

	newhead->next = newhead->prev = NULL;
	newhead->data = x;
	return newhead;
}


//初始化
LTNode* InitNode()
{
	LTNode* phead = BuyNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}



//打印
void ListNodeprint(LTNode* head)
{
	assert(head);
	LTNode* cur = head->next;
	while (cur != head)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}


//后插
void LTNPushBack(LTNode* phead, ListDataType x)
{
	assert(phead);
	LTNode* newhead = BuyNode(x);
	LTNode* Tail = phead->prev;

	Tail->next = newhead;
	newhead->prev = Tail;

	newhead->next = phead;
	phead->prev = newhead;

}



//前插
void LTPushFront(LTNode* phead, ListDataType x)
{
	assert(phead);
	LTNode* newhead = BuyNode(x);

	LTNode* Tail = phead->next;

	newhead->next = Tail;
	Tail->prev = phead;
	
	phead->next = newhead;
	newhead->prev = phead;


}

//头删
void LTPopFront(LTNode* head)
{
	assert(head);
	assert(head->next != head);

	LTNode* Next = head->next;
	head->next = Next->next;

	Next->prev = head;

	free(Next);
	Next = NULL;

}



//尾删
void LTPopBack(LTNode* head)
{
	assert(head);
	assert(head->next != head);

	LTNode* cur = head->prev;
	head->prev = cur->prev;
	head->prev->next = head;
	free(cur);
	cur = NULL;
}



//任意插入
void LTInsert(LTNode* pos, ListDataType x)
{
	assert(pos);
	LTNode* newhead = BuyNode(x);
	LTNode* posPrev = pos->prev;

	newhead->prev = posPrev;
	posPrev->next = newhead;

	pos->prev = newhead;
	newhead->next = pos;

}


//pos删除
void LTErase(LTNode* pos)
{
	//pos理论上不能为phead，但是没有参数phead，无法增加校验
	assert(pos);

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

	free(pos);
	pos = NULL;

}


LTNode* LTFind(LTNode* head, ListDataType x)
{
	assert(head);
	assert(head->next != NULL);

	LTNode* cur = head->next;
	while (cur != head)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	printf("找不到\n");
	return NULL;
}


//链表的销毁
void LTDestroy(LTNode* phead)
{
	assert(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"


int main()
{
	LTNode* head = InitNode();

	LTNPushBack(head, 1);
	LTNPushBack(head, 2);
	LTNPushBack(head, 3);
	LTNPushBack(head, 4);

	LTNode* find = LTFind(head, 1);
	LTErase(find);
	find = NULL;

	//打印
	ListNodeprint(head);

	//销毁
	LTDestroy(head);
}

总结：

双链表是一种常见的数据结构，与单链表相比，每个节点不仅保存了指向下一个节点的指针，还保存了指向前一个节点的指针。这种结构的引入增加了链表的灵活性和功能性。

首先，双链表支持双向遍历。由于每个节点都有指向前一个节点的指针，可以从任一节点开始向前或向后遍历链表，这对于某些操作如逆序遍历或者在特定节点前后插入节点非常方便。

其次，双链表更便于节点的删除和插入。在单链表中，要删除或插入一个节点，需要找到其前一个节点，而在双链表中，只需要修改节点本身的指针即可，无需额外的查找操作，从而提高了操作效率。

然而，双链表相比单链表需要额外的空间来存储前一个节点的指针，因此会占用更多的内存。在某些情况下，如果对内存占用有限制，可能需要权衡选择是否使用双链表。

总的来说，双链表是一种功能强大的数据结构，适用于需要频繁进行节点插入、删除和双向遍历的场景，但在内存占用上需要谨慎权衡。

二进制掌控者
关注
专栏目录
数据结构 -- 链表
m0_59748326的博客
04-18 368
本篇文章主要梳理链表相关概念及代码实现。
数据结构-链表（C语言实现，超详细！！小白必看！！）
2301_79381549的博客
08-24 1022
你可以把单链表想象成一串珍珠项链，每一颗珍珠都代表一个数据元素，而连接这些珍珠的线就相当于指针，指向下一个珍珠（元素）。在单链表中，每个元素都保存着下一个元素的地址，这样就能够按顺序访问链表中的每一个元素。//这里把int类型重命名为SLTDataType，是为了方便以后单链表储存别的类型数据，因为数据域指的可能是整型也可能是字符串等等，如果以后想要储存别的类型的数据只需要在这里把int改为别的类型即可，不需要在后面的代码去逐个改变//数据域//指针域}SLTNode;
C语言中的数据结构--双向链表
2301_78694309的博客
04-12 1524
C语言实现双向链表
数据结构----循环链表 C++
weixin_50490968的博客
08-13 495
循环双链表
python数据结构-双向链表
Big_Older的博客
04-10 198
双向链表 一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。 操作 is_empty() 链表是否为空 length() 链表长度 travel() 遍历链表 add(item) 链表头部添加 append(item) 链表尾部添加 insert(pos, item...
JAVA数据结构总结--小白入门
qq_51772768的博客
12-11 244
一些小小的总结，希望可以帮助到大家。
数据结构（C语言） -- 双链表demo
weixin_44977283的博客
07-28 137
【代码】数据结构（C语言） -- 双链表demo。
数据结构（C语言） -- 双循环链表demo
weixin_44977283的博客
07-28 122
有头节点的双向循环链表。
【数据结构】——单链表超详细介绍（独家介绍，小白必看！！！）
热门推荐
yakiyakiya的博客
09-06 2万+
今天又是认真更新的一天耶！！一万字的文章，带你吃透单链表！文章内含链表的构建、链表构建时的易错点和注意事项以及链表与顺序表的区别，详细讲解到小白都能学会。
多线程安全型双向链表-C++实现
12-21
在C++编程中，多线程环境下的数据结构设计是一个重要的课题，特别是在处理并发操作时。本项目实现了一个多线程安全的双向链表，它允许在多个线程中同时进行增删节点、读写操作，确保数据一致性。以下是这个实现涉及...
适合小白的python算法-双指针问题
12-21
在Python编程中，双指针是一种常用的数据结构操作技巧，尤其在处理数组和链表等线性结构时。双指针问题通常涉及两个指针，它们从数组的两端或者某一点开始，以不同的速度或方向遍历数组，从而解决特定的算法问题。...
数据结构-带头节点的单链表（C语言）超详细讲解
m0_56992713的博客
10-17 2万+
前面我们学到线性表的顺序存储结构（顺序表），发现它有着明显的缺点：插入和删除元素时需要频繁的移动元素，运算效率低。必须按事先估计的最大元素个数申请连续的存储空间。存储空间估计大了，造成浪费空间；估计小了，容易产生溢出，空间难以扩大。 采用链式存储结构的线性表（链表）可以克服以上的不足。 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(存放的数据元素)+指针(指示下一个元素存储位置，单、双链表的最后一个节点除外，它们.
双向链表的基本操作-结点插入、结点删除、整表删除、正序遍历、逆序遍历
asfd_4的博客
07-15 1121
第二期 双向链表的基本操作
数据结构学习笔记----[小白版]
小男孩的博客
02-12 383
数据结构学习笔记 本篇内容是根据郝斌老师数据结构的学习笔记 如有侵权或总结中有任何错误愿意通过邮箱，QQ联系我的话，本人将万分感谢。 邮箱：zzy2wjj@163.com QQ：227222517 定义: 我们如何把现实中大量而复杂的问题以特定的数据类型(个体如何来存储)和特定存储结构(个体和个体的的关系)保存到主存储器（内存）中，以及在此基础上为实现某功能(eg:比如查找某个元素，删除某个元素，...
数据结构 栈和队列
最新发布
qq_67140973的博客
11-08 505
正文开始。
Java：数据结构-Lambda表达式
blamep的博客
11-08 543
lambda表达式允许你通过表达式来代替功能接口。lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
【数据结构与算法】第9课—数据结构之二叉树(链式结构)
weixin_70620792的博客
11-05 767
2为底，n+1为对数，n为二叉树节点数。
【STL栈和队列】：高效数据结构的应用秘籍
LH__1314的博客
11-05 953
C++ 标准模板库（STL）为我们提供了多种容器，其中stack（栈）和queue（队列）是非常常用的两种容器。根据之前C语言实现的栈和队列，（如有遗忘，请回去看看【数据结构】— 栈和队列-CSDN博客）我们知道一些栈和队列的逻辑，现在就来学习C++STL中的栈和队列。eque`（双端队列）既可以当作栈，也可以当作队列使用。我们可以在双端队列的两端进行插入和删除操作，从而更灵活地实现栈和队列的功能。​对于双端队列，简单来说，就是可以像vector那样随机访问，也可以像链表那样随机位置插入；
Java：数据结构-枚举
blamep的博客
11-08 366
枚举 概念：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式。 public static final int RED = 1; public static final int GREEN = 2; public static final int BLACK = 3; 枚举的使用 public enum enumTest { RED(0,"RED"),GREEN(1,"GREEN"),BLUE(2,"BLUE"), BLACK(3,"BLACK"),WHI
数据结构与算法解析：链表及链表操作
面试题库涉及数据结构，如链表、栈、队列、树等，以及编程实践，如手写代码实现链表操作。" 本文将详细讨论在IT行业中，特别是GIS（地理信息系统）领域，数据结构与算法的重要性及其在arcgis中的具体应用。首先，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值