【探索数据结构与算法】——深入了解双向链表（图文详解）

已于 2024-08-08 20:01:58 修改
阅读量1.1k 收藏 16
点赞数 13
分类专栏： 数据结构与算法（c语言） 文章标签： 算法 数据结构 c语言
于 2024-08-08 19:57:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80220709/article/details/141032072
版权

目录

一、双向链表的基本概念 ​​​

二、双向链表的结构

三、双向链表的基本操作实现方法 

1.双向链表的初始化

2.双向链表的头插

3.双向链表的尾插

6.查找节点

7.在指定位置之前插入节点

8.删除指定位置节点

9.打印链表数据 

 10.双向链表销毁

四、完整代码实现 

LIst.h

List.c

💓 博客主页：C-SDN花园GGbond

⏩ 文章专栏：探索数据结构与算法

一、双向链表的基本概念 ​​​

双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。

一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。

二、双向链表的结构

双向链表中的每个节点通常包含以下部分：

  1. 数据元素：可以是任何类型的数据，如整数、浮点数、字符串或对象。
  2. prev 指针：指向前一个节点的指针。
  3. next 指针：指向下一个节点的指针。相比单链表只有独立存在的每个节点，双向链表多了哨兵位节点，该节点作为头结点，不存储有效数据，只有指向第一个有效节点的next指针和指向尾节点的prev指针。
    只要链表存在，哨兵位节点就存在

 相比单链表只有独立存在的每个节点，双向链表多了哨兵位节点，该节点作为头结点，不存储有效数据，只有指向第一个有效节点的next指针和指向尾节点的prev指针。
只要链表存在，哨兵位节点就存在

三、双向链表的基本操作实现方法 

  1. 初始化顺序表中的数据。
  2. 对顺序表进行头插(开头插入数据)。
  3. 对顺序表进行尾插插(末尾插入数据)。
  4. 对顺序表进行头删(开头删除数据)。
  5. 对顺序表进行尾删(末尾删除数据)。
  6. 对顺序表进行查找。
  7. 7.在指定位置之前插入节点
  8. 删除指定位置节点。
  9. 打印顺序表中的数据。
  10. .双向链表销毁
1.双向链表的初始化

双向链表的初始化也就是创建一个哨兵位节点，所以实现初始化之前需要先封装一个节点申请函数

单独封装的申请节点函数

  • 动态申请节点大小的空间
  • 判空
  • 通过形参接受的数据初始化节点数据部分
  • next指针和prev指针都指向自身（因为双向链表是循环链表）
  • 返回节点地址

LTNode* NewNode(LTDataType x)//申请节点
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("NewNode\n");
		exit(1);
	}
	newnode->data = x;//根据参数初始化数据
	newnode->next = newnode->prev = newnode;//两个指针初始都指向自身
	return newnode;
}

双向链表初始化

  • 调用申请节点函数创建一个哨兵位节点，作为链表的头结点
  • 返回链表头结点地址

注意：

双向链表因为有哨兵位的存在，链表始终不为空，哨兵位节点不会被改变，所以不再需要传递地址，以及用二级指针接收。这一点区别于单链表实现

LTNode* LTInit()            //链表初始化
{
	LTNode* newnode = NewNode(-1);
	return newnode;
}
2.双向链表的头插

双向链表头插

  • 头插就是将新节点插入到哨兵位节点和第一个有效节点之间
  • 形参接收一个哨兵位地址和要插入的数据
  • 首先对哨兵位地址判空，判断链表结构是否正常

  • 申请新节点，存入要插入的数据

  • 接下来是移动指针

  • 一般情况下应当先调整新节点的指针，因为新节点指针调整不会影响到原链表:

  • 新节点prev指向哨兵位，next指向哨兵位的next所指向节点

  • 然后，调整第一个有效节点的prev指针，不再指向哨兵位而是指向新节点；调整哨兵位

  • next指针，不再指向原来的第一个有效节点，而是指向新节点

  • 新节点插入完成

void LTPushFront(LTNode* phead, LTDataType x)//头插
{
	assert(phead);//判空
	LTNode* newnode = NewNode(x);//申请节点
 
	newnode->next = phead->next;//改变新节点指针指向
	newnode->prev = phead;
 
	phead->next->prev = newnode;//改变原链表相关节点指针指向
	phead->next = newnode;
 
}

3.双向链表的尾插

双向链表尾删

  • 尾删就是将双向链表的最后一个有效节点删除
  • （尾删的前提是至少存在一个有效节点）
  • 首先创建一个指针del指向要删除的节点（哨兵位prev指向节点）
  • 然后将倒数第二个节点的next指针指向哨兵位
  • 将哨兵位的prev指针指向倒数第二个节点
  • 指针修改完成，此时倒数第二个节点成为最后一个节点，释放del指向的节点
  • （如果删除之前链表只有一个节点，删除完之后只剩下一个哨兵位节点，两个指针都指向自己）

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;
}
4.双向链表的头删 

双向链表头删

  • 头删就是将双向链表第一个有效节点删除
  • （头删的前提是链表至少存在一个有效节点）
  • 首先创建一个指针del指向要删除的节点（哨兵位节点next指向的节点）
  • 然后将第二个有效节点的prev指针指向哨兵位节点
  • 哨兵位节点的next指针指向第二个有效节点
  • 指针修改完成，此时第二个有效节点成为链表的第一个有效节点，释放del指向的节点
  • （如果删除之前链表只有一个节点，删除完之后只剩下一个哨兵位节点，两个指针都指向自己）

void LTPopFront(LTNode* phead)		//头删
{
	assert(phead && phead->next != phead);//判空
	LTNode* del = phead->next;//暂时存储要删除的节点
 
	del->next->prev = phead;//移动指针
	phead->next = del->next;
 
	free(del);//释放节点空间
	del = NULL;
}

5.双向链表的尾删

双向链表尾删

  • 尾删就是将双向链表的最后一个有效节点删除
  • （尾删的前提是至少存在一个有效节点）
  • 首先创建一个指针del指向要删除的节点（哨兵位prev指向节点）
  • 然后将倒数第二个节点的next指针指向哨兵位
  • 将哨兵位的prev指针指向倒数第二个节点
  • 指针修改完成，此时倒数第二个节点成为最后一个节点，释放del指向的节点
  • （如果删除之前链表只有一个节点，删除完之后只剩下一个哨兵位节点，两个指针都指向自己）

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

6.查找节点

双向链表查找（根据数据查找节点）

  • 首先对哨兵位地址判空，否则可能对空地址解引用
  • 创建一个遍历链表的指针，从第一个有效节点开始，将节点数据与要查找的数据进行比对，如果相同返回节点地址
  • 出循环，说明未找到，返回NULL
LTNode* LTFind(LTNode* phead, LTDataType x)//查找节点
{
	assert(phead);//判空
 
	LTNode* pcur = phead->next;//遍历链表的指针
 
	while (pcur!= phead)
	{
		if (pcur->data == x)
			return pcur;
		pcur = pcur->next;
	}
	return NULL;
}
7.在指定位置之前插入节点

双向链表在指定位置之前插入节点：

插入的前提是指定位置存在
申请新节点，存入要插入的数据
调整指针:
临时创建一个指针prev指向指定位置节点的perv指向节点
新节点next指针指向指定位置节点，prev指针指向prev节点
然后再修改原链表指针:
指定位置节点的prev指针指向新节点，prev节点的next指针指向新节点
新节点插入完成

void LTInsert(LTNode* pos, LTDataType x)//在pos位置之前插入数据
{
	assert(pos);//判空
	LTNode* newnode = NewNode(x);//申请新节点
 
	newnode->next = pos;//改变新节点指针指向
	newnode->prev = pos->prev;
 
	pos->prev->next = newnode;//改变原链表相关节点指针指向
	pos->prev = newnode;
 
}

8.删除指定位置节点

双向链表删除指定位置节点

  • 删除指定节点的前提是该节点必须存在
  • 首先创建一个指针del指向要删除的节点
  • 然后将该节点的前一个结点的next指针指向它的后一个节点，后一个节点的prev指针指向他的前一个节点
  • 释放该节点
  • （如果删除之前链表只有一个节点，删除完之后只剩下一个哨兵位节点，两个指针都指向自己）

void LTErase(LTNode* pos)//删除指定位置节点
{
	assert(pos);//判空
	pos->next->prev = pos->prev;//改变要删除节点的前后节点指针指向
	pos->prev->next = pos->next;
 
	free(pos);
	pos = NULL;
 
}

9.打印链表数据 

双向链表数据打印

  • 首先对地址判空，防止对空地址解引用
  • 创建一个遍历链表的指针，从第一个有效节点打印数据，然后向后移动，直到指针遍历到哨兵位
void LTPrint(LTNode* phead)  //链表数据打印
{
	assert(phead);//判空
	LTNode* pcur = phead->next;//遍历链表的指针
 
	while (pcur != phead)//打印数据
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}
 10.双向链表销毁

双向链表的销毁

从第一个有效节点开始，创建指针循环遍历链表:
创建next指针临时保存下一个节点，释放本节点，遍历指针指向next节点
循环至有效节点全部被释放
然后将哨兵位节点释放，指针置空，销毁完成
注意：

为了与其他配套函数的参数保持一致，这里的参数本该用二级指针接收，却用一级指针接收。出函数后，需要手动将哨兵位指针置空

oid LTDestroy(LTNode* phead)//链表销毁
{
	assert(phead);//判空
	LTNode* pcur = phead->next;//遍历链表的指针
 
	while (pcur != phead)//从第一个有效节点开始，逐个释放节点
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);//释放哨兵位节点
	phead = NULL;
 
}

四、完整代码实现 

LIst.h
//List.h 双链表头文件
#define _CRT_SECURE_NO_WARNINGS 1
 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
 
typedef int LTDataType;//数据类型重定义，可以是任意数据类型
typedef struct ListNode//双向链表节点结构
{
	LTDataType data;//数据
	struct ListNode* prev;//指向前一个节点的指针
	struct ListNode* next;//指向下一个节点的指针
}LTNode;
 
LTNode* NewNode(LTDataType x);//申请节点
LTNode* LTInit();             //链表初始化
 
void LTPushFront(LTNode* phead, LTDataType x);//头插
void LTPushBack(LTNode* phead, LTDataType x);//尾插
 
void LTPopBack(LTNode* phead);		//尾删
void LTPopFront(LTNode* phead);		//头删
 
 
LTNode* LTFind(LTNode* phead, LTDataType x);//查找节点
 
void LTInsert(LTNode* pos, LTDataType x);//在pos位置之后插入数据
void LTErase(LTNode* pos);//删除指定位置节点
 
void LTPrint(LTNode* phead);  //链表数据打印
void LTDestroy(LTNode* phead);//链表销毁
List.c
//DouSList.c  双链表源文件
#define _CRT_SECURE_NO_WARNINGS 1
#include"DouSList.h"
 
LTNode* NewNode(LTDataType x)//申请节点
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("NewNode\n");
		exit(1);
	}
	newnode->data = x;//根据参数初始化数据
	newnode->next = newnode->prev = newnode;//两个指针初始都指向自身
	return newnode;
}
LTNode* LTInit()            //链表初始化
{
	LTNode* newnode = NewNode(-1);
	return newnode;
}
void LTPushFront(LTNode* phead, LTDataType x)//头插
{
	assert(phead);//判空
	LTNode* newnode = NewNode(x);//申请节点
 
	newnode->next = phead->next;//改变新节点指针指向
	newnode->prev = phead;
 
	phead->next->prev = newnode;//改变原链表相关节点指针指向
	phead->next = newnode;
 
}
void LTPushBack(LTNode* phead, LTDataType x)//尾插
{
	assert(phead);//判空
	LTNode* newnode = NewNode(x);//申请节点
 
	newnode->next = phead;//改变新节点指针指向
	newnode->prev = phead->prev;
 
	phead->prev->next = newnode;//改变原链表相关节点指针指向
	phead->prev = newnode;
}
 
 
void LTPopFront(LTNode* phead)		//头删
{
	assert(phead && phead->next != phead);//判空
	LTNode* del = phead->next;//暂时存储要删除的节点
 
	del->next->prev = phead;//移动指针
	phead->next = del->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 x)//查找节点
{
	assert(phead);//判空
 
	LTNode* pcur = phead->next;//遍历链表的指针
 
	while (pcur!= phead)
	{
		if (pcur->data == x)
			return pcur;
		pcur = pcur->next;
	}
	return NULL;
}
 
void LTInsert(LTNode* pos, LTDataType x)//在pos位置之前插入数据
{
	assert(pos);//判空
	LTNode* newnode = NewNode(x);//申请新节点
 
	newnode->next = pos;//改变新节点指针指向
	newnode->prev = pos->prev;
 
	pos->prev->next = newnode;//改变原链表相关节点指针指向
	pos->prev = newnode;
 
}
 
void LTErase(LTNode* pos)//删除指定位置节点
{
	assert(pos);//判空
	pos->next->prev = pos->prev;//改变要删除节点的前后节点指针指向
	pos->prev->next = pos->next;
 
	free(pos);
	pos = NULL;
 
}
 
void LTPrint(LTNode* phead)  //链表数据打印
{
	assert(phead);//判空
	LTNode* pcur = phead->next;//遍历链表的指针
 
	while (pcur != phead)//打印数据
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}
 
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;
 
}

C-SDN花园GGbond
关注
  • 13
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【探索数据结构与算法】——深入了解栈数据结构（图文详解）
2302_80220709的博客
08-09 999
全网这一篇就够了。深入了解栈数据结构（图文详解）
【数据结构与算法 经典例题】链表的回文结构（图文详解）
2302_78391795的博客
06-04 2061
回文结构（Palindromic structure）是指一个序列或字符串从前往后读和从后往前读是相同的。 计算机科学中，回文结构可以出现在各种数据结构中，如字符串、数组等。对于字符串来说，判断一个字符串是否为回文字符串是一个常见的问题。判断方法是从字符串的两端开始比较字符是否相等，如果都相等，则继续比较下一对字符，直到中间位置。如果在任何时刻存在一对不相等的字符，则该字符串不是回文。 对于数组来说，直接采取上述方法便可以判断是否是回文结构。但对于单链表来说，则是行不通的，因为单链表只能顺序访问，不能
数据结构——双链表详解（超详细）
effort123_的博客
08-05 465
哨兵位这个名字看起来是很威武的，其实了解它之后就知道它仅仅就是名字威武点，它才是真正意义上的头结点，哨兵位是不存数据的，它的存在仅仅就是为了说明这个链表是带头的，是用来“放哨的”，小编在讲述单链表的时候曾多次提到了头结点这个名字，那个时候头结点是链表第一个结点，这个叫法是不太规范的，不过为了让读者朋友更好的去理解链表的知识，小编于是就直接头结点来代替链表第一个结点了，不过各位读者朋友一定要清楚。下面紧跟小编的步伐，开启今天的双链表之旅！
【数据结构与算法 经典例题】随机链表的复制（图文详解）
2302_78391795的博客
06-05 1307
要完成一个带随机指针的链表的复制，有一个巧妙的办法: 分三步走——完成节点数据拷贝，完成节点的随机指针拷贝，完成节点的next指针拷贝
【数据结构与算法 经典例题】反转链表(图文详解)
2302_78391795的博客
06-03 758
通过三个指针n1,n2,n3来实现链表的反转
【数据结构与算法 刷题系列】判断链表是否有环（图文详解）
2302_78391795的博客
06-17 1075
给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。这道题的解题思路主要涉及到“快慢指针”或“双指针”的方法。这种方法的关键在于，如果存在环，那么快指针最终会追上慢指针。
【数据结构与算法 刷题系列】求带环链表的入环节点（图文详解）
2302_78391795的博客
06-17 1244
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。
【数据结构】图文详解11道力扣链表OJ题
学了就忘是正常现象
08-15 1007
这是碳基生物能想到的思路？
Java实现数据结构与算法（内含源码图文解析，语言清晰易懂）
chang_mao的博客
01-31 2303
本篇文章主要帮助有计算机基础的同学了解一下各类数据结构的基本概念，优劣分析及使用场景，并附带了大牛文章的详解链接，可供读者学习。数据结构主要是表示数据在计算机中的存储形式，主要表示元素之间的位置及关联关系，用现实的话来说就是用桶装，管道装，手链的串链等等，数据结构只是一种存储方式，只要实现了它的概念，不管是Java还是C++或是Python实现，都大同小异。按照笔者个人的理解，计算机所做的事情主要是对数据的存储、传输、和计算。
数据结构之折半插入排序图文详解及代码（C++实现）
热门推荐
qq_40159978的博客
07-11 1万+
问题： 对待排序的数组r[1..n]中的元素进行直接插入排序，得到一个有序的（从小到大）的数组r[1..n]。 算法思想： 1、设待排序的记录存放在数组r[1..n]中，r[1]是一个有序序列。 2、循环n-1次，每次使用折半查找法，查找r[i]（i=2，..，n）在已排好的序列r[1..i-1]中的插入位置，然后将r[i]插入表长为i-1的序列r[1..i-1]，直到将r[n]插入...
数据结构堆的概念&&堆排序的思想以及算法过程详解（图文）
LifeGoesOn
06-29 1364
一、堆的概念 介绍堆之前，首先来看二叉树 Binary Tree。 二叉树是树的一种，主要的特点是二叉树的所有节点最多只有两个叶节点。除此之外没有别的要求。 Complete Binary Tree(完全二叉树): 二叉树的一种。在完全二叉树当中，除了最后一层之外，所有层的节点都是满的，且最后一层的节点也是从左到右的。优先填满左边的节点。 Full Binary Tree(满二叉树): 二叉树的一种。满二叉树的所有层，包括最后一层，都是满的。也就是说，除了最后一层的节点外所有的节点都有两个子节点。 这两
❤️数据结构之栈（图文版详解）❤️
耀的博客
09-24 2333
一，写在前面 不知道大家有投有玩过手枪，估计都投有。现在和平年代，上哪去玩这种危险的 真东西，就是仿真玩具也大都被限制了.我高中在军训时，也算是一次机会，几个老兵和我们学生聊天，让我们学习了下关于枪的知识。 在你准备用枪的时候，那基本到了不是你死就是我亡的时刻，突然手枪明明有子弹却打不出来，这不是要命吗?而左轮手枪就不存在这问题，这一颗不行，转到下颗就可以 了，人总不会倒霉到六颗全是臭弹， 当然，后来子弹质量基本过关了，由于弹夹可以 8颗颗甚至20颗子弹，比左轮手枪的只能放6颗子弹要多，所以后来普及率更
C++ 数据结构 红黑树 图文详解
weixin_44062380的博客
06-21 1016
红黑树前言为什么要红黑树？红黑树需要遵守的性质红黑树的变换方式红黑树的变换原则代码展示红黑树和AVL树该怎么选择 前言 我不喜欢搞什么“一文看懂XXX”的标题，因为如果一开始看到“一文读懂XXX”的标题，然后放松警惕，但当读完后，发现自己没有懂，难免会感到失落与担忧。大多数时候，这不是读者的问题，而是写作者的问题，写作者并没有将内容写得通俗易懂，却起这种标题去吸引眼球，从而使部分读者产生心理落差，这是极不负责的表现。 因为马上就要算法考试了，所以代码没时间写了，一部分概念也没时间细说了，这次就先把变色和旋转
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
04-22 1230
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递归/分治/动态规划/贪心算法)总结 目录 相关文章 数据结构的最强学习路线之问题为导向的十大类刷题算法总结 一、学习相关的讲解与刷题平台 二、刷题集合 三、常见的十大类考试题型 相关文章 DSt：数据结构的简介、最强学习路线(逻辑结构【数组
dp算法练习【7】
MADAO的博客
09-08 1347
给你一个按排序的整数数组nums，返回组成的新数组，要求也按排序。平方后，数组变为 [16,1,0,9,100]排序后，数组变为 [0,1,9,16,100]非常简单，思路平方后排序。优化：插入法。
【Python 千题 —— 算法篇】寻找两个正序数组的中位数
繁依Fanyi的博客
09-07 1245
合并排序法：易于理解，但时间复杂度较高，适合小规模数据。双指针法：通过双指针合并数组，时间复杂度 O(m + n)，适合中等规模数据。二分查找法：通过二分查找，在较短数组上进行划分，时间复杂度为 O(log(min(m, n)))，是处理大规模数据的最佳选择。对于这种涉及高效搜索和排序的题目，掌握二分查找的应用至关重要。通过本题目，我们不仅能够提升对数组和中位数的理解，还能够学到如何优化时间复杂度，使算法在处理大规模数据时更加高效。
【Hot100】LeetCode—64. 最小路径和
最新发布
weixin_44382896的博客
09-12 343
64. 最小路径和。
算法练习题22——解码
hello77的blogggg 祝你得偿所愿
09-11 276
小明有一串很长的英文字母，其中可能包含大写和小写字母。在这串字母中，有很多字母是连续且重复的。为了压缩这串字母的表达形式，小明决定将连续相同的字母用“字母 + 出现次数”的形式表示。
腾讯精选数据结构与算法50题详解：考研与学习宝典
"《数据结构与算法 腾讯精选练习50 V1.0》是一本面向数据结构与算法学习者的170多页小册子，主要梳理了LeetCode上“腾讯精选练习50题”的精华内容。这本书旨在帮助学生深化理解数据结构和算法的基础知识，尤其适合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值