【深度优先】LeetCode1932:合并多棵二叉搜索树

已于 2023-12-01 13:56:43 修改
阅读量178 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 深度优先 算法 c++ LeetCode 二叉搜索树 合并 森林
于 2023-12-01 06:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/134719379
版权

作者推荐

动态规划LeetCode2552：优化了6版的1324模式

题目

给你 n 个 二叉搜索树的根节点 ，存储在数组 trees 中（下标从 0 开始），对应 n 棵不同的二叉搜索树。trees 中的每棵二叉搜索树 最多有 3 个节点 ，且不存在值相同的两个根节点。在一步操作中，将会完成下述步骤：
选择两个 不同的 下标 i 和 j ，要求满足在 trees[i] 中的某个 叶节点 的值等于 trees[j] 的 根节点的值 。
用 trees[j] 替换 trees[i] 中的那个叶节点。
从 trees 中移除 trees[j] 。
如果在执行 n - 1 次操作后，能形成一棵有效的二叉搜索树，则返回结果二叉树的 根节点 ；如果无法构造一棵有效的二叉搜索树，返回 null 。
二叉搜索树是一种二叉树，且树中每个节点均满足下述属性：
任意节点的左子树中的值都 严格小于 此节点的值。
任意节点的右子树中的值都 严格大于 此节点的值。
叶节点是不含子节点的节点。
示例 1：
输入：trees = [[2,1],[3,2,5],[5,4]]
输出：[3,2,5,1,null,4]
解释：
第一步操作中，选出 i=1 和 j=0 ，并将 trees[0] 合并到 trees[1] 中。
删除 trees[0] ，trees = [[3,2,5,1],[5,4]] 。
在第二步操作中，选出 i=0 和 j=1 ，将 trees[1] 合并到 trees[0] 中。
删除 trees[1] ，trees = [[3,2,5,1,null,4]] 。
结果树如上图所示，为一棵有效的二叉搜索树，所以返回该树的根节点。
示例 2：
输入：trees = [[5,3,8],[3,2,6]]
输出：[]
解释：
选出 i=0 和 j=1 ，然后将 trees[1] 合并到 trees[0] 中。
删除 trees[1] ，trees = [[5,3,8,2,6]] 。
结果树如上图所示。仅能执行一次有效的操作，但结果树不是一棵有效的二叉搜索树，所以返回 null 。
示例 3：
输入：trees = [[5,4],[3]]
输出：[]
解释：无法执行任何操作。
参数范围：
n == trees.length
1 <= n <= 5 * 104
每棵树中节点数目在范围 [1, 3] 内。
输入数据的每个节点可能有子节点但不存在子节点的子节点
trees 中不存在两棵树根节点值相同的情况。
输入中的所有树都是 有效的二叉树搜索树 。
1 <= TreeNode.val <= 5 * 104.

分析

正确分析

能合并则合并，如果合并树的数量为1，则正确。
不需要考虑：叶子相同，那个叶子合并根的问题，两个叶子相同，那个叶子合并最后都不会是合法的搜索树。

错误分析

vMin 记录各子树的最小值，vMax记录各子树的最大值。 成为左子树的条件：一，叶子的值等子树根的值。 二，子树的最大值小于父树的值。成为右子树的条件：一，叶子的值等子树根的值。 二，子树的最小值大于父树的值。

错误原因

父子符合条件，祖孙不符合条件。

解决方法

判断是否是合法的树。

变量解释

vMin[i]以trees[i]为根的树的最小节点值
vMax[i]以trees[i]为根的树的最大节点值
mValueIndexkey:trees[i]根节点的值；value:i。

代码

struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
};

class Solution {
public:
TreeNode* canMerge(vector<TreeNode*>& trees) {
m_c = trees.size();
vector vMin(m_c), vMax(m_c);
unordered_map<int, int> mValueIndex;
for (int i = 0; i < m_c; i++)
{
const auto& p = trees[i];
mValueIndex[p->val] = i;
vMin[i] = (nullptr == p->left) ? p->val : p->left->val;
vMax[i] = (nullptr == p->right) ? p->val : p->right->val;
}
for (int i = 0; i < m_c; i++)
{
std::cout << "i " << i;
const auto& p = trees[i];
if ((nullptr != p->left) && mValueIndex.count(p->left->val))
{
const int index = mValueIndex[p->left->val];
if (vMax[index] < p->val)
{
std::cout << "index " << index;
vMin[i] = min(vMin[i], vMin[index]);
p->left = trees[index];
mValueIndex.erase(mValueIndex.find(p->left->val));
}
}
if ((nullptr != p->right) && mValueIndex.count(p->right->val))
{
const int index = mValueIndex[p->right->val];
if (vMin[index] > p->val)
{
std::cout << "r " << index;
vMax[i] = max(vMax[i], vMax[index]);
p->right = trees[index];
mValueIndex.erase(p->right->val);
}
}
std::cout << std::endl;
}
if (mValueIndex.size() > 1) return nullptr;
auto [suc, tmp1, tmp2] = DFS(trees[mValueIndex.begin()->second]);
if (!suc)
{
return nullptr;
}
return trees[mValueIndex.begin()->second];
}
std::tuple<bool, int, int> DFS(TreeNode* root)
{
int iMin = root->val;
int iMax = root->val;
if (nullptr != root->left)
{
auto [suc, iRetMin, iRetMax] = DFS(root->left);
if ((!suc)||( iRetMax >= root->val))
{
return std::make_tuple(false, 0, 0);
}
iMin = iRetMin;
}
if (nullptr != root->right)
{
auto [suc, iRetMin, iRetMax] = DFS(root->right);
if ((!suc) || (iRetMin <= root->val))
{
return std::make_tuple(false, 0, 0);
}
iMax = iRetMax;
}
return std::make_tuple(true, iMin, iMax);
}
int m_c;
};

优化

分析

最后总是要判断是否是合法树，那合并树的时候就不需要判断了。这样会产生新问题：
三个子树成环，两个子树合并成树。 合并了3次符合条件，但不是一棵树，而是两个连通区域。
解法方法如下：
一，判断唯一的树的节点数是否合法。
二，并集查找，看有几个连通区域。
三，判断有几个合法的根（不存在值相同的叶子），从根开始合并。
四，获取树的中顺遍历，看是否是严格递增。且节点数是否正确。

判断合法的根的代码

class Solution {
public:
TreeNode* canMerge(vector<TreeNode*>& trees) {
m_c = trees.size();
unordered_set setLeaf;
for (int i = 0; i < m_c; i++)
{
auto& p = trees[i];
m_mValuePtr[p->val] = p;
if (nullptr != p->left)
{
setLeaf.emplace(p->left->val);
}
if (nullptr != p->right)
{
setLeaf.emplace(p->right->val);
}
}
TreeNode* root = nullptr;
for (int i = 0; i < m_c; i++)
{
if (setLeaf.count(trees[i]->val))
{
continue;//和某个叶子起点重合，不是根
}
if (nullptr != root)
{
return nullptr;//不可能有两个根
}
root = trees[i];
}
if( nullptr == root)
{
return nullptr;
}
DFSBuild(root);
if (m_mValuePtr.size() != 1 )
{
return nullptr;
}
auto [suc, tmp1, tmp2] = DFS(root);
if (!suc)
{
return nullptr;
}
return root;
}
void DFSBuild(TreeNode* root)
{
auto Build = [&](TreeNode*& node)
{
if ((nullptr != node) && (m_mValuePtr.count(node->val)))
{
node = m_mValuePtr[node->val];
m_mValuePtr.erase(node->val);
DFSBuild(node);
}
};
Build(root->left);
Build(root->right);
}
std::tuple<bool, int, int> DFS(TreeNode* root)
{
int iMin = root->val;
int iMax = root->val;
if (nullptr != root->left)
{
auto [suc, iRetMin, iRetMax] = DFS(root->left);
if ((!suc) || (iRetMax >= root->val))
{
return std::make_tuple(false, 0, 0);
}
iMin = iRetMin;
}
if (nullptr != root->right)
{
auto [suc, iRetMin, iRetMax] = DFS(root->right);
if ((!suc) || (iRetMin <= root->val))
{
return std::make_tuple(false, 0, 0);
}
iMax = iRetMax;
}
return std::make_tuple(true, iMin, iMax);
}
unordered_map<int, TreeNode*> m_mValuePtr;
int m_c;
};

中序遍历

class Solution {
public:
TreeNode* canMerge(vector<TreeNode*>& trees) {
m_c = trees.size();
int iNodeCount = 0;
for (int i = 0; i < m_c; i++)
{
const auto& p = trees[i];
m_mValuePtr[p->val] = p;
iNodeCount += (1 + (nullptr != p->left) + (nullptr != p->right));
}
for (int i = 0; i < m_c; i++)
{
auto Build = [&](TreeNode*& node)
{
if ((nullptr != node) && (m_mValuePtr.count(node->val)))
{
node = m_mValuePtr[node->val];
m_mValuePtr.erase(node->val);
}
};
Build(trees[i]->left);
Build(trees[i]->right);
}
if (m_mValuePtr.size() != 1 )
{
return nullptr;
}
vector vNode;
DFSNLR(vNode, m_mValuePtr.begin()->second);
if (vNode.size() + m_c-1 != iNodeCount)
{
return nullptr;
}
for (int i = 1; i < vNode.size(); i++)
{
if (vNode[i] <= vNode[i - 1])
{
return nullptr;
}
}
return m_mValuePtr.begin()->second;
}
void DFSNLR(vector& v,TreeNode* root)
{
if (nullptr == root)
{
return ;
}
DFSNLR(v,root->left);
v.emplace_back(root->val);
DFSNLR(v,root->right);
}
unordered_map<int, TreeNode*> m_mValuePtr;
int m_c;
};

中序遍历优化

vNode我们只需要读取最后一个值，所以可以用一个整形变量pre代替。

 class Solution {
   public:
	   TreeNode* canMerge(vector<TreeNode*>& trees) {
		   m_c = trees.size();
		   int iNodeCount = 0;
		   for (int i = 0; i < m_c; i++)
		   {
			   const auto& p = trees[i];
			   m_mValuePtr[p->val] = p;
			   iNodeCount += (1 + (nullptr != p->left) + (nullptr != p->right));
		   }
		   for (int i = 0; i < m_c; i++)
		   {
			   auto Build = [&](TreeNode*& node)
			   {
				   if ((nullptr != node) && (m_mValuePtr.count(node->val)))
				   {
					   node = m_mValuePtr[node->val];
					   m_mValuePtr.erase(node->val);		
				   }
			   };
			   Build(trees[i]->left);
			   Build(trees[i]->right);
		   }
		   if (m_mValuePtr.size() != 1 )
		   {
			   return  nullptr;
		   }
			 int pre=-1;
		   if (!DFSNLR(m_mValuePtr.begin()->second, pre) || (m_iNodeSize + m_c - 1 != iNodeCount))
		   {
			   return nullptr;
		   }
		   return m_mValuePtr.begin()->second;
	   }
	   bool DFSNLR(TreeNode* root, int& pre)
	   {
		   if ((root->left) && (!DFSNLR(root->left, pre)))
		   {
			   return false;
		   }
		   m_iNodeSize++;
		   if (root->val <= pre)
		   {
			   return false;
		   }
			 pre = root->val;
		   if ((root->right) && (!DFSNLR(root->right, pre)))
		   {
			   return false;
		   }
		   return true;
	   }	   
	   int m_iNodeSize = 0;
	   unordered_map<int, TreeNode*> m_mValuePtr;
	   int m_c;
   };

2023年6月旧版

class Solution {
public:
TreeNode* canMerge(vector<TreeNode*>& trees) {
vector<TreeNode*> vRoot(5 * 10000 + 1);
std::set setNums;
for (auto& ptr : trees)
{
vRoot[ptr->val] = ptr;
setNums.emplace(ptr->val);
if (nullptr != ptr->left)
{
setNums.emplace(ptr->left->val);
}
if (nullptr != ptr->right)
{
setNums.emplace(ptr->right->val);
}
}
int iNodeNum = setNums.size();
for (auto& ptr : trees)
{
if ((nullptr != ptr->left) && (nullptr != vRoot[ptr->left->val]))
{
ptr->left = vRoot[ptr->left->val];
vRoot[ptr->left->val] = nullptr;
}
if ((nullptr != ptr->right) && (nullptr != vRoot[ptr->right->val]))
{
ptr->right = vRoot[ptr->right->val];
vRoot[ptr->right->val] = nullptr;
}
}
TreeNode* pRoot = nullptr;
for (auto ptr : vRoot)
{
if (nullptr == ptr)
{
continue;
}
if (nullptr != pRoot)
{
return nullptr;//两个根
}
pRoot = ptr;
}
if (nullptr == pRoot)
{
return nullptr;
}
if (iNodeNum != DFSNum(pRoot))
{
return nullptr;
}
int iMin, iMax;
bool bRet = DFS(iMin, iMax, pRoot);
return bRet ? pRoot : nullptr;
}
bool DFS(int& iMin, int& iMax, TreeNode* pNode)
{
iMin = iMax = pNode->val;
if ((nullptr != pNode->left))
{
int iMinLeft, iMaxLeft;
if (!DFS(iMinLeft, iMaxLeft, pNode->left))
{
return false;
}
if (iMaxLeft >= pNode->val)
{
return false;
}
iMin = iMinLeft;
}
if ((nullptr != pNode->right))
{
int iMinRight, iMaxRight;
if (!DFS(iMinRight, iMaxRight, pNode->right))
{
return false;
}
if (iMinRight <= pNode->val)
{
return false;
}
iMax = iMaxRight;
}
return true;
}
int DFSNum(TreeNode* pNode)
{
if (nullptr == pNode)
{
return 0;
}
return 1 + DFSNum(pNode->left) + DFSNum(pNode->right);
}
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境：

VS2022 C++17

闻缺陷则喜何志丹
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
vscode提交leetcode-rusty-leetcode::crab:同时对抗LeetCode和RustBorrowChecker
06-30
验证二叉搜索树 中等的 0 毫秒 2.8 MB 0101 对称树 简单的 0 毫秒 2.2 MB :star: 0102 二叉树级别顺序遍历 中等的 0 毫秒 2.2 MB 0104 二叉树的最大深度 简单的 0 毫秒 2.4 MB 2020/02/24 0105 从前序和中序遍历构造...
leetcode530-leetcode:leetcode
06-30
leetcode 530 力码 大批 题号 题目名称 难度 26 从排序数组中删除重复项 简单的 ...二叉树的最大深度 ...将排序数组转换为二叉搜索树 ...树的最大深度 ...合并两个二叉树 ...修剪二叉搜索树 ...从前序遍历构造二叉搜索树
C++------利用C++实现二叉搜索树【数据结构】
m0_67635008的博客
08-20 554
算法思想：二叉搜索树的查找算法是这样的，从根的地方开始找，如果要找的key比根大就到右子树去找，如果比根小就到左子树找。我们要使树的高度保持为logN就必须引入平衡二叉搜索树的概念，这个部分我们在后面的AVL和红黑树部分讲解。情况d：在它的左子树中寻找最大节点，用它的值填补到被删除节点中，再来处理该节点的删除问题—替换法删除。情况b：删除该节点且是被删除节点的双亲节点指向被删除节点的左孩子节点—直接删除。情况c：删除该节点且是被删除节点的双亲节点指向被删除节点的右孩子节点—直接删除。好的我们下一篇再见！
1932. 合并多棵二叉搜索树 并查集+DFS
yu_duan_hun的博客
08-26 250
多个二叉搜索树合并
LeetCode：450. 删除二叉搜索树中的节点————中等
Kinght_123的博客
06-02 103
450. 删除二叉搜索树中的节点 给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。一般来说，删除节点可分为两个步骤：首先找到需要删除的节点； 如果找到了，删除它。示例 1:输入：root = [5,3,6,2,4,null,7], key = 3 输出：[5,4,6,2,null,null,7] 解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。 一个正确的答
LeetCode——1305. 两棵二叉搜索树中的所有元素
允诺@晴天的博客
05-01 2380
1305. 两棵二叉搜索树中的所有元素题目描述答案我的答案官方答案中序遍历 + 归并 题目描述 给你 root1 和 root2 这两棵二叉搜索树。请你返回一个列表，其中包含 两棵树 中的所有整数并按 升序 排序。. 示例 1： 输入：root1 = [2,1,4], root2 = [1,0,3] 输出：[0,1,1,2,3,4] 示例 2： 输入：root1 = [1,null,8], root2 = [8,1] 输出：[1,1,8,8] 提示： 每棵树的节点数在 [0, 5000] 范围内 -1
LeetCode题解：1305. 两棵二叉搜索树中的所有元素
qq_41950660的博客
05-01 61
文章目录题目1、题目描述2、原题链接解题报告1、解题思路2、解题方法2、代码详解总结 题目 1、题目描述 给你 root1 和 root2 这两棵二叉搜索树。请你返回一个列表，其中包含 两棵树 中的所有整数并按 升序 排序。 2、原题链接 1305. 两棵二叉搜索树中的所有元素 解题报告 1、解题思路    (1)(1)(1) 两个数组是二叉搜索树，题目要求输出一个有序数组。    (2)(2)(2) 二叉搜索树也是有序的，可以转成两个有序数组。    (3)(3)(3) 不难发现这个就是归并排序的两
LeetCode实战：二叉搜索树的最近公共祖先
老马的程序人生
09-20 566
背景 为什么你要加入一个技术团队？ 如何加入 LSGO 软件技术团队？ 我是如何组织“算法刻意练习活动”的？ 为什么要求团队的学生们写技术Blog 题目英文 Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST. According to th...
LeetCode-题目详解：深度优先搜索、广度优先遍历
u013250861的博客
05-27 1321
一、高频题 1、高频题 1.1、105-从前序与中序遍历序列构造二叉树 1.2、131-分割回文串 1.3、200-岛屿数量 1.4、124-二叉树中的最大路径和 1.5、394-字符串解码 1.6、199-二叉树的右视图 1.7、17-电话号码的字母组合 1.8、104-二叉树的最大深度 1.9、101-对称二叉树 1.10、679-24 点游戏 1.11、98-验证二叉搜索树 1.12、721-账户合并 1.13、257-二叉树的所有路径 1.14、剑指 Offer 34-二叉树中和为某一值的路径 1.
【深度优先搜索】leetcode 617. 合并二叉树
lele_ne的博客
08-18 64
使用dfs合并二叉树。
LeetCode实战：二叉搜索树中第K小的元素
老马的程序人生
09-21 556
背景 为什么你要加入一个技术团队？ 如何加入 LSGO 软件技术团队？ 我是如何组织“算法刻意练习活动”的？ 为什么要求团队的学生们写技术Blog 题目英文 Given a binary search tree, write a function kthSmallest to find the kth smallest element in it. Note: You may assume ...
leetcode530-leetcode:Go版本leetcode
06-30
将排序数组转换为二叉搜索树 树 简单的 平衡二叉树 树 简单的 二叉树的最小深度 树 简单的 路径和 树 简单的 反转二叉树 树 简单的 二叉搜索树的最低公共祖先 树 简单的 二叉树路径 树 简单的 左叶总和 树 简单的 ...
leetcode卡-leetcode:leetcode练习
07-06
将有序数组转换为二叉搜索树 排序和搜索专题 合并两个有序数组 第一个错误的版本 动态规划专题 爬楼梯 买卖股票的最佳时机 最大子序和 打家劫舍 设计问题专题 Shuffle an Array 最小栈 数学专题 3的幂 Fizz Buzz ...
leetcode小岛出水口-LeetCode:LeetCode走马观花
06-30
98.验证二叉搜索树 101.对称二叉树 102.二叉树的层序遍历 104.二叉树的最大深度 110.平衡二叉树 112.路径总和 116.填充每个节点的下一个右侧节点指针 117.填充每个节点的下一个右侧节点指针II 118.杨辉三角 120....
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5082
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
Java 7大排序
m0_74270127的博客
05-10 801
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
[Easy] leetcode-35 搜索插入位置
Sofine
05-09 248
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。利用二分查找可以更快的找到，只需要修改返回值即可，注意获取mid的计算方法考虑了溢出。注意到是按顺序排列的数组，那么按顺序遍历，如果找到，则跳出循环返回索引即可。如果找到最后还没找到，则返回数组长度索引值即为插入位置。
从零学算法6
最新发布
m0_53256503的博客
05-11 988
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。输入：s = “PAYPALISHIRING”, numRows = 3。输入：s = “PAYPALISHIRING”, numRows = 4。输入：s = “A”, numRows = 1。输出：“PAHNAPLSIIGYIR”输出：“PINALSIGYAHRPI”
leetcode 101:和你一起你轻松刷题(c++) pdf
07-30
"leetcode 101:和你一起你轻松刷题(c )"是一本关于刷题的 pdf 电子书。LeetCode 是一个流行的在线编程平台，提供了许多编程问题和算法题供程序员练习和挑战。这本电子书的目的是通过提供答案和解题思路帮助读者更轻松地刷题。 电子书的标题中提到了 "C"，这意味着书中的题目主要是用 C 语言编写的。C 语言是一种非常重要和广泛使用的编程语言，特别适合用来解决算法和数据结构相关的问题。通过在 LeetCode 平台上刷题，读者可以熟悉 C 语言的特性和语法，并提高自己的编程能力。 这本电子书的核心内容是提供解题思路和代码实现。每个题目都会给出详细的解题思路，解释如何分析问题、设计算法和实现解决方案。同时，每个题目还会给出一个或多个 C 语言的代码实现，帮助读者理解解题思路并进行实践。 通过使用这本电子书，读者可以深入了解各种常见的算法和数据结构，并学会如何应用它们解决实际问题。同时，读者还可以通过刷题提高自己的编码能力，加深对 C 语言的理解和掌握。 总而言之，"leetcode 101:和你一起你轻松刷题(c )"是一本帮助读者更轻松地刷题并提高编程能力的电子书。通过学习其中的解题思路和代码实现，读者可以更好地理解算法和数据结构，并提升自己的编程水平。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值