C++：AVL树的插入详解

最新推荐文章于 2024-04-08 14:44:18 发布
最新推荐文章于 2024-04-08 14:44:18 发布
阅读量631 收藏 2
点赞数
分类专栏： C++专栏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AngelDg/article/details/105797584
版权

AVL

AVL树的概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树:

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

在这里插入图片描述

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 O(log2n)，搜索时间复杂度O(log2n)。

AVL树节点的定义

template <class T>
class TreeNode
{
	int m_bf;
	T m_data;
	TreeNode<T>* m_left;
	TreeNode<T>* m_right;
	TreeNode<T>* m_parent;
public:
	TreeNode(const T& val = T()) :
		m_bf(0),
		m_data(val),
		m_left(nullptr),
		m_right(nullptr),
		m_parent(nullptr)
	{}
};
AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步:

  1. 按照二叉搜索树的方式插入新节点

  2. 调整节点的平衡因子

template <class T>
class AVLTree
{
	TreeNode<T>* m_root;
public:
	bool insert(const T& val)
	{
		if (m_root == nullptr)
		{
			m_root = new TreeNode<T>(val);
			return true;
		}

		TreeNode<T>* cur = m_root;
		TreeNode<T>* pre = nullptr;

		while (cur)
		{
			if (val < cur->m_data)
			{
				pre = cur;
				cur = cur->m_left;
			}
			else if (val > cur->m_data)
			{
				pre = cur;
				cur = cur->m_right;
			}
			else
			{
				return false;
			}
		}

		cur = new TreeNode<T>(val);
		if (val < pre->m_data)
		{
			pre->m_left = cur;
		}
		else
		{
			pre->m_right = cur;
		}

		cur->m_parent = pre;

		while (pre)
		{
			// 更新双亲的平衡因子
			if (pre->m_left == cur)
			{
				pre->m_bf--;
			}
			else
			{
				pre->m_bf++;
			}

			// 更新后检测双亲的平衡因子
			if (pre->m_bf == 0)
			{
				break;
			}
			// 插入前双亲的平衡因子是0，插入后双亲的平衡因为为1 或者 -1
			// 说明以双亲为根的二叉树的高度增加了一层，因此需要继续向上调整 
			else if (pre->m_bf == 1 || pre->m_bf == -1)
			{
				cur = pre;
				pre = pre->m_parent;
			}
			else
			{
				// 双亲的平衡因子为正负2，违反了AVL树的平衡性
				// 需要对以pParent为根的树进行旋转处理
				if (pre->m_bf == 2)
				{
					if (cur->m_bf == 1)
					{
						lRound(pre);
					}
					else
					{
						rlRound(pre);
					}
				}
				else
				{
					if (cur->m_bf == 1)
					{
						lrRound(pre);
					}
					else
					{
						rRound(pre);
					}
				}
				break;
			}
		}
		return true;
	}
};
AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡 化。根据节点插入位置的不同，AVL树的旋转分为四种:

  1. 新节点插入较高右子树的右侧—右右:左单旋
    在这里插入图片描述
	// 出现右右这种情况，触发左单旋
	void lRound(TreeNode<T>* pre)
	{
		TreeNode<T>* parent = pre->m_parent;
		TreeNode<T>* cur = pre->m_right;

		cur->m_parent = parent;
		if (parent)
		{
			if (parent->m_left == pre)
			{
				parent->m_left = cur;
			}
			else
			{
				parent->m_right = cur;
			}
		}
		else
		{
			m_root = cur;
		}

		pre->m_right = cur->m_left;
		if (cur->m_left)
		{
			cur->m_left->m_parent = pre;
		}

		cur->m_left = pre;
		pre->m_parent = cur;

		cur->m_bf = pre->m_bf = 0;
	}
  1. 新节点插入较高左子树的左侧—左左:右单旋

在这里插入图片描述

// 出现左左这种情况，触发右单旋
	void rRound(TreeNode<T>* pre)
	{
		TreeNode<T>* parent = pre->m_parent; //B结点
		TreeNode<T>* cur = pre->m_left;

		cur->m_parent = parent;
		if (parent)
		{
			if (parent->m_left == pre)
			{
				parent->m_left = cur;
			}
			else
			{
				parent->m_right = cur;
			}
		}
		else
		{
			m_root = cur;
		}

		pre->m_left = cur->m_right;
		if (cur->m_right)
		{
			cur->m_right->m_parent = pre;
		}

		cur->m_right = pre;
		pre->m_parent = cur;

		cur->m_bf = pre->m_bf = 0;
	}
  1. 新节点插入较高左子树的右侧—左右:先左单旋再右单旋

在这里插入图片描述

	void lrRound(TreeNode<T>* pre)
	{
		TreeNode<T>* left = pre->m_left;
		TreeNode<T>* newroot = left->m_right;

		int flag = newroot->m_bf;

		lRound(pre->m_left);
		rRound(pre);

		if (flag == -1)
		{
			pre->m_bf = 1;
		}
		else if (flag == 1)
		{
			left->m_bf = -1;
		}
	}
  1. 新节点插入较高右子树的左侧—右左:先右单旋再左单旋

在这里插入图片描述

	void rlRound(TreeNode<T>* pre)
	{
		TreeNode<T>* right = pre->m_right;
		TreeNode<T>* newroot = right->m_left;

		int flag = newroot->m_bf;

		rRound(pre->m_right);
		lRound(pre);

		if (flag == -1)
		{
			right->m_bf = 1;
		}
		else if(flag == 1)
		{
			pre->m_bf = -1;
		}
	}
图解AVL树双旋过程

在这里插入图片描述

AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步:

  1. 验证其为二叉搜索树

    如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

	std::vector<T> InOrder()
	{
		std::stack<TreeNode<T>*> s;
		std::vector<T> res;
		TreeNode<T>* cur = m_root;

		while (cur || !s.empty())
		{
			for (; cur; cur = cur->m_left)
			{
				s.push(cur);
			}

			if (!s.empty())
			{
				cur = s.top();
				res.push_back(cur->m_data);
				s.pop();

				cur = cur->m_right;
			}
		}

		return res;
	}
  1. 验证其为平衡树
    1. 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
    2. 节点的平衡因子是否计算正确
	int _Height(TreeNode<T>* root) {
		if (root == NULL)
		{
			return 0;
		}
		int depth = 0;
		//求左子树的高度
		int leftDepth = _Height(root->m_left);
		//求右子树的高度
		int rightDepth = _Height(root->m_right);
		//求二叉树的高度
		depth = leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
		return depth;
	}

	bool _IsBalanceTree(TreeNode<T>* pRoot) {
		// 空树也是AVL树
		if (nullptr == pRoot)
			return true;
		// 计算pRoot节点的平衡因子:即pRoot左右子树的高度差 
		int leftHeight = _Height(pRoot->m_left);
		int rightHeight = _Height(pRoot->m_right);
		int diff = rightHeight - leftHeight;
		// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者 
		// pRoot平衡因子的绝对值超过1，则一定不是AVL树
		if (diff != pRoot->m_bf || (diff > 1 || diff < -1))
			return false;
		// pRoot的左和右如果都是AVL树，则该树一定是AVL树
		return _IsBalanceTree(pRoot->m_left) && _IsBalanceTree(pRoot->m_right);
	}

AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即 log2N 。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如: 插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。 因此:如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树， 但一个结构经常修改，就不太适合。

模拟实现AVL树的插入

.h文件

#pragma once

#include <vector>
#include <stack>

namespace dg {

template <class T>
class TreeNode
{
	int m_bf;
	T m_data;
	TreeNode<T>* m_left;
	TreeNode<T>* m_right;
	TreeNode<T>* m_parent;
public:
	TreeNode(const T& val = T()) :
		m_bf(0),
		m_data(val),
		m_left(nullptr),
		m_right(nullptr),
		m_parent(nullptr)
	{}

	template <class T>
	friend class AVLTree;
};

template <class T>
class AVLTree
{
public:
	TreeNode<T>* m_root;

	void destroy(TreeNode<T>* root)
	{
		if (root)
		{
			destroy(root->m_left);
			destroy(root->m_right);
			delete root;
		}
	}

	// 出现右右这种情况，触发左单旋
	void lRound(TreeNode<T>* pre)
	{
		TreeNode<T>* parent = pre->m_parent;
		TreeNode<T>* cur = pre->m_right;

		cur->m_parent = parent;
		if (parent)
		{
			if (parent->m_left == pre)
			{
				parent->m_left = cur;
			}
			else
			{
				parent->m_right = cur;
			}
		}
		else
		{
			m_root = cur;
		}

		pre->m_right = cur->m_left;
		if (cur->m_left)
		{
			cur->m_left->m_parent = pre;
		}

		cur->m_left = pre;
		pre->m_parent = cur;

		cur->m_bf = pre->m_bf = 0;
	}

	// 出现左左这种情况，触发右单旋
	void rRound(TreeNode<T>* pre)
	{
		TreeNode<T>* parent = pre->m_parent; //B结点
		TreeNode<T>* cur = pre->m_left;

		cur->m_parent = parent;
		if (parent)
		{
			if (parent->m_left == pre)
			{
				parent->m_left = cur;
			}
			else
			{
				parent->m_right = cur;
			}
		}
		else
		{
			m_root = cur;
		}

		pre->m_left = cur->m_right;
		if (cur->m_right)
		{
			cur->m_right->m_parent = pre;
		}

		cur->m_right = pre;
		pre->m_parent = cur;

		cur->m_bf = pre->m_bf = 0;
	}

	void rlRound(TreeNode<T>* pre)
	{
		TreeNode<T>* right = pre->m_right;
		TreeNode<T>* newroot = right->m_left;

		int flag = newroot->m_bf;

		rRound(pre->m_right);
		lRound(pre);

		if (flag == -1)
		{
			right->m_bf = 1;
		}
		else if(flag == 1)
		{
			pre->m_bf = -1;
		}
	}

	void lrRound(TreeNode<T>* pre)
	{
		TreeNode<T>* left = pre->m_left;
		TreeNode<T>* newroot = left->m_right;

		int flag = newroot->m_bf;

		lRound(pre->m_left);
		rRound(pre);

		if (flag == -1)
		{
			pre->m_bf = 1;
		}
		else if (flag == 1)
		{
			left->m_bf = -1;
		}
	}
public:
	AVLTree() :
		m_root(nullptr)
	{}

	~AVLTree()
	{
		destroy(m_root);
	}

	bool insert(const T& val)
	{
		if (m_root == nullptr)
		{
			m_root = new TreeNode<T>(val);
			return true;
		}

		TreeNode<T>* cur = m_root;
		TreeNode<T>* pre = nullptr;

		while (cur)
		{
			if (val < cur->m_data)
			{
				pre = cur;
				cur = cur->m_left;
			}
			else if (val > cur->m_data)
			{
				pre = cur;
				cur = cur->m_right;
			}
			else
			{
				return false;
			}
		}

		cur = new TreeNode<T>(val);
		if (val < pre->m_data)
		{
			pre->m_left = cur;
		}
		else
		{
			pre->m_right = cur;
		}

		cur->m_parent = pre;

		while (pre)
		{
			if (pre->m_left == cur)
			{
				pre->m_bf--;
			}
			else
			{
				pre->m_bf++;
			}

			if (pre->m_bf == 0)
			{
				break;
			}
			else if (pre->m_bf == 1 || pre->m_bf == -1)
			{
				cur = pre;
				pre = pre->m_parent;
			}
			else
			{
				if (pre->m_bf == 2)
				{
					if (cur->m_bf == 1)
					{
						lRound(pre);
					}
					else
					{
						rlRound(pre);
					}
				}
				else
				{
					if (cur->m_bf == 1)
					{
						lrRound(pre);
					}
					else
					{
						rRound(pre);
					}
				}
				break;
			}
		}
		return true;
	}

	std::vector<T> InOrder()
	{
		std::stack<TreeNode<T>*> s;
		std::vector<T> res;
		TreeNode<T>* cur = m_root;

		while (cur || !s.empty())
		{
			for (; cur; cur = cur->m_left)
			{
				s.push(cur);
			}

			if (!s.empty())
			{
				cur = s.top();
				res.push_back(cur->m_data);
				s.pop();

				cur = cur->m_right;
			}
		}

		return res;
	}

	int _Height(TreeNode<T>* root) {
		if (root == NULL)
		{
			return 0;
		}
		int depth = 0;
		//求左子树的高度
		int leftDepth = _Height(root->m_left);
		//求右子树的高度
		int rightDepth = _Height(root->m_right);
		//求二叉树的高度
		depth = leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
		return depth;
	}

	bool _IsBalanceTree(TreeNode<T>* pRoot) {
		// 空树也是AVL树
		if (nullptr == pRoot)
			return true;
		// 计算pRoot节点的平衡因子:即pRoot左右子树的高度差 
		int leftHeight = _Height(pRoot->m_left);
		int rightHeight = _Height(pRoot->m_right);
		int diff = rightHeight - leftHeight;
		// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者 
		// pRoot平衡因子的绝对值超过1，则一定不是AVL树
		if (diff != pRoot->m_bf || (diff > 1 || diff < -1))
			return false;
		// pRoot的左和右如果都是AVL树，则该树一定是AVL树
		return _IsBalanceTree(pRoot->m_left) && _IsBalanceTree(pRoot->m_right);
	}

};

};

主函数：

#include "AVLTree.h"
#include <iostream>
using namespace std;

int main()
{
	dg::AVLTree<int> bst;

	bst.insert(5);
	bst.insert(2);
	bst.insert(8);
	bst.insert(0);
	bst.insert(4);
	bst.insert(7);
	bst.insert(9);
	bst.insert(1);
	bst.insert(3);
	bst.insert(6);
	
	//bst.insert(16);
	//bst.insert(3);
	//bst.insert(7);
	//bst.insert(11);
	//bst.insert(9);
	//bst.insert(26);
	//bst.insert(18);
	//bst.insert(14);
	//bst.insert(15);

	//bst.insert(4);
	//bst.insert(2);
	//bst.insert(6);
	//bst.insert(1);
	//bst.insert(3);
	//bst.insert(5);
	//bst.insert(15);
	//bst.insert(7);
	//bst.insert(16);
	//bst.insert(14);

	//bst.insert(1);
	//bst.insert(2);
	//bst.insert(3);
	//bst.insert(4);
	//bst.insert(5);
	//bst.insert(6);
	//bst.insert(7);
	//bst.insert(7);
	//bst.insert(6);
	//bst.insert(5);
	//bst.insert(4);
	//bst.insert(3);
	//bst.insert(2);
	//bst.insert(1);
	
	if (bst._IsBalanceTree(bst.m_root)) {
		cout << "是平衡二叉树：";
	}
	else {
		cout << "不是平衡二叉树：";
	}

	vector<int> v = bst.InOrder();

	for (auto& i : v)
	{
		cout << i << ' ';
	}
	return 0;
}

代码生成图：
在这里插入图片描述

如有不同见解，欢迎留言讨论

小米内推官_AngelDg
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于双向堆栈的avl树双向迭代算法
05-23
### 基于双向堆栈的AVL树双向迭代算法详解 #### 一、引言与背景 在现代计算机科学中，数据结构的设计对于优化算法性能至关重要。平衡二叉搜索树，尤其是AVL树，因其良好的查找性能和有序的数据存储方式而被广泛...
AVL树的查找、删除、插入
09-18
### AVL树的查找、删除与插入 #### 一、引言 AVL树是一种自平衡的二叉搜索树，由Georgy Adelson-Velsky和Evgenii Landis在1962年发明。它在任何操作后都能保持树的高度平衡，确保了基本操作（如查找、插入和删除）...
【C++】AVL树插入过程详解
罅隙的博客
09-13 979
在本文中，我们将学习AVL树是如何插入新元素的，重点掌握AVL树中的“旋转”是如何维持平衡因子。
AVL树插入详解
Shall#的博客
03-06 551
AVL树、平衡二叉树、搜索二叉树、插入函数
数据结构:AVL树详解(平衡二叉树)
机会是给有准备的人
11-11 3121
假如以 parent 为根的子树不平衡，即 parent 的平衡因子为2或者-2，分以下情况考虑parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL当subL的平衡因子为-1是，执行右单旋当subL的平衡因子为1时，执行左右双旋。
AVL树的插入详解
C_Rio的博客
11-09 294
_kv(kv)//pair内部有实现自己的拷贝构造函数,_bf(0){}int _bf;//每个节点的平衡因子（right-left）class AVLpublic:AVL(){}private:首先我们要知道AVL树的数据类型一般都是K-V型，具体说也就是pair类型，而且AVL树和一般的树据关联是不同的，属于三叉连，也就是不仅仅要有左右指针还要有父指针，而父指针的目的就是在插入数据的时候可以更方便的处理祖宗节点的平衡因子。平衡因子的计算：右子树的高度—左子树的高度。
『 C++ 』AVL树详解 ( 万字 )
小侯宝的博客
01-15 812
从上文可知,AVL树可以看作是一棵搜索二叉树,其为基于搜索二叉树在此基础上对树做了平衡的操作使其在结构上变得平衡不至于在极端情况下出现"歪脖子树"的情况;AVL树的定义与平衡搜索二叉树的结构上呈现类似;//将节点进行typedefpublic:protected:private://节点指针该篇文章中重点实现AVL树中的插入操作;
【C++】-- AVL树详解
局部变量和全局变量
08-31 2414
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： (1)它的左右子树都是AVL树 (2)左右子树高度之差(简称平衡因子=右子树高度-左子树高度)的绝对值不超过1(-1/0/1)
AVL树（动图详解）
热门推荐
2021dragon的博客
12-02 1万+
AVL树（C++实现）
C++：AVL树
NaiLuo_45的博客
04-08 925
AVL树插入、旋转详解
C++之AVL树详解
weixin_64394633的博客
11-08 550
【代码】C++之AVL树详解
基于C++ AVL树的航空客运订票系统【100012693】
06-12
《基于C++ AVL树的航空客运订票系统详解》 航空客运订票系统是现代航空公司运营中的关键组成部分，它能够高效地处理航班信息、预订和退票等业务。本项目以C++编程语言为基础，利用AVL树这一自平衡二叉搜索树的数据...
山东大学数据结构课程设计—AVL搜索树
11-24
【AVL搜索树详解】 AVL搜索树是一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。它是最早被提出的自平衡二叉搜索树，其主要特点是任何节点的两个子树的高度最大差别不...
c++实现二叉查找树
11-15
本文将详细介绍如何使用C++来实现一个二叉查找树(Binary Search Tree, BST)，包括其基本操作：插入、删除、遍历等，并通过示例代码进行解释。二叉查找树是一种非常重要的数据结构，在计算机科学领域有着广泛的应用，...
pillow_heif-0.17.0-pp39-pypy39_pp73-macosx_14_0_arm64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
cykooz.resizer-3.0.0-cp310-cp310-macosx_11_0_arm64.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
[毕设]Delphi题库管理与试卷自动生成系统.zip
最新发布
07-27
[毕设]Delphi题库管理与试卷自动生成系统
131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+图像识别与定位+该数据集相关的研究论文
07-27
<项目介绍> 包含131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+该数据集相关的研究论文。可供深度学习图像识别与定位。 - 训练集大小：67700 个图像 测试集大小：22888 个图像 文件名格式：image_index_100.jpg（例如 32_100.jpg）或 r_image_index_100.jpg（例如 r_32_100.jpg）或 r2_image_index_100.jpg 或 r3_image_index_100.jpg。 “r”代表旋转水果。 “r2”表示水果绕第三轴旋转。 “100”来自图像尺寸（100x100 像素）。 水果是如何拍摄的: 1:使用 C920 摄像机拍摄水果。最好的网络摄像头之一。 2:在水果后面，我们放了一张白纸作为背景。 3:将水果和蔬菜种植在低速电机（3转/分钟）的轴中，并录制一段20秒的短片。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
数据结构：树形结构详解与应用
1. **树**：树是一种非线性的数据结构，由节点（或称为顶点）和边组成，每个节点可以有零个或多个子节点。树的基本术语包括根节点（没有父节点的节点）、叶子节点（没有子节点的节点）和分支节点（既有父节点又有子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值