【c++】二叉搜索树（BST）

最新推荐文章于 2024-05-30 15:59:49 发布
最新推荐文章于 2024-05-30 15:59:49 发布
阅读量1.3k 收藏 142
点赞数 158
分类专栏： c++笔记仓 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/arf_dog/article/details/138813688
版权

Alt

🔥个人主页：Quitecoder

🔥专栏：c++笔记仓

Alt

朋友们大家好，本篇文章来到二叉搜索树的内容

目录

1.二叉搜索树的介绍

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树

它在动态数据集合中维护了一定的排序顺序，以便实现快速的数据查找、插入和删除操作

在这里插入图片描述
左子树比根小，右子树比根大

比如我想查找13，就不需要暴力比较，按照大小往左边或者右边走

对于二叉搜索树，进行中序遍历为升序

2.二叉搜索树的操作与实现

首先我们构建节点：

template<class K>
struct BSTreeNode
{
	K _key;
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	BSTreeNode()
		:_key(K())
		,_left(nullptr)
		,_right(nullptr)
	{}
	BSTreeNode(const K& key)
		: _key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

每个节点有两个指针，分别指向它的左子节点和右子节点。如果子节点不存在，则这些指针为nullptr

  1. 默认构造函数：
BSTreeNode()
	:_key(K())
	,_left(nullptr)
	,_right(nullptr)
{}

默认构造函数，它初始化键值为K类型的默认值（通过调用K的默认构造函数），并将左右子节点指针都设置为nullptr，表示节点没有子节点

  1. 参数化构造函数：
BSTreeNode(const K& key)
	: _key(key)
	, _left(nullptr)
	, _right(nullptr)
{}

采用键值作为参数的构造函数，它会创建一个节点，这个节点的键值为传入的key值，同时初始化左右子节点指针为nullptr

接着我们来完成主体部分：

template<class T>
class BSTree
{
public:
	typedef BSTreeNode<T> Node;
private:
	Node* _root = nullptr;
};

insert插入

在这里插入图片描述
比如插入5，我们从根节点开始，比8小，往左走，比3大，往右走…：

在这里插入图片描述

bool Insert(const T& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	return true;
}

比当前节点小，往左走，反之往右走，搜索树默认是不允许插入重复键值

所以遇到相同的直接返回false，但是最后一步插入，我们还需要父亲位置的节点来完成左边插入或者右边插入，所以我们需要一个父亲节点来记录位置：

bool Insert(const T& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(key);
	if (parent->_key < key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	return true;
}

由于我们是从根部开始向下遍历直到达到叶节点，parent->_key必定不等于key（因为有重复检查）。如果parent的键值小于插入的键值key，新节点被设置为父节点的右子树；否则设置为左子树

注意

这里如果起始为**空树*

Node* cur = _root;
while (cur)
{
    // ...
}

由于cur是从_root开始的，如果跳过判空且_root实际上为nullptr，这个循环不会执行任何操作，因为它的条件立即不满足（cur此时为nullptr），并且会跳到循环之后的代码，如下：

cur = new Node(key);
// ...

这里将创建一个新的节点，但此时变量parent仍然是nullptr。代码会接着尝试访问parent的_key成员：

if (parent->_key < key)
{
    // ...
}

因为parent是nullptr，这会导致未定义行为，最常见的是程序崩溃，因为你不能对nullptr解引用。另外，即使程序不崩溃，新的节点cur也没有父节点可以挂载到，这样二叉搜索树的结构就不完整了

所以完整代码如下：

bool Insert(const T& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(key);
	if (parent->_key < key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	return true;
}

Find查找

find这里思路很简单，就按照大小关系往下遍历即可：

bool Find(const T& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			cur = cur->_left;
		}
		else
		{
			return true;
		}
	}
	return false;
}

InOrder中序遍历

void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->_left);
	cout << root->_key << " ";
	_InOrder(root->_right);
}

这里我们需要传入根节点，为类成员，单独一个函数是无法实现的，所以我们先完成上面的子函数书写，再一个主函数传入_root即可

void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

测试如下：

int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };

for (int e : a)
{
	b1.Insert(e);
}
b1.InOrder();

在这里插入图片描述

Erase删除

二叉树的删除是这里的难点，因为它涉及到多种情况，针对不同的情况我们对应不同的方法：

  1. 要删除的结点无孩子结点
  2. 要删除的结点只有左孩子结点
  3. 要删除的结点只有右孩子结点
  4. 要删除的结点有左、右孩子结点

前三种情况可以结合起来：

情况2：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除

情况3：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除

情况4：替换法解决

对于一个节点，它的：

  • 中序前驱是它左子树中的最大节点，它小于该节点且最接近它。
  • 中序后继是它右子树中的最小节点，它大于该节点且最接近它。

替换法删除的思路分为以下步骤：

  1. 找到需要被删除的节点。
  2. 检查这个节点是否有两个子节点：
    • 如果不是，处理起来比较简单，可以直接删除。如果该节点只有一个子节点，则该子节点取代被删除节点的位置。如果是叶节点，可以直接移除。
    • 如果是，执行以下步骤。
  3. 选择使用中序前驱或中序后继来替换要删除的节点。我们通常默认使用中序后继，但两者均可。
  4. 找到中序后继节点：
    • 进入待删除节点的右子树，然后一直向左走，直到找到没有左子节点的节点；这是中序后继。
  5. 替换：
    • 复制中序后继节点的值到待删除节点中，覆盖原有值
    • 此时，待删除节点的值已更新为其中序后继节点的值，原来的中序后继节点可以被移除（因为它已经被复制了）。需要注意，这个中序后继节点不会有左子节点（因为它已经是某个子树中的最左侧节点），所以它要么是一个叶节点，要么只有一个右子节点
  6. 删除中序后继节点：
    • 通过调整指针，将中序后继节点的父节点指向其可能存在的右子节点（也可能为空），完成删除操作

进行这样的替换之后，二叉搜索树的特性依然得以保持。中序后继节点保证了替换后的节点值仍然比其左子节点的所有值大，且比其右子节点（除了被移除的中序后继节点外）的所有值小

替换法删除操作需要注意的关键点是，通过中序前驱或中序后继节点替换，实际上我们把删除一个可能有两个子节点的难题转变成了删除一个有零个或一个子节点的简单问题，且这个中序后继节点一定在待删除节点的右子树中最左侧

	bool Erase(const T& key)
{
	if (_root == nullptr)
		return false;
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			if (cur->_left == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_right;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else {
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;

			}
			else
			{
				//左右都不为空，替换法删除
				Node* rightminparent = cur;
				Node* rightmin = cur->_right;
				while (rightmin->_left)
				{
					rightminparent = rightmin;
					rightmin = rightmin->_left;
				}
				cur->_key = rightmin->_key;
				if (rightminparent->_left = rightmin)
				{
					rightminparent->_left = rightmin->_right;
				}
				else
				{
					rightminparent->_right = rightmin->_right;
				}
				delete rightmin;
			}

			return true;
		}
	}
	return false;
}

我们拆分来看这串代码：

  1. 检查树是否为空:
if (_root == nullptr)
    return false;

  1. 查找需删除的节点:
    代码通过while循环遍历树找到匹配key的节点。在循环中使用变量cur作为当前节点，变量parent作为cur的父节点

  2. 节点匹配:
    当找到与key匹配的节点后:

    • 如果该节点没有左子节点(cur->_left == nullptr), 那么它的右子节点直接替换它（也适用于它没有子节点的情况）
    • 如果该节点没有右子节点(cur->_right == nullptr), 那么它的左子节点直接替换它
if (cur->_left == nullptr)
{
	if (cur == _root)
	{
		_root = cur->_right;
	}
	else
	{
		if (cur == parent->_left)
		{
			parent->_left = cur->_right;
		}
		else
		{
			parent->_right = cur->_right;
		}
	}
	delete cur;
}

如果cur恰好是根节点，我们直接将树的根 _root 指向cur的右子节点。这个更新意味着我们在树中移除了根节点，并将右子节点（如果存在）提升为新的根节点。

如果cur不是根节点，我们需要更新它父节点的相应指针。我们检查cur是其父节点的左子还是右子，并相应地更新父节点的左指针或右指针，使其指向cur的右子节点。这样，在二叉搜索树中删除了cur节点，并保持了其右子树

    • 如果该节点既有左子节点也有右子节点, 那么需要找到该节点的中序后继节点来替代它。中序后继节点是在其右子树中值最小的节点。我们替换cur的键为中序后继节点的键，并将rightmin放在原来的位置上。
else
{
	//左右都不为空，替换法删除
	Node* rightminparent = cur;
	Node* rightmin = cur->_right;
	while (rightmin->_left)
	{
		rightminparent = rightmin;
		rightmin = rightmin->_left;
	}
	cur->_key = rightmin->_key;
	if (rightminparent->_left == rightmin)
	{
		rightminparent->_left = rightmin->_right;
	}
	else
	{
		rightminparent->_right = rightmin->_right;
	}
	delete rightmin;
}

注意，在替换完成后需要删除原始的中序后继节点。这时rightmin的右子节点（如果存在）会替换rightmin。

每次删除一个节点后，代码会释放该节点的内存。

  1. 维护父节点指针:
    删除过程中对父节点指针的适当维护是必须的，以确保删除节点后树的结构保持正确。比如，如果待删除节点是其父节点的左子节点，那么父节点的左指针应该指向待删除节点的相应子节点

最后，如果在树中找到并成功删除了key对应的节点，则函数返回true。如果没有找到，则函数返回false。

3.二叉搜索树的应用（K与KV模型）

  1. K模型：
    • K模型指的是二叉树的节点仅存储键Key）信息，而没有与键相关联的特定“值”（Value）。换句话说，节点中的数据只有一个维度，节点的排序和组织就是基于这些键
    • 在K模型的二叉树中，例如二叉搜索树（BST），节点的位置由其键的顺序决定。所有的节点操作，包括插入、查找和删除都是根据这个键来执行的。
  • 比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
    • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
    • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误
  1. KV模型：
    • KV模型指的是二叉树的节点存储“键值对”（Key-Value Pair）。这里“键”（Key）用于确定节点的位置跟顺序，“值”（Value）则是与键关联的数据。
    • 在KV模型的二叉树中，节点依然是根据键的顺序进行排列和组织的，但是与每个键都有一个相对应的值。这种模式适用于情况更为复杂的场景，如实现映射或字典结构。
    • KV模型的一个典型例子是映射（Map）或词典（Dictionary）

比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；

再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对

改造二叉树为KV结构

节点构建，加一个模版参数V

template<class K,class V>
struct BSTreeNode
{
	V _value;
	K _key;
	BSTreeNode<K,V>* _left;
	BSTreeNode<K,V>* _right;
	BSTreeNode()
		:_key(K())
		, _value(V());
		, _left(nullptr)
		, _right(nullptr)
	{}
	BSTreeNode(const K& key,const V& value)
		: _key(key)
		,_value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

代码主题部分只需要进行简单的修改即可：

template<class K,class V>
class BSTree
{
public:
	typedef BSTreeNode<K,V> Node;
	bool Insert(const K& key,const V& value)
	{........
	cur = new Node(key,value);
     ........
	}
	Node* Find(const K& key)
    {
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < key)
		{
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			cur = cur->_left;
		}
		else
		{
			return cur;
		}
	}
	return nullptr;
    }
	........
};

其余部分不需要改变

简单示例如下：

void TestBSTree2()
	{
		BSTree<string, string> dict;
		dict.Insert("string", "字符串");
		dict.Insert("left", "左边");
		dict.Insert("insert", "插入");
		//...

		string str;
		while (cin >> str)
		{
			BSTreeNode<string, string>* ret = dict.Find(str);
			if (ret)
			{
				cout << ret->_value << endl;
			}
			else
			{
				cout << "无此单词，请重新输入" << endl;
			}
		}
	}

本节内容到此结束！ 感谢阅读！！

4.二叉搜索树性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为O(log n)

在这里插入图片描述
最差情况下，二叉搜索树退化为单支树(或者类似单支)，查找的时间复杂度为O(n)

在这里插入图片描述
如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？

期待后续AVL树和红黑树的讲解

本节内容到此结束！！感谢阅读！！

QuiteCoder
关注
  • 158
    点赞
  • 踩
  • 142
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 128
    评论
专栏目录
BST_fanli.zip.二叉搜索树源码
04-10
二叉搜索树源码，数据结构上机课任务，C++写的，可以运行
C++实现二叉搜索树（BST），通过控制台能够实现增删改查
12-02
C++实现二叉搜索树（BST），通过控制台能够实现增删改查，同时还能求树的高度，其中树的增加，删除等都是采用递归的方式生成的
二叉查找树（二分搜索树）的C++方法实现
01-20
资源内容：完整的二叉查找树C++头文件，包括<<运算符重载，bst类构造器、bst类析构器、destroy()、size()、insert()，迭代器类的声明与实现，++运算符重载（前置、后置）、--运算符重载、*运算符重载、！=运算符重载、begin()、end()、find()、erase()、insertLeaf()、prune()、deleteLink()。（插入节点方法、删除节点的三种情况）。
C++ 二叉搜索树(BST)的实现方法
01-20
废话不多说了，直接给大家贴代码了，具体代码如下所示： class BST { public: struct Node { int key;//节点的key int value;//节点的value Node* left; Node *right; int N;//节点的叶子节点数目 Node(int _key, int _value, int _N) { key = _key; value = _value; N = _N; } }; BST(); ~BST(); vo
C++进阶——二叉搜索树BST
weixin_43635473的博客
04-21 642
C++进阶——二叉搜索树BST
二叉搜索树BST实现(c++语言)
weixin_40428368的博客
09-10 247
数据结构
C++二叉搜索树
默的博客
05-05 532
C++二叉搜索树1、概念2、操作2.1增加（插入）2.2删除2.3查找2.4修改3、 二叉搜索树的性能分析4、模拟实现代码 1、概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树。 2、操作 2.1增加（插入） 树为空，直接插入，返回true； 树不为空，判断根节点数据大小，根数据大往左边找，否则往右边找，找到返回true；
二叉搜索树（BST-Tree）(C++全)
weixin_48560325的博客
04-28 4709
目录 二叉搜索树基本概念 1，什么是根节点 2、什么是二叉搜索树 3、二叉搜索树结构 4、二叉搜索树的性质 5、复杂度 算法实现 1、创建一个二叉搜索树节点 2、打印二叉搜索树 3、二叉搜索树的插入 4、其他操作 （1）查找二叉搜索树的最大值 （2）查找二叉搜索树的最小值 （3）查找某一节点的前驱 （4）查找某一节点的后继 5、删除二叉搜索树的某一节点 步骤： 代码： 性能分析 二叉搜索树基本概念 1，什么是根节点 根结点（root）是树的一个组成部分，也
【数据结构】二叉查找树/二叉搜索树BST（附相关C++代码）
weixin_50941083的博客
05-14 837
本文内容将主要介绍二叉查找树的相关概念，与关于二叉查找树的重要操作，如添加节点、删除节点等。
【C++】二叉搜索树（BST）
taoxing
07-11 753
一.基本介绍 特征： 二叉搜索树，也被称为二叉查找树、有序二叉树或者排序二叉树。 ∙\bullet∙ 一般来说输入的第一个数作为根结点，当继续输入数时，小于根结点的放在根结点左边，大于根结点的放在根结点右边。 ∙\bullet∙ 不只是根结点，每个子节点也符合左小右大的规律。 ∙\bullet∙ 如下图所示，输入数据8、3、10、1、6、14、4、7、13，得到下面的二叉搜索树。 下面我们来介绍BST的构成成分： ∙\bullet∙ 首先我们需要实现两个类：一个是BSTNode类（节点类）、一个为
C++实现二叉搜索树BST,并实现多种方式遍历
AppWhite_Star的博客
12-24 805
C++实现二叉搜索树BST,并实现多种方式遍历
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 800
string类各函数接口。
C语言在头⽂件中#if、_STDC_等字⾏起什么作⽤？
PAP
05-26 395
C语言——在头⽂件中#if、_STDC_等字⾏起什么作⽤？
C-数据结构-树状存储的基本实现
aqiangdeba的博客
05-27 917
main.c320。
【如何利用c++RAII技术实现自动加解锁】
逆风飞翔的博客
05-28 331
使用C++中的 RAII（资源获取即初始化）技术来实现自动加锁解锁
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
weixin_73886306的博客
05-30 303
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
C++ 多重继承的内存布局和指针偏移
Damon_X的博客
05-30 273
在 C++ 程序里，在有多重继承的类里面。偏移的大小，等于派生类的继承顺序表里面，排在该类前面的所有的类的数据成员（含虚表指针）所占的空间大小总和。注意：在 D 的继承关系链里面，只有基类 B 有虚函数，因此对于 D 对象而言，总体只有一个虚表指针，也就是（B）基类对象中的虚表指针。D 继承自A, B, C，它的大小等于 A, B, C 的所有数据成员的大小，加上其自身的数据成员和虚表指针的总的大小：4(b) + 4(c) + 4(d) + 8(vptr) = 20 字节。我们首先来分析这四个类的大小。
【C++】问题及补充（2）
最新发布
2301_80207207的博客
05-30 805
vector和list都是C++ STL中的容器，它们被定义在不同的头文件中。vector在中定义，而list在中定义。因此，如果要使用它们，需要包含相应的头文件。通常情况下，C++中的类定义需要包含在头文件中，而类的实现则包含在源文件中。这样做的目的是为了避免在多个源文件中重复定义同一个类，从而引发编译错误。因此，在C++ STL中，vector和list的定义也需要写在头文件中，以便在需要使用它们的源文件中包含相应的头文件即可。
手搓顺序表（C语言）
m0_62646213的博客
05-28 959
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
C++最优二叉搜索树详细代码
05-05
最优二叉搜索树（Optimal Binary Search Tree）是一种动态规划的算法，用于在给定一组键和它们的概率时构建最优的二叉搜索树。 下面是 C 语言实现最优二叉搜索树的详细代码： ``` #include <stdio.h> #include <limits.h> #define MAX_KEYS 100 int keys[MAX_KEYS]; int freq[MAX_KEYS]; int n; int sum(int freq[], int i, int j) { int s = 0; for (int k = i; k <= j; k++) { s += freq[k]; } return s; } int opt_cost(int freq[], int i, int j) { if (j < i) { return 0; } if (j == i) { return freq[i]; } int fsum = sum(freq, i, j); int min_cost = INT_MAX; for (int r = i; r <= j; r++) { int cost = opt_cost(freq, i, r-1) + opt_cost(freq, r+1, j) + fsum; if (cost < min_cost) { min_cost = cost; } } return min_cost; } int main() { printf("Enter the number of keys: "); scanf("%d", &n); printf("Enter the keys:\n"); for (int i = 0; i < n; i++) { scanf("%d", &keys[i]); } printf("Enter the frequencies:\n"); for (int i = 0; i < n; i++) { scanf("%d", &freq[i]); } int cost = opt_cost(freq, 0, n-1); printf("Minimum cost of optimal BST is %d.\n", cost); return 0; } ``` 代码中，`sum()` 函数用于计算频率数组 `freq[]` 中下标从 `i` 到 `j` 的元素之和，`opt_cost()` 函数则是实现最优二叉搜索树的核心算法。`opt_cost()` 函数使用递归的方法，枚举所有可能的根节点，计算出每个根节点对应的最小成本，并返回其中的最小值。 在主函数中，输入了键和频率数组，并调用 `opt_cost()` 函数计算出最小成本。 需要注意的是，该代码仅仅是计算了最小成本，并没有构建出最优二叉搜索树的结构。如果需要构建出最优二叉搜索树，需要在递归过程中记录每个子树的根节点，然后根据这些根节点的位置来构建树的结构。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

QuiteCoder

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

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

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

打赏作者

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

抵扣说明：

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

余额充值