【数据结构详解】——线性表之双向链表（动图详解）

最新推荐文章于 2023-02-04 18:36:07 发布
最新推荐文章于 2023-02-04 18:36:07 发布
阅读量265 收藏 1
点赞数 1
分类专栏： 数据结构详解 文章标签： 链表 数据结构 c语言 算法 经验分享
❗ 转载请注明出处 作者：HinsCoder 博客链接：
本文链接：https://blog.csdn.net/HinsCoder/article/details/126189083
版权

📖 前言：本期我们将讨论链表的另外一种结构————双向链表，相比单链表那可谓是优势多多。

🎓 作者：HinsCoder
📦 作者的GitHub：代码仓库
📌 往期文章&专栏推荐：

  1. 【C语言详解】专栏
  2. 【C语言详解】——函数栈帧的创建与销毁（动图详解）
  3. 【数据结构详解】——线性表之顺序表（多图详解）
  4. 【数据结构详解】——线性表之单链表（动图详解）

目录📌

🕒 1. 单链表的缺点

上一期我们学习了单链表（单向不带头非循环链表），发现它虽然相比顺序表是有一定的优势的，但是它的缺陷也是不可忽视的。

  • 假如找一个数据只能从前向后依次遍历，而且链表中一旦一个结点的地址丢失了，这个结点往后所有的结点都找不到了；
  • PopBack（尾删），Insert（任插），Erase（任删）的时间复杂度都是O(N)，都是需要从头开始找前一个结点；
  • 几乎每个接口都需要判断链表是否为空，比较麻烦。

针对这些缺陷的解决方案是什么呢?————就是双链表（双向带头循环链表）

🕒 2. 链表的分类

链表分别有六个特点：

  • 单向、双向
  • 带头、不带头
  • 循环、非循环

⚡ 注意： 头结点（哨兵位）是不能存储有效数据的

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

🕘 2.1 带头结点（哨兵位）的优点

不管链表如何，都有一个头结点在那里，但是这个头结点不存储有效数据，尾插的话直接链接在头结点后面就行，这样我们几乎用不到二级指针了，因为我们并不会改变外面的指针，而是在这个结点后面去链接，哪怕链表为空，所以带头结点的链表尾插判断会更简单。

  1. 头删也是如此，如果是不带头单链表，删除一个数据的话，需要定义一个del结点，让del指向被删结点，之后将被删结点后一个与头指针链接起来，然后释放del，由于需要动pHead，因此需要二级指针。
  2. 如果是带头结点链表的话，删除第一个结点，然后将头结点链接到第二个结点上即可，无需二级指针

带头与否单链表头删函数动画
⌛ 小结：

  • 带头结点不需要改变传过来的指针，也就意味着不需要传二级指针。
  • 头结点是不存储有效数据的，更不能存储链表的长度。

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

  1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

🕒 3. 双向带头循环链表的接口实现

🕘 3.1 定义双链表

typedef int DLTDataType;
typedef struct DListNode
{
	struct DListNode* next;
	struct DListNode* prev;
	DLTDataType data;
}DLTNode;

🕘 3.2 初始化双链表

说起初始化，我们应该会马上想到以下代码的传参方式，

void DListInit(DLTNode** pphead);

int main()
{
	DLTNode* plist = NULL;
	DListInit(&plist);

	return 0;
}

我们思考一下，既然带头结点的链表都不需要传二级指针，那么在初始化这块传二级指针岂不是很突兀？我们想想看，有什么不用传二级指针的方式。

想到了，返回值不就行了。

上代码

DLTNode* DListInit()
{
	DLTNode* guard = (DLTNode*)malloc(sizeof(DLTNode));
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	guard->next = guard;	//记得指向自己
	guard->prev = guard;

	return guard;
}

int main()
{
	//DLTNode* plist = NULL;
	//DListInit(&plist);
	DLTNode* plist = DListInit();
	return 0;
}

🕘 3.3 创建新结点

思路：x就是待插入数据，前驱和后驱指针先置为空，方便链接。

DLTNode* BuyDLTNode(DLTDataType x)
{
	DLTNode* node = (DLTNode*)malloc(sizeof(DLTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->next = NULL;	//刚malloc的结点置空就好
	node->prev = NULL;
	node->data = x;
	return node;

}

🕘 3.4 尾插双链表

以前我们的单链表都需要找尾，时间复杂度为O(n)，现在带头双链表找尾可谓易如反掌，直接phead->prev就找到了

思路：如图链接形成循环，不需要判空哦~

在这里插入图片描述

void DListPushBack(DLTNode* phead, DLTDataType x)
{
	assert(phead);

	DLTNode* newnode = BuyDLTNode(x);
	DLTNode* tail = phead->prev;

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

🕘 3.5 打印双链表

⚡ 注意：因为不像单链表的结束标记是NULL，因为是循环结构，所以这里的结束标记为返回到头结点就结束。

思路：打印是不需要打印phead的，让cur指向第一个数据的结点，当cur=phead的时候结束，这样把空链表的情况也考虑到了。

void DListPrint(DLTNode* phead)
{
	assert(phead);
	printf("phead<=>");

	DLTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

🕘 3.6 头插双链表

观察下面的代码，这样写对吗❓

void DListPushFront(DLTNode* phead, DLTDataType x)
{
	assert(phead);
	
	DLTNode* newnode = BuyDLTNode(x);
	phead->next = newnode;
	newnode->prev = phead;
	
	newnode->next = phead->next;
	phead->next->prev = newnode;
}

这样先写phead->next = newnode;这句代码就会把后续结点给弄丢了，要注意顺序。

void DListPushFront(DLTNode* phead, DLTDataType x)
{
	assert(phead);
	
	// 先链接newnode和phead->next之间的关系
	DLTNode* newnode = BuyDLTNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

还有更优的代码，可以不考虑先后顺序

思路：头插也就是在第一个有效数据前，phead头结点后面插入，那么既然是链表就很容易找到phead后面的结点，记做first，然后将newnode和头结点链接上，然后再和first接上。
在这里插入图片描述

void DListPushFront(DLTNode* phead, DLTDataType x)
{
	assert(phead);
	
	// 不关心顺序
	DLTNode* newnode = BuyDLTNode(x);
	DLTNode* first = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;
}

🕘 3.7 双链表判空

bool DListEmpty(DLTNode* phead)
{
	assert(phead);
	/*
	if (phead->next == phead)
		return true;
	else
		return false;
	*/		//比较繁琐
	return phead->next == phead;	一步到位
}

🕘 3.8 尾删双链表

思路：尾删和头删也是很相似的，需要两个指针，一个指针指向链表最后一个结点（tail），另外一个指向倒数第二个结点（prev），然后将prev和头结点链接，释放tail。删空的情况也兼顾到了。
在这里插入图片描述

void DListPopBack(DLTNode* phead)
{
	assert(phead);
	assert(!DListEmpty(phead));

	DLTNode* tail = phead->prev;
	DLTNode* prev = tail->prev;

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

🕘 3.9 头删双链表

思路：定义两个指针，first指向第一个结点，second指向第二个结点，先将头结点phead和第二个数据second链接，然后释放first。
在这里插入图片描述

void DListPopFront(DLTNode* phead)
{
	assert(phead);
	assert(!DListEmpty(phead));
	DLTNode* first = phead->next;
	DLTNode* second = first->next;

	phead->next = second;
	second->prev = phead;

	free(first);
	first = NULL;
}

🕘 3.10 统计双链表有效结点个数

思路：遍历统计
⚡ 注意：有些书可能会这么写，在头结点存入结点个数，在类型int情况下没有问题，可一旦用了不是int类型来定义头结点，那就有溢出风险了。

size_t DListSize(DLTNode* phead)
{
	assert(phead);
	size_t n = 0;
	DLTNode* cur = phead->next;
	while (cur != phead)
	{
		n++;
		cur = cur->next;
	}

	return n;
}

🕘 3.11 查找双链表结点

思路：遍历查找

DLTNode* DListFind(DLTNode* phead, DLTDataType x)
{
	assert(phead);

	size_t n = 0;
	DLTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

🕘 3.12 任意位置前插入结点

思路：先通过Find查找函数找到pos，并返回的指针，然后找到pos的前一个结点（prev），下一步开始链接。
在这里插入图片描述

void DListInsert(DLTNode* pos, DLTDataType x)
{
	assert(pos);
	DLTNode* prev = pos->prev;
	DLTNode* newnode = BuyDLTNode(x);

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

}

🕤 3.12.1 【复用】尾插双链表

void DListPushBack(DLTNode* phead, DLTDataType x)
{
	assert(phead);
	
	DListInsert(phead, x);
}

🕤 3.12.2 【复用】头插双链表

void DListPushFront(DLTNode* phead, DLTDataType x)
{
	assert(phead);
	
	DListInsert(phead, x);
}

🕘 3.13 任意位置删除结点

思路：用Find返回pos的指针，然后对pos的前后进行标记，分别是prev和next，链接prev和next，释放掉pos即可。
在这里插入图片描述

void DListErase(DLTNode* pos)
{
	assert(pos);

	DLTNode* prev = pos->prev;
	DLTNode* next = pos->next;

	prev->next = next;
	next->prev = prev;
	free(pos);
	pos = NULL;
}

🕤 3.13.1 【复用】尾删双链表

void DListPopBack(DLTNode* phead)
{
	assert(phead);
	
	DListErase(phead->prev);
}

🕤 3.13.2 【复用】头删双链表

void DListPopFront(DLTNode* phead)
{
	assert(phead);
	assert(!DListEmpty(phead));
	
	DListErase(phead->next);
}

🕘 3.13 销毁双链表

思路：

  • 可以传二级，内部置空头结点
  • 也可以考虑用一级指针，让调用DListDestroy的人置空（保持接口的一致性）


void DListDestroy(DLTNode* phead)
{
	assert(phead);

	DLTNode* cur = phead->next;
	while (cur != phead)
	{
		DLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL;
}

🕒 4. 完整源码

// DList.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>

typedef int DLTDataType;
typedef struct DListNode
{
	struct DListNode* next;
	struct DListNode* prev;
	DLTDataType data;
}DLTNode;

//void DListInit(DLTNode** pphead);
DLTNode* DListInit();
void DListDestroy(DLTNode* phead);

void DListPrint(DLTNode* phead);

void DListPushBack(DLTNode* phead,DLTDataType x);
void DListPushFront(DLTNode* phead, DLTDataType x);
void DListPopBack(DLTNode* phead);
void DListPopFront(DLTNode* phead);

bool DListEmpty(DLTNode* phead);
size_t DListSize(DLTNode* phead);

DLTNode* DListFind(DLTNode* phead,DLTDataType x);

// 在pos之前插入
void DListInsert(DLTNode* pos, DLTDataType x);

// 删除pos位置
void DListErase(DLTNode* pos);

// DList.c

#include"DList.h"

DLTNode* DListInit()
{
	DLTNode* guard = (DLTNode*)malloc(sizeof(DLTNode));
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	guard->next = guard;	//记得指向自己
	guard->prev = guard;

	return guard;
}

DLTNode* BuyDLTNode(DLTDataType x)
{
	DLTNode* node = (DLTNode*)malloc(sizeof(DLTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->next = NULL;	//刚malloc的结点置空就好
	node->prev = NULL;
	node->data = x;
	return node;

}

void DListPrint(DLTNode* phead)
{
	assert(phead);
	printf("phead<=>");

	DLTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}


void DListPushBack(DLTNode* phead, DLTDataType x)
{
	assert(phead);

	DLTNode* newnode = BuyDLTNode(x);
	DLTNode* tail = phead->prev;

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

	//DListInsert(phead, x);
}

void DListPushFront(DLTNode* phead, DLTDataType x)
{
	assert(phead);

	/*
	DLTNode* newnode = BuyDLTNode(x);
	phead->next = newnode;
	newnode->prev = phead;
	//注意顺序
	newnode->next = phead->next;
	phead->next->prev = newnode;
	*/
	/*		先链接newnode和phead->next之间的关系
	DLTNode* newnode = BuyDLTNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;
	//正确，但又更优写法
	phead->next = newnode;
	newnod e->prev = phead;
	*/
	// 不关心顺序
	DLTNode* newnode = BuyDLTNode(x);
	DLTNode* first = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;

	//DListInsert(phead->next, x);
}

void DListPopBack(DLTNode* phead)
{
	assert(phead);
	assert(!DListEmpty(phead));

	DLTNode* tail = phead->prev;
	DLTNode* prev = tail->prev;

	prev->next = phead;
	phead->prev = prev;
	free(tail);
	tail = NULL;

	//DListErase(phead->prev);
}

void DListPopFront(DLTNode* phead)
{
	assert(phead);
	assert(!DListEmpty(phead));
	DLTNode* first = phead->next;
	DLTNode* second = first->next;

	phead->next = second;
	second->prev = phead;

	free(first);
	first = NULL;

	//DListErase(phead->next);
}

bool DListEmpty(DLTNode* phead)
{
	assert(phead);
	/*
	if (phead->next == phead)
		return true;
	else
		return false;
	*/
	return phead->next == phead;
}

size_t DListSize(DLTNode* phead)
{
	assert(phead);
	size_t n = 0;
	DLTNode* cur = phead->next;
	while (cur != phead)
	{
		n++;
		cur = cur->next;
	}

	return n;
}

DLTNode* DListFind(DLTNode* phead, DLTDataType x)
{
	assert(phead);

	size_t n = 0;
	DLTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}


void DListInsert(DLTNode* pos, DLTDataType x)
{
	assert(pos);
	DLTNode* prev = pos->prev;
	DLTNode* newnode = BuyDLTNode(x);

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

}

void DListErase(DLTNode* pos)
{
	assert(pos);

	DLTNode* prev = pos->prev;
	DLTNode* next = pos->next;

	prev->next = next;
	next->prev = prev;
	free(pos);
	//pos = NULL;
}

// 可以传二级，内部置空头结点
// 也可以考虑用一级指针，让调用DListDestroy的人置空（保持接口的一致性）

void DListDestroy(DLTNode* phead)
{
	assert(phead);

	DLTNode* cur = phead->next;
	while (cur != phead)
	{
		DLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	//phead = NULL;
}

// test.c

#include"DList.h"
void TestList1()
{/*
	DLTNode* plist = NULL;
	DListInit(&plist);*/

	DLTNode* plist = DListInit();
	DListPushBack(plist, 1);
	DListPushBack(plist, 2);
	DListPushBack(plist, 3);
	DListPushBack(plist, 4);

	DListPrint(plist);

	DListPushFront(plist, 10);
	DListPushFront(plist, 20);
	DListPushFront(plist, 30);
	DListPushFront(plist, 40);
	DListPrint(plist);
	DListPrint(plist);

	DListPopBack(plist);
	DListPopBack(plist);
	DListPopBack(plist);
	DListPopBack(plist);
	DListPrint(plist);

	DListPopBack(plist);
	DListPopBack(plist);
	DListPopBack(plist);
	DListPopBack(plist);
	DListPrint(plist);

	//DListPopBack(plist);
	DListDestroy(plist);
	plist = NULL;
}

void TestList2()
{
	DLTNode* plist = DListInit();
	DListPushBack(plist, 1);
	DListPushBack(plist, 2);
	DListPushBack(plist, 3);
	DListPushBack(plist, 4);
	DListPrint(plist);

	DListPopFront(plist);
	DListPopFront(plist);
	DListPrint(plist);

	DListPopFront(plist);
	DListPopFront(plist);
	DListPrint(plist);

	DListDestroy(plist);
	plist = NULL;
}

void TestList3()
{
	DLTNode* plist = DListInit();
	DListPushBack(plist, 1);
	DListPushBack(plist, 2);
	DListPushBack(plist, 3);
	DListPushBack(plist, 4);
	DListPrint(plist);

	// ...
}

int main()
{
	TestList2();

	return 0;
}

OK，以上就是本期知识点“双链表”的知识啦~~ ，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟📌~
🎉如果觉得收获满满，可以点点赞👍支持一下哟~

HinsCoder
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表 2 之双向动态链表
小菜羊的博客
02-03 636
双向链表相比单向链表，多了一个指向上一节点的结构体指针。下面以建立一个录入小型学生成绩程序为例。 链表的建立不同之处在于多了一个指向上一节点的指针 last。（建立的方法与节点删除与 1 中方法不同，但实质相同） 该程序包括学生名字与成绩的录入、依据编号查找学生成绩、删除相应编号的学生的信息 #include #include #define len sizeof(struct Stud
双向链表（动图讲解）-Java数据结构和算法
qq_31747473的博客
03-08 422
单向链表基本操作 图解 文章目录前言一、双向链表的介绍：二、相关操作1. 新建双向链表的类2.删除数据(变化较大，有坑????)3. 中间添加数据4.尾部添加数据(稍微变化)5.修改数据(思路不变)6.双向链表的遍历(无变化)总结 前言       对于单向链表来说，查找的方向只能单向的，所以进行删除或插入，我们需要找到目标的前一个结点（无法实现向后查找的弊端）。       单向链表
【数据结构】动图详解双向链表
最新发布
忆梦初心的博客
02-04 1707
带头双向循环链表：其结构是链表8种结构中最复杂的，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。此链表的结点在单向链表的基础上，添加了前驱指针prev指向上一个结点，然后添加了上述所描述的头结点，而循环则是体现在首尾结点相连上。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现起来反而更加简单。通过上面一个个接口的实现，我们发现：虽然双向带头循环链表的结构比起单向链表结构复杂太多，但对于各接口的实现反而变得更加方便，并且某些接口时间效率更高
数据结构——双向循环链表（二）双向动态链表
chenchen_fcj程序猿的博客
07-24 394
双向动态链表才是关键，直接看例子和图示既就可以，主要是自己会画图，然后根据图来写代码 dlist.h  //头文件 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct _node {         int data;         struct  _node* next;         struct  _nod...
线性表(双向链表(动图解析))
weixin_42567027的博客
07-02 571
双向链表 双向链表或双面链表 每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。 双向链表操作 判断链表是否为空、计算链表长度、遍历整个链表、查找指定元素的操作与单向链表相同 在头部添加元素 // An highlighted block """头部添加元素""" def add(self, item): node = DoubleLinkList(item) node.next
C#数据结构之双向链表(DbLinkList)实例详解
12-31
本文实例讲述了C#数据结构之双向链表(DbLinkList)。分享给大家供大家参考，具体如下： 这是继上一篇《C#数据结构之单链表(LinkList)实例详解》的继续，对于双向链接，节点上除了Next属性外，还要有Prev属性用来指向...
Java数据结构（线性表）详解
08-30
线性表是数据结构中基础且重要的概念，它是由n（n>=0）个相同类型元素构成的有限序列。在Java中，线性表可以有多种实现方式，但本文主要讨论的是链式存储的实现，即单链表。 单链表是一种线性表的链式存储结构，它...
Java描述数据结构学习之链表的增删改查详解
08-27
Java链表数据结构学习之增删改查详解 本文将从链表的基本概念、链表的定义、链表的增删改查操作等方面对Java描述数据结构学习之链表的增删改查进行详细的解释。 链表是一种常见的基础数据结构，它是一种线性表，但...
数据结构实验1线性表归并及附加题详解
08-25
数据结构实验旨在让学生深入理解线性表的基本操作和高级操作，如归并和特定条件下的节点删除。实验涉及两个核心任务：一是两个有序线性表的归并，二是双向循环链表中满足条件节点的删除。 在归并有序线性表的实验中...
C语言双向链表的表示与实现实例详解
09-04
双向链表，又称为双链表，是数据结构中的一种线性表，它在链表的基础上增加了指向前后节点的指针，使得每个节点不仅可以向前遍历，还可以向后遍历。在C语言中，双向链表的实现涉及到节点结构的定义、链表的初始化、...
数据结构链表的动画演示
12-24
可以更直观的展现数据结构原理，链表的动态演示，让我们更有效地学习链表在数据结构中是如何插入删除等工作的。
【数据结构】线性表-双向链表（图解、c++、java）
扑腾的江鱼复习仓库
01-16 1132
URLeisure的双向链表”完美“复习资料。
【数据结构和算法】动图详解，链表（单链表/双链表……）（实例讲解）
Linux猿
09-22 1万+
???? 作者：Linux猿 ???? 简介：CSDN博客专家????，华为云享专家????，C/C++、面试、刷题、算法尽管咨询我，关注我，有问题私聊！ ???? 关注专栏：C/C++面试通关集锦（优质好文持续更新中……）???? 目录 一、单链表 1.1 插入节点 1.2 删除结点 二、双链表 2.1 插入节点 2.2 删除节点 三、单向循环链表 3.1 插入节点 3.2 删除结点 四、双向循环链表 4.1 插入节点 4.2 删除节点 五、静态链表 六、实战讲解 6.
双向链表（无注释...慎入）
sbfksmq的博客
09-01 339
#include #include typedef struct Node{ int data; struct Node*prev; struct Node*next; }Node; typedef struct List{ Node* head; Node* tail; }List; Node * NodeCreate(int
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6480
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
双向链表
qq_40239482的博客
03-18 524
数据结构 | 双向链表简单实现及图示————————————————————————————————————————————双向链表- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ...
双向链表的插入及删除图解
热门推荐
c++菜鸟一只。
05-06 3万+
双向链表的插入第一步：首先找到插入位置，节点 s 将插入到节点 p 之前 第二步：将节点 s 的前驱指向节点 p 的前驱，即 s->prior = p->prior; 第三步：将节点 p 的前驱的后继指向节点 s 即 p->prior->next = s; 第四步：将节点 s 的后继指向节点 p 即 s->next = p; 第五步：将节点 p 的前驱指向节点 s 即 p->prior =
图解双向链表的插入动作。
何亮5083的博客
06-08 422
初始态 变化态 我要插入进去 结果态
「数据结构 | 链表」单链表、双向链表节点操作演示动画
商亮的技术手册
06-20 1088
目录1. 什么是链表2. 链表数据结构 2.1 单链表数据接口（Java）2.2 双链表数据结构（Java）3. 单链表操作动画3.1 新增节点3.2 删除节点4. 双向链表操作动画4.1 新增节点4.2 删除节点链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。 2.2 双向链表数据结构（Java） 单链表在已知单个节点的情况下，只能在该节点的后续链上增加新的节点，
数据结构算法详解：线性表操作与链表操作实践
"这份资料包含了数据结构中关于线性表、树、查找和排序的各种算法思想及实现代码，是学习和掌握数据结构必备算法的重要参考资料。" 数据结构是计算机科学的基础，它研究如何高效地组织和存储数据，以便进行有效的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值