二叉树进阶

C++二叉树进阶 二叉搜索树又称二叉排序树,它或者是一颗空树,或者具有以下性质的二叉树。 阅读详情

目录

二叉搜索树概念

​二叉搜索树操作

二叉搜索树的查找

二叉搜索树的插入

二叉搜索树的删除

二叉搜索树的应用

二叉搜索树的性能分析


二叉搜索树概念

二叉搜索树(BST Binary Search Tree),也称二叉排序树或二叉查找树。

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

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

二叉搜索树操作

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

二叉搜索树的查找

  • a、从根开始比较,查找,比根大则往右边走查找,比根小则往左边走查找。
  • b、最多查找高度次,走到到空,还没找到,这个值不存在。

二叉搜索树的插入

插入的具体过程如下:

  • a. 树为空,则直接新增节点,赋值给root指针
  • b. 树不空,按二叉搜索树性质查找插入位置,插入新节点

二叉搜索树的删除

首先查找元素是否在二叉搜索树中,如果不存在,则返回, 否则要删除的结点可能分下面四种情
况:

  • a. 要删除的结点无孩子结点
  • b. 要删除的结点只有左孩子结点
  • c. 要删除的结点只有右孩子结点
  • d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况,实际情况a可以与情况b或者c合并起来,因此真正的删除过程如下:

  • 情况b:删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除
  • 情况c:删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除
  • 情况d:在它的右子树中寻找中序下的第一个结点(关键码最小),用它的值填补到被删除节点中,再来处理该结点的删除问题--替换法删

二叉搜索树的应用

1. K模型:K模型即只有key作为关键码,结构中只需要存储Key即可,关键码即为需要搜索到的值。
比如:给一个单词word,判断该单词是否拼写正确,具体方式如下:

  • 以词库中所有单词集合中的每个单词作为key,构建一棵二叉搜索树
  • 在二叉搜索树中检索该单词是否存在,存在则拼写正确,不存在则拼写错误。

2. KV模型:每一个关键码key,都有与之对应的值Value,即<Key, Value>的键值对。该种方
式在现实生活中非常常见:

  • 比如英汉词典就是英文与中文的对应关系,通过英文可以快速找到与其对应的中文,英文单词与其对应的中文<word, chinese>就构成一种键值对;
  • 再比如统计单词次数,统计成功后,给定单词就可快速找到其出现的次数,单词与其出现次数就是<word, count>就构成一种键值对。
// K模型
#pragma once
#include<iostream>
#include<vector>
using namespace std;


namespace chx
{
	template<class T>
	struct BSTreeNode
	{
		BSTreeNode<T>* _left;
		BSTreeNode<T>* _right;
		T _key;
		BSTreeNode(const T& key)
			:_key(key)
			,_left(left)
			,_right(right)
		{}
	};
	template<class K>
	class BSTree
	{
	private:
		typedef BSTreeNode<K> Node;
	public:
		bool Insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}
			Node* prev = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					prev = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					prev = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			Node* newnode = new Node(key);
			if (prev->_key < key)
			{
				prev->_right = newnode;
			}
			else
			{
				prev->_left = newnode;
			}

			return true;
		}
		bool Find(const K& key)
		{
			if (_root == nullptr)
			{
				return false;
			}
			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;
		}
		bool Erase(const K& key)
		{
			if (_root == nullptr)
			{
				return false;
			}
			Node* cur = _root;
			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
				{
					// 开始删除
					// 1、左为空
					// 2、右为空
					// 3、左右都不为空
					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 == nullptr;
					}
					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;
						cur = nullptr;
					}
					else
					{
						Node* minparent = nullptr;
						Node* min = cur->_right;
						while (min->_left)
						{
							minparent = min;
							min = min->_left;
						}
						swap(cur->_key, min->_key);
						if (minParent->_left == min)
							minParent->_left = min->_right;
						else
							minParent->_right = min->_right;

						delete min;
					}
				}
			}
			return false;
		}
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

		/////////////////////////////////////////////////////////////////////////////
		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}

		bool InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}

		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}

		~BSTree()
		{
			_Destory(_root);
		}


		// C++的用法:强制编译器生成默认的构造
		BSTree() = default;

		BSTree(const BSTree<K>&t)
		{
			_root = _Copy(t._root);
		}

		// t2 = t1
		BSTree<K>& operator=(BSTree<K> t)
		{
			swap(_root, t._root);
			return *this;
		}
	private:
		Node* _Copy(Node* root)
		{
			if (root == nullptr)
			{
				return nullptr;
			}
			Node* cur = new Node(root->key);
			cur->_left = _Copy(root->_left);
			cur->_right = _Copy(root->_right);
			return cur;
		}
		void _Destory(Node*& root)
		{
			if (root == nullptr)
				return;
			_Destory(root->_left);
			_Destory(root->_right);
			delete root;
			return;
		}
		bool _EraseR(Node*& root, const K& key)
		{
			if (root == nullptr)
				return false;
			if (root->_key < key)
				return _EraseR(root->_right, key);
			else if (root->_key > key)
				return _EraseR(root->_left, key);
			else
			{
				Node* del = root;
				if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					Node* min = root->_right;
					while (min->_left)
					{
						min = min->_left;
					}
					swap(min->_key, root->key);
					//key被交换下去了,所以最后会变成前两种情况
					return _EraseR(root->_right, key);
				}
				delete del;
				return true;
			}
		}
		bool _InsertR(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				Node* newnode = new Node(key);
				root = newnode;
				return true;
			}
			if (root->_key < key)
				return _InsertR(root->_right, key);
			else if (root->_key > key)
				return _InsertR(root->_left, key);
			else
				return false;
		}
		bool _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key < key)
				return _FindR(root->_right, key);
			else if (root->_key > key)
				return _FindR(root->_left, key);
			else
				return true;
		}
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}
	private:
		Node* _root;
	};
}
//KV模型
#pragma once
#include<iostream>
#include<vector>
using namespace std;


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

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

		bool Erase(const K& key)
		{
			if (_root == nullptr)
			{
				return false;
			}
			Node* cur = _root;
			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
				{
					// 开始删除
					// 1、左为空
					// 2、右为空
					// 3、左右都不为空
					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 == nullptr;
					}
					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;
						cur = nullptr;
					}
					else
					{
						Node* minparent = nullptr;
						Node* min = cur->_right;
						while (min->_left)
						{
							minparent = min;
							min = min->_left;
						}
						swap(cur->_key, min->_key);
						if (minParent->_left == min)
							minParent->_left = min->_right;
						else
							minParent->_right = min->_right;

						delete min;
					}
				}
			}
			return false;
		}
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:

		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root;
	};
}

二叉搜索树的性能分析

插入和删除操作都必须先查找,查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树,若每个元素查找的概率相等,则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数,即结点越深,则比较次数越多。

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

  • 最优情况下,二叉搜索树为完全二叉树(或者接近完全二叉树),其平均比较次数为:$log_2 N$
  • 最差情况下,二叉搜索树退化为单支树(或者类似单支),其平均比较次数为:$\frac{N}{2}$ 
C++二叉树进阶面试题 只是后序要倒着从后往前访问:后序倒着访问到根以后,紧接着就是右子树的根节点,然后才是左子树的根节点。●递归的子问题:就是通过前序确定根后,在中序里分隔出左右子树,则中序分割出的左子树又可以通过前序的下一个值来确定子树的根,紧接着就又是分割左右子树,这就是递归的子问题;进入到右子树后,就是迭代的子问题:即在右子树中也是先遍历左路节点,然后遍历左路节点的右子树。●递归的结束条件:通过前序确定根以后可以在中序中分割出左右子树的区间,则当递归到区间不存在时,说明左右子树已经为空,这时就递归结束。 阅读详情

相关推荐

从“要啥”到“咋测”:手把手拆解Aspice SWE.1需求分析,为你的车载/嵌入式项目避坑

本文深入解析Aspice SWE.1需求分析在车载/嵌入式项目中的关键作用,帮助开发者将模糊的系统需求转化为可执行、可验证的软件需求。通过实战案例和结构化方法,详细拆解功能需求原子化、非功能需求工程化表达等核心技巧,为项目避坑提供实用指南。

weixin_31682031的博客 261

c++——二叉树进阶

本节内容主要围绕二叉搜索树(BST)展开,旨在通过二叉搜索树的学习,进一步理解map和set等数据结构的特性。二叉搜索树是一种特殊的二叉树,具有左子树节点值小于根节点、右子树节点值大于根节点的性质。文章详细介绍了二叉搜索树的基本操作,包括查找、插入和删除,并提供了递归和非递归的实现方式。此外,还探讨了二叉搜索树在实际应用中的两种模型:key搜索模型和key-value搜索模型。最后,文章通过几道LeetCode题目,展示了二叉搜索树在面试题中的应用,如二叉树的字符串表示、最近公共祖先、二叉搜索树

xiaosuai168的博客 1486

RTX 50系显卡(5080/5090D)CUDA 12.8环境下的vLLM部署避坑与实战指南

本文为RTX 5080/5090D显卡用户提供了在CUDA 12.8环境下部署vLLM的完整实战指南。文章详细介绍了从驱动安装、CUDA 12.8环境配置、PyTorch Nightly版本精准匹配,到vLLM源码编译及常见报错排查的全过程,帮助开发者高效利用新一代硬件进行大模型推理。

gray5的博客 671

【刷题日记】二叉树经典进阶题目

😀大家好,我是白晨,一个不是很能熬夜😫,但是也想日更的人✈。如果喜欢这篇文章,点个赞👍,关注一下👀白晨吧!你的支持就是我最大的动力!💪💪💪虽然还有很多课,但是也不能忘了写编程题呀🤣。本次白晨为大家总结了二叉树的经典进阶题目,需要一定的二叉树的基础,如果没有了解过二叉树的同学可以先读【数据结构】二叉树全解析(入门篇)了解一下二叉树这种十分经典的数据结构。这次白晨总结的题目都是互联网大厂必考的二叉树题目,也是思想非常经典的题目,第一次做可能想不到这样的思路,但是当见得多了就自然而然有这样的思路了......

白晨的博客 854

cosmos-curate工业级视频数据预处理引擎/终端用户指南( end-user-guide)

摘要:Cosmos-Curate是一个用于视频和自动驾驶数据处理的开源工具,提供从本地到集群的完整部署方案。文档针对三类用户:终端用户(配置运行现有管道)、开发者(修改/创建管道)和贡献者(改进代码库)。核心功能包括容器化设计(Docker+NVIDIA工具链)、多平台支持(本地/Slurm/云)、集成HuggingFace/NGC模型,以及可扩展的管道架构。使用需满足硬件(如Ampere架构GPU)和软件(Ubuntu22.04+Python3.10)要求,通过CLI工具构建镜像、下载模型并运行示例管道(

qq_45053161的博客 1204

在Pycharm中配置Pyqt5工具(2023年新版教程)

在Pycharm中配置Pyqt5相关的三个工具:QtDesigner、PyUIC、PYRCC

网络技术和Python 2万+

C++进阶:3_二叉树进阶

因此本节借二叉树搜索树,对二叉树部分进行收尾总结。

Open__Ai的博客 1575

完整功能-《网络安全创新实践》:设计并实现一种基于Npcap的网络嗅探器(直接能运行cpp的MFC代码+实验报告)

《网络安全创新实践》:设计并实现一种基于Npcap的网络嗅探器。(直接能跑的MFC)监听所有数据包,以及监听指定IP地址的数据包;(2)能够显示完整的IP数据包首部信息,例如:版本、首部长度、数据包长度、数据包类型(协议字段)、TTL、源IP地址、目的IP地址等;(3)能够显示完整的TCP报文段信息,例如:源端口、目的端口、序号、确认号、数据部分等;(4)能够自动检测SQL注入攻击等Web攻击行为;(5)能够将监听到的数据包信息保存到文件中,以及从文件中读取并显示数据包信息;(6)具有图形化操作界面。

weixin_46531010的博客 661

C++: 二叉树进阶面试题

一些面试中可能会遇到的二叉树的进阶题目

酷酷学!!!的博客 1949

OpenClaw实战-行政与HR必备:AI驱动的办公自动化

智能会议纪要自动生成会议时间智能协调自动提醒和跟进简历智能筛选和匹配度分析面试安排自动化入职办理流程化通知公告一键发布发票识别和报销辅助资产管理数字化让AI处理繁杂的事务性工作,让您有更多时间专注于更有价值的战略和管理任务。

gaoxiang_120的专栏 220

Linux ARM平台开发系列讲解(调试篇) 1.6.4 NVIDIA AGX Xavier以太网MAC TO MAC模式

内核发展了那么多年,早已经将这种场景集成到了内核里,具体添加方式如下,本次针对。具体详细描述,可参考本专栏的网络篇和交换机篇,这里就简单的提一句,想要使用。速率和双工状态固定死,使其和交换机的模式一模一样,双方就可以建立通信了。2. MAC TO MAC原理。3. 开启无PHY模式进入内核。模式,本章节记录调试过程。模式,简单来说就是字面意思,以太网部分需要与交换机。,其他芯片也是一样的。修改设备树文件,将与。

DSMGUOGUO的博客 1531

二叉树进阶 - 下

学习二叉搜索树的一些原因:1. map和set特性需要先铺垫二叉搜索树,而二叉搜索树也是一种树形结构2.二叉搜索树的特性了解,有助于更好的理解map和set的特性。

m0_62229058的博客 218

Python爬虫实战:利用Scrapy+Playwright高效爬取TED演讲数据

在当今信息爆炸的时代,TED演讲作为全球知名的思想传播平台,汇聚了各领域顶尖人才的精彩分享。对于数据分析师、研究人员或内容创作者来说,获取TED演讲的完整数据集具有重要价值。本文将详细介绍如何使用Python中最先进的爬虫技术组合——Scrapy框架配合Playwright浏览器自动化工具,高效爬取TED演讲的完整数据。传统爬虫技术在处理现代动态网页时面临诸多挑战,而本文将展示如何利用最新工具解决这些问题。

2201_76125261的博客 207

【二叉树进阶】--- 根据二叉树创建字符串

假设有颗满二叉树,当根结点入队时顺便此时他的左右结点也顺便入队,此时队列中结点的个数就是2,此时这两个结点对应层数就是2;类似地当第二层的两结点一父带两娃时,此时入队了4个结点,这一层也是有4个结点。1.了解思路一后,我们发现思路一维护每个结点的层数比较麻烦,我们能否另寻他路,一口气把每层的结点push进数组里?4.为了效率,我们可以先计算总的高度,提前开好二维数组所需要的层数;.我们按上面流程得到的是从上到下的层序遍历,从下往上我们可以使用。的思想(即一个父亲入队的时候,它的两个孩子也一起入队)实现。

2301_79448270的博客 1717

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

【C++】二叉树的进阶

一文带你由浅入深掌握二叉树

m0_74808907的博客 1949

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

【C++】二叉树进阶(二叉搜索树)

这篇文章详细介绍了二叉搜索树(BST)的基本概念、操作、代码实现以及应用。首先,介绍了BST的定义和核心操作,包括查找、插入和删除,并提供了非递归和递归两种实现方式。随后,通过具体的代码示例,展示了BST的节点设置、类框架构建以及查找、插入、中序遍历和删除函数的完整实现。此外,还探讨了BST在实际问题中的应用和性能分析。进阶部分则包含了一系列与二叉树相关的OJ题目,涵盖了从根据遍历序列构造二叉树,到层序遍历、公共祖先查找、BST与双向链表转换等多种场景,希望能够帮助读者深入理解二叉树的结构和应用。

是阿建吖! 2117

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

二叉树扩展-二叉树进阶算法题

val = val;T _val;

zc331的博客 785

数据结构二叉树进阶

开始前就可以判断是否有结点是祖先,然后构建函数判断是否在左边,而右边函数就可以不用写了,因为不是左就是右,得到两结点的方位值(true为左,false为右),就可以用来走判断了,如果是一左一右那么就返回这个结点,反着也是,接下来是同左边,就要递归了,因为要用一左一右和其中一个为祖先来找,同右也是,只是用来移动位置来触发一左一右和有一个为祖先的情况。q为4结点,先入35,然后6入,但是因为没有目标结点在6的左右子数就踢出去,到2,到7,而7也是跟6一样踢出去,就到4了找到并返回。

2302_80378107的博客 990

【C++】二叉树进阶

情况d:在它的右子树中寻找中序下的第一个结点(关键码最小),用它的值填补到被删除节点中,再来处理该结点的删除问题。1.2 二叉搜索树的特性了解,有助于更好的理解map和set的特性。情况b:删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点。情况c:删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点。1.若它的左子树不为空,则左子树上所有节点的值都小于根节点的值;2.若它的右子树不为空,则右子树上所有节点的值都大于根节点的值;b. 树不空,按二叉搜索树性质查找插入位置,插入新节点;

m0_46676283的博客 496

【C++】二叉树进阶面试题

根据二叉树创建字符串,最近公共祖先,二叉搜索树转化成排序双向链表,根据前序和中序构造二叉树,前中后序的非递归实现

关注学习C++领域,感谢陪伴,共同进步! 934

【C++进阶】二叉树进阶

二叉搜索树(BST)又称二叉排序树或二叉查找树

x_2023_713的博客 972

C++进阶——二叉树OJ题

本文总结了二叉树相关的7个经典算法问题及解法:1. 层序遍历(BFS)使用队列按层输出节点值;2. 最近公共祖先(LCA)两种解法:子树判断法和路径记录法;3. 二叉搜索树转双向链表通过中序遍历调整指针;4. 前序+中序序列重建二叉树利用前序定位根节点,中序分割左右子树;5-7. 三种非递归遍历(前序/中序/后序)均提供两种实现:统一标记法和优化栈操作法,其中后序遍历还通过反转前序结果实现。所有解法均给出C++代码实现,涵盖队列、栈、递归等核心数据结构应用。

博客 | 复习知识点 + 练习 + 最终的领悟 | 全力以赴 1419

C++进阶—二叉树进阶

问题:如果退化成单支树,二叉搜索树的性能就失去了。那能否进行改进,不论按照什么次序插入关键码,二叉搜索树的性能都能达到最优?对有n个结点的二叉搜索树,若每个元素查找的概率相等,则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数,即结点越深,则比较次数越多。插入和删除操作都必须先查找,查找效率代表了二叉搜索树中各个操作的性能。a、从根开始比较,查找,比根大则往右边走查找,比根小则往左边走查找。b、最多查找高度次,走到到空,还没找到,这个值不存在。b. 树不空,按二叉搜索树性质查找插入位置,插入新节点。

Awkwardx的博客 828

C++:二叉树进阶

一篇带你完全掌握二叉树进阶

Makise的博客 1179
上一篇: start&&queue(模拟实现及底层原理)
下一篇: C++特殊类设计
pythoncjavac++
博客等级 码龄5年 718粉丝 71原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

pythoncjavac++

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

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

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

打赏作者

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

抵扣说明:

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

余额充值