C++实现二叉排序树

已于 2024-04-14 17:40:54 修改
阅读量1.7k 收藏 50
点赞数 51
分类专栏： 数据结构 文章标签： c++ 数据结构
于 2024-04-13 22:20:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cctv1324/article/details/137725218
版权

二叉排序树

视频讲解请看王道考研
链接如下
【王道计算机考研 数据结构】 https://www.bilibili.com/video/BV1b7411N798/?p=75&share_source=copy_web&vd_source=734d9fe130776e8ae82b2b5371a5f5b8

还有一个它动画做的不错，b站 蓝不过海呀
链接如下
【二叉搜索树(二叉排序树)(二叉查找树)】 https://www.bilibili.com/video/BV1uK421x7JJ/?share_source=copy_web&vd_source=734d9fe130776e8ae82b2b5371a5f5b8

主要是学习数据结构，真的做什么请直接使用map、set等容器

二叉排序树定义和性质

定义：
二叉排序树，又称二叉查找树(BST，Binary Search Tree)
一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树:
左子树上所有结点的关键字均小于根结点的关键字.
右子树上所有结点的关键字均大于根结点的关键字。
左子树和右子树又各是一棵二又排序树

性质：
左子树结点值< 根结点值 < 右子树结点值
进行中序遍历（左根右），可以得到一个递增的有序序列

定义二叉排序树这一结构时，直接继承之前的二叉树
然后这里说一下，按理说排序是根据关键值key排序，我这里直接用data当关键值了，注意一下，我懒得改了

//二叉排序树
template<class ElemType>
class BST :public BiTree<ElemType>
{
	//省略一些代码……
}

二叉排序树的查找

我这里先说查找，再说插入和删除，因为插入和删除涉及到查找

二叉排序树中：左子树结点值< 根结点值< 右子树结点值，因此可以利用循环解决，不必使用递归
若树非空，目标值与根结点的值比较:
若相等，则查找成功;
若小于根结点，则在左子树上查找，否则在右子树上查找。
查找成功，返回结点指针;查找失败返回NULL

相对简单，直接上代码

template<class ElemType>
class BST :public BiTree<ElemType>
{
	//省略一些代码……
	/*功能：在本二叉排序树中查找元素e
	* 输入：
	* e：要查找的元素
	* 返回：
	* 成功：元素的结点的指针
	* 失败：NULL
	* 其它：
	*/
public:
	BTNode<ElemType>* Search(ElemType e);
}

template<class ElemType>
BTNode<ElemType>* BST<ElemType>::Search(ElemType e)
{
	BTNode<ElemType>* t = this->root;
	//若等于此结点值（说明找到），或者是空结点（说明找完了也没有找到），则结束循环
	//也就是说循环条件是，不等于此结点值并且不是空结点
	while (t != NULL && e != t->data)//好像t!=NULL要写在前面，这样t==NULL的时候就不继续往后了，否则NULL的时候还会去访问t->data
	{
		if (e < t->data)//小于，则在左子树中查找
			t = t->lchild;
		else//大于，则在左子树中查找
			t = t->rchild;
	}
	return t;
}

在后面的插入和删除中，我们需要找到“查找路径上的上一个结点”，以便于处理
将普通的查找简单改造即可实现

template<class ElemType>
class BST :public BiTree<ElemType>
{
//省略一些代码……
protected:
	/*功能：在本二叉排序树中查找元素e，并得到查找路径上的“上一个结点”
	* 输入：
	* e：要查找的元素
	* f：用来指向"上一个结点"的指针
	* 返回：
	* 成功：e元素的结点的指针
	* 失败：NULL
	* 其它：如果最后f为NULL，说明二叉树为空，或者根节点为要找的
	* 插入的时候要用
	*/
	BTNode<ElemType>* Search_f(ElemType e, BTNode<ElemType>*& f);
}

template<class ElemType>
BTNode<ElemType>* BST<ElemType>::Search_f(ElemType e, BTNode<ElemType>*& f)
{
	BTNode<ElemType>* t = this->root;
	f = NULL;
	//若等于此结点值（说明找到），或者是空结点（说明找完了也没有找到），则结束循环
	//也就是说循环条件是，不等于此结点值并且不是空结点
	while (t != NULL && e != t->data)//好像t!=NULL要写在前面，这样t==NULL的时候就不继续往后了，否则NULL的时候还会去访问t->data
	{
		f = t;//赋值f，使其为“上一个”
		if (e < t->data)//小于，则在左子树中查找
			t = t->lchild;
		else//大于，则在左子树中查找
			t = t->rchild;
	}
	return t;
}

二叉排序树的插入

若原二叉排序树为空，则直接插入结点;

否则，

​ 若关键字k小于此结点值，则插入到此结点左子树
​ 若关键字k大于此结点值，则插入到此结点右子树
若关键字k等于此结点值，原本就存在，插入失败

基本就是查找的要求，只是要得到“查找路径上的“上一个”结点，也就是我前面在查找中提到的函数Search_f

template<class ElemType>
class BST :public BiTree<ElemType>
{
//省略一些代码……
public:
	/*功能：在本二叉排序树中插入元素e
	* 输入：
	* e：要插入的元素
	* 返回：
	* 成功：true
	* 失败：false（原本存在元素e）
	* 其它：
	*/
	bool Insert(ElemType e);
}

template<class ElemType>
bool BST<ElemType>::Insert(ElemType e)
{	
	if (this->root == NULL)//如果没有根结点，直接申请
	{
		this->root =new BTNode<ElemType>(e);
		return true;
	}

	BTNode<ElemType>* t = NULL;
	BTNode<ElemType>* p = NULL;//指向查找路径上访问的最后一个结点（目标的父亲）
	//看看原本有没有，并确定插入位置
	t = this->Search_f(e, p);

	if (t != NULL)//原本存在元素e
		return false;
	else
	{
		BTNode<ElemType>* s = new BTNode<ElemType>(e);
		if (e < p->data)			
		{
			p->lchild = s;
			s->father = p;
		}
		else
		{
			p->rchild = s;
			s->father = p;
		}
		return true;
	}
}

后面我们会需要，插入完了之后不光知道是否插入成功，还要得到插入的结点指针
简单改造上面的代码

template<class ElemType>
class BST :public BiTree<ElemType>
{
//省略一些代码……
protected:
	/*功能：在本二叉排序树中插入元素e
	* 输入：
	* e：要插入的元素
	* 返回：
	* 成功：形成的结点的指针
	* 失败：NULL（原本存在元素e）
	* 其它：
	* 子类平衡二叉树中使用
	*/
	BTNode<ElemType>* Insert_p(ElemType e);
}
template<class ElemType>
BTNode<ElemType>* BST<ElemType>::Insert_p(ElemType e)
{
	if (this->root == NULL)//如果没有根结点，直接申请
	{
		this->root = new BTNode<ElemType>(e);
		return this->root;
	}

	BTNode<ElemType>* t = NULL;
	BTNode<ElemType>* p = NULL;//指向查找路径上访问的最后一个结点（目标的父亲）
	//看看原本有没有，并确定插入位置
	t = this->Search_f(e, p);

	if (t != NULL)//原本存在元素e
		return NULL;
	else
	{
		BTNode<ElemType>* s = new BTNode<ElemType>(e);
		if (e < p->data)
		{
			p->lchild = s;
			s->father = p;
		}
		else
		{
			p->rchild = s;
			s->father = p;
		}
		return s;
	}
}

二叉排序树的删除

现在开始，问题变得有点复杂了
先搜索找到目标结点:(被删除结点记为target)

if (this->root == NULL)//本来啥都没有直接返回false
	return false;

//先尝试找到e的结点
BTNode<ElemType>* target = this->Search(e);
//原本就不存在元素e，直接返回错
if (target == NULL)	return false;

然后

1、若被删除结点是叶结点

直接删除，不会破坏二叉排序树的性质

二叉排序树删除情况1
注意：

如果删除的时普通叶子节点

​ 看它是他爹的左孩子还是右孩子，然后处理他爹的对应指针，再删除它

如果删除的是根节点

​ 别忘了把类的root指针置为空

二叉排序树删除叶子结点
代码如下

//1、若被删除结点是叶结点，则直接删除
if (target->lchild == NULL && target->rchild == NULL)
{
	if (target->father == NULL)//要删除的target是根结点，而且是叶子节点，就是只有target一个
	{
		this->root = NULL;//处理一下根的指针
	}
	else//target不是根结点，如果是根节点直接删除就行
	{
		if (target->father->rchild == target)//别忘了处理父节点
			target->father->rchild = NULL;
		else
			target->father->lchild = NULL;
	}	
	delete target;
	return true;
}

2、若被删除结点只有一棵左子树或右子树

让target的子树成为target父结点的子树，替代target的位置。

二叉排序树删除情况2

同样的，请注意如果删除的就是根节点这种特殊情况

二叉排序树删除情况2注意
代码如下

//2、若结点target只有一棵左子树或右子树，则让target的子树成为target父结点的子树，替代target的位置。
//只有一棵左子树
else if (target->lchild != NULL && target->rchild == NULL)
{
	if (target->father == NULL)//target本身是根结点
	{
		this->root = target->lchild;
		target->lchild->father = NULL;
	}
	else
	{
		//如果目标是他爹的左孩子
		if (target == target->father->lchild)
		{
			target->father->lchild = target->lchild;
			target->lchild->father = target->father;
		}
		else//如果目标是他爹的右孩子
		{
			target->father->rchild = target->lchild;
			target->lchild->father = target->father;
		}			
	}		
	delete target;
	return true;
}
//只有一棵右子树
else if (target->lchild == NULL && target->rchild != NULL)
{
	if (target->father == NULL)//target本身是根结点
	{
		this->root = target->rchild;
		target->rchild->father = NULL;
	}
	else
	{
		//如果目标是他爹的左孩子
		if (target == target->father->lchild)
		{
			target->father->lchild = target->rchild;
			target->rchild->father = target->father;
		}
		else//如果目标是他爹的右孩子
		{
			target->father->rchild = target->rchild;
			target->rchild->father = target->father;
		}
	}
	delete target;
	return true;
}

3、若被删除结点有左、右两棵子树

令target的直接后继 (或直接前驱)替代target，然后从二叉排序树中删去这个直接后继 (或直接前驱)，

​ 这样就转换成了第一或第二种情况。

​ target的直接后继，就是target的右子树的中序遍历第一个，也就是target的右子树一直“往左走”

​ 该节点一定没有左子树

​ target的直接前驱，就是target的左子树的中序遍历最后一个，也就是target的左子树一直“往右走”

​ 该节点一定没有右子树
二叉排序树删除情况3

注意，这时target结点不会被删除，它的直接后继（或前驱）才会被删除

我的代码中使用的是直接后继

先找到target的直接后继（记为successor)，就是在target的右子树中一直“往左走”，然后把successor的数据付给target

BTNode<ElemType>* successor = NULL;//目标的直接后继
//在target的右子树中一直“往左走”
successor = target->rchild;
while (successor->lchild != NULL)//一直“往左走”
{
	successor = successor->lchild;
}

//令target的直接后继替代target
target->data = successor->data;

3.1直接后继为叶子结点

注意，直接后继可能是他爹的右孩子，这时，target右子树只有successor这一个结点，请分别处理，或删除前判断

二叉排序树删除3.1

if (successor->lchild==NULL && successor->rchild==NULL)//直接后继为叶子结点
{
	if (successor->father == target)//特殊情况，目标右子树就一个，见后面注释2
	{
		target->rchild = NULL;
	}
	else
	{
		//删去这个直接后继
		successor->father->lchild = NULL;//直接后继只可能是它爹的左孩子
	}			
}

3.2直接后继有右子树

同样的，直接后继可能是他爹的右孩子，这时，情况如图中所示，请分别处理，或删除前判断
二叉排序树删除3.2
代码如下

else//直接后继只有右子树
{
	if (successor->father == target)//特殊情况，目标右子树根节点就是后继,见后面注释4
	{
		target->rchild = successor->rchild;
		successor->rchild->father = target;
	}
	else
	{
		//删去这个直接后继
		successor->father->lchild = successor->rchild;//见后面注释3
		successor->rchild->father = successor->father;
	}
	
}

删除的完整代码

template<class ElemType>
class BST :public BiTree<ElemType>
{
public:
	/*功能：在本二叉排序树中删除元素e
	* 输入：
	* e：要删除的元素
	* 返回：
	* true：成功
	* false：失败（原本就不存在元素e）
	* 其它：会保证排序树结构不被破坏
	*/
	bool Delete(ElemType e);
}
template<class ElemType>
bool BST<ElemType>::Delete(ElemType e)
{
	if (this->root == NULL)//本来啥都没有直接返回false
		return false;

	//先尝试找到e的结点
	BTNode<ElemType>* target = this->Search(e);
	//原本就不存在元素e，直接返回错
	if (target == NULL)	return false;

	//1、若被删除结点是叶结点，则直接删除
	if (target->lchild == NULL && target->rchild == NULL)
	{
		if (target->father == NULL)//要删除的target是根结点，而且是叶子节点，就是只有target一个
		{
			this->root = NULL;//处理一下根的指针
		}
		else//target不是根结点，如果是根节点直接删除就行
		{
			if (target->father->rchild == target)//别忘了处理父节点
				target->father->rchild = NULL;
			else
				target->father->lchild = NULL;
		}	
		delete target;
		return true;
	}

	//2、若结点target只有一棵左子树或右子树，则让target的子树成为target父结点的子树，替代target的位置。
	//只有一棵左子树
	else if (target->lchild != NULL && target->rchild == NULL)
	{
		if (target->father == NULL)//target本身是根结点，见下面注释1
		{
			this->root = target->lchild;
			target->lchild->father = NULL;
		}
		else
		{
			//如果目标是他爹的左孩子
			if (target == target->father->lchild)
			{
				target->father->lchild = target->lchild;
				target->lchild->father = target->father;
			}
			else//如果目标是他爹的右孩子
			{
				target->father->rchild = target->lchild;
				target->lchild->father = target->father;
			}			
		}		
		delete target;
		return true;
	}
	//只有一棵右子树
	else if (target->lchild == NULL && target->rchild != NULL)
	{
		if (target->father == NULL)//target本身是根结点，见下面注释1
		{
			this->root = target->rchild;
			target->rchild->father = NULL;
		}
		else
		{
			//如果目标是他爹的左孩子
			if (target == target->father->lchild)
			{
				target->father->lchild = target->rchild;
				target->rchild->father = target->father;
			}
			else//如果目标是他爹的右孩子
			{
				target->father->rchild = target->rchild;
				target->rchild->father = target->father;
			}
		}
		delete target;
		return true;
	}
	
	/*3、若结点target有左、右两棵子树，
	* 则令target的直接后继(或直接前驱)替代target，然后从二叉排序树中删去这个直接后继(或直接前驱)，
	* 这样就转换成了第一或第二种情况。
	* 我这里使用直接后继，也就是target的右子树的中序遍历第一个（在target的右子树中一直“往左走”）
	* 该节点一定没有左子树
	*/
	else
	{
		BTNode<ElemType>* successor = NULL;//目标的直接后继
		//在target的右子树中一直“往左走”
		successor = target->rchild;
		while (successor->lchild != NULL)//一直“往左走”
		{
			successor = successor->lchild;
		}

		//令target的直接后继替代target
		target->data = successor->data;

		if (successor->lchild==NULL && successor->rchild==NULL)//直接后继为叶子结点
		{
			if (successor->father == target)//特殊情况，目标右子树就一个，见后面注释2
			{
				target->rchild = NULL;
			}
			else
			{
				//处理相关指针
				successor->father->lchild = NULL;//直接后继只可能是它爹的左孩子
			}			
		}
		else//直接后继只有右子树
		{
			if (successor->father == target)//特殊情况，目标右子树根节点就是后继,见后面注释4
			{
				target->rchild = successor->rchild;
				successor->rchild->father = target;
			}
			else
			{
				//处理相关指针
				successor->father->lchild = successor->rchild;//见后面注释3
				successor->rchild->father = successor->father;
			}
			
		}	
		delete successor;//删去这个直接后继
		return true;
	}
}

类似的，后面会需要，删除后，知道真实删掉的结点的父结点，以及删掉的是左孩子还是右孩子
对上面的普通删除简单改造一下

template<class ElemType>
class BST :public BiTree<ElemType>
{
public:
	/*功能：在本二叉排序树中删除元素e
	* 输入：
	* e：要删除的元素
	* realDeleteFather：记录真实删掉的结点的父亲的指针
	* isLeft：记录删掉的是左孩子（true）还是右孩子（false）
	* 返回：
	* true：成功
	* false：失败（原本就不存在元素e）
	* 其它：
	* 会保证排序树结构不被破坏
	* 子类平衡二叉树中使用
	* 如果返回true，但realDeleteFather为NULL，说明删除的是根节点
	*/
	bool Delete_p(ElemType e, BTNode<ElemType>*& realDeleteFather, bool& isLeft);
}

template<class ElemType>
bool BST<ElemType>::Delete_p(ElemType e, BTNode<ElemType>*& realDeleteFather, bool& isLeft)
{
	realDeleteFather = NULL;
	isLeft = false;

	if (this->root == NULL)//本来啥都没有直接返回false
		return false;

	//先尝试找到e的结点
	BTNode<ElemType>* target = this->Search(e);
	//原本就不存在元素e，直接返回错
	if (target == NULL)	return false;

	//1、若被删除结点是叶结点，则直接删除
	if (target->lchild == NULL && target->rchild == NULL)
	{
		if (target->father == NULL)//要删除的target是根结点，而且是叶子节点，就是只有target一个
		{
			this->root = NULL;//处理一下根的指针
		}
		else//target不是根结点，如果是根节点直接删除就行
		{
			if (target->father->rchild == target)//别忘了处理父节点
			{
				isLeft = false;
				target->father->rchild = NULL;
			}				
			else
			{
				isLeft = true;
				target->father->lchild = NULL;
			}				
		}
		realDeleteFather = target->father;
		delete target;//找到真实删除的它爹
		return true;
	}

	//2、若结点target只有一棵左子树或右子树，则让target的子树成为target父结点的子树，替代target的位置。
	
	else if (target->lchild != NULL && target->rchild == NULL)//只有一棵左子树
	{
		if (target->father == NULL)//target本身是根结点，见下面注释1
		{
			this->root = target->lchild;
			target->lchild->father = NULL;
		}
		else
		{
			
			realDeleteFather = target->father;//找到真实删除的它爹
			//如果目标是他爹的左孩子
			if (target == target->father->lchild)
			{
				isLeft = true;
				target->father->lchild = target->lchild;
				target->lchild->father = target->father;
			}
			else//如果目标是他爹的右孩子
			{
				isLeft = false;
				target->father->rchild = target->lchild;
				target->lchild->father = target->father;
			}
		}		
		delete target;
		return true;
	}
	//只有一棵右子树
	else if (target->lchild == NULL && target->rchild != NULL)
	{
		if (target->father == NULL)//target本身是根结点，见下面注释1
		{
			this->root = target->rchild;
			target->rchild->father = NULL;
		}
		else
		{			
			realDeleteFather = target->father;//找到真实删除的它爹

			//如果目标是他爹的左孩子
			if (target == target->father->lchild)
			{
				isLeft = true;
				target->father->lchild = target->rchild;
				target->rchild->father = target->father;
			}
			else//如果目标是他爹的右孩子
			{
				isLeft = false;
				target->father->rchild = target->rchild;
				target->rchild->father = target->father;
			}
		}
		delete target;
		return true;
	}

	/*3、若结点target有左、右两棵子树，
	* 则令target的直接后继(或直接前驱)替代target，然后从二叉排序树中删去这个直接后继(或直接前驱)，
	* 这样就转换成了第一或第二种情况。
	* 我这里使用直接后继，也就是target的右子树的中序遍历第一个（在target的右子树中一直“往左走”）
	* 该节点一定没有左子树
	*/
	else
	{
		BTNode<ElemType>* successor = NULL;//目标的直接后继
		
		//在target的右子树中一直“往左走”
		successor = target->rchild;
		while (successor->lchild != NULL)//一直“往左走”
		{
			successor = successor->lchild;
		}

		//令target的直接后继替代target
		target->data = successor->data;

		if (successor->lchild == NULL && successor->rchild == NULL)//情况1，直接后继为叶子结点
		{
			if (successor->father == target)//特殊情况，目标右子树就一个，见后面注释2
			{
				isLeft = false;
				realDeleteFather = target;

				target->rchild = NULL;
			}
			else
			{
				isLeft = true;
				realDeleteFather = successor->father;

				//删去这个直接后继
				successor->father->lchild = NULL;//直接后继只可能是它爹的左子树
			}
		}
		else//情况2，直接后继有右子树（直接后继的左子树必为空）
		{
			isLeft = true;
			realDeleteFather = successor->father;

			if (successor->father == target)//特殊情况，目标右子树根节点就是后继,见后面注释4
			{
				target->rchild = successor->rchild;
				successor->rchild->father = target;
			}
			else
			{
				//删去这个直接后继
				successor->father->lchild = successor->rchild;//见后面注释3
				successor->rchild->father = successor->father;
			}
		}
		delete successor;
		return true;
	}
}
cctv1324
关注
  • 51
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉排序树C++实现
LHJ884的专栏
07-28 3296
学习了算法导论12章关于二叉排序树的内容，自己利用C++实现了二叉排序树的封装。（删除暂时没有实现，后续再补吧） 有什么不足之处希望不吝赐教！头文件，二叉排序树类的定义（注释比较清楚，就不再赘述了）：#pragma once#include<iostream> using namespace std;//树节点定义，包含父节点指针（便于回溯前驱与后继） typedef struct Node {
二叉排序树的创建，插入和删除（C++完整代码）
qq_48071481的博客
10-18 7842
一、二叉排序树（二叉查找树）的概念 （1）若左子树非空，则左子树上所有结点的值均小于根节点的值 （2）若右子树非空，则右子树上所有结点的值均大于根节点的值 （3）左右子树分别也是一棵二叉排序树 tip：可以是一棵空树 二、二叉排序树的判别 （1）因为二叉排序树的中序遍历是一个有序递增序列，可以对已经建立的二叉树进行中序遍历，如果满足则判断是 三、二叉排序树的创建（creat、insert） 树结点的结构体： struct tree{ int data; struc...
[c++]二叉排序树(Binary Sort Tree)详解
EQUINOX1的博客
07-24 952
二叉树是一种很基础的数据结构，而二叉排序树则是一种插入，删除，查找效率都不错的一种数据结构。二叉排序树的特性就是左子树键值小于根，右子树键值大于根，所以二叉排序树就天然的具有查找功能，有时二叉排序树又叫二叉搜索树或者二叉查找树。
C++——二叉树排序树
博主qq1077644249
02-18 1259
1 二叉搜索树概念 2 二叉搜索树操作与模拟实现 2.1 二叉搜索树的查找 非递归版本 递归版本 2.2 二叉搜索树的插入 非递归版本 递归版本 2.3 二叉搜索树的删除 非递归版本 递归版本 3 二叉搜索树的应用（K模型、KV模型） 4 二叉搜索树的性能分析
数据结构之二叉排序树（C++实现）
cheng_jack_li的博客
09-11 3192
二叉树是数据结构中的一个非常非常重要的板块，俗话说不到长城非好汉，那么不会二叉树就不算了解数据结构。什么是二叉树，在之前我们了解了链表，但是我们在使用的时候就会发现一个问题就是，链表的每一个节点只能在同一方向指向一个节点，也就是不能分叉，可是在实际应用中必须要有分叉的存在，怎么办呢，前辈们就提出了二叉排序树的概念。通过前边的学习我们了解了单链表有两个区域，就是数据域和指针域，双向链表为了实现反向遍历多加了一个区域叫前驱指针域，所以双向链表就有了三个域，前驱指针域，后继指针域和数据域，同理我们就能猜出来，二叉
数据结构C++——二叉排序树
qq_54162207的博客
06-13 4318
数据结构C++——二叉排序树 文章目录数据结构C++——二叉排序树一、前言二、二叉排序树的相关概念三、树表的查找①二叉排序树的存储表示②二叉排序树的递归查找③二叉排序树的插入④二叉排序树的创建⑤二叉排序树的删除四、完整测试代码五、总结 一、前言 二叉排序树用到了二叉树中序遍历的知识，以及树的相关操作部分的知识，由于笔者在之前的文章中已介绍过树的知识，在此不再过多赘述，对此部分不太了解的读者欢迎移步此文章，共同学习！： 数据结构C++——二叉树的遍历（递归和非递归）及一些简单操作 二、二叉排序树的相关概念 （
二叉排序树的C++实现
qwas12345qwas的博客
09-04 393
二叉排序树的C++简单实现
C++建立二叉排序树
Akeron的博客
03-08 1303
#include<bits/stdc++.h>using namespace std;class Node{ public: Node* left; Node* right; int content; Node(){ left=NULL; right=NULL; }
C++实现 二叉排序树
06-08
二叉排序树（Binary Search Tree，BST），也称为二叉查找树或有序二叉树，是一种自平衡的...在编程实践中，C++ 提供了丰富的库支持，包括STL中的`<map>`和`<set>`容器，它们内部就采用了类似二叉排序树的数据结构。
C++二叉排序树的创建、插入、删除、查找
09-30
二叉排序树，用前序遍历是就是增序排列，的创建删、插入、查询
c++实现二叉查找树示例
09-04
在C++中实现二叉查找树，我们需要定义两个类，一个是数据节点`dNode`，另一个是二叉树节点`bstNode`，以及一个用于操作二叉查找树的类`bst`。 首先，数据节点`dNode`包含了三个成员变量：`name`表示姓名，`age`表示...
适合小白学习的C++二叉排序树.doc
最新发布
05-29
二叉排序树 适合小白学习的C++二叉排序树.doc 适合小白学习的C++二叉排序树.doc 适合小白学习的C++二叉排序树.doc 适合小白学习的C++二叉排序树.doc 适合小白学习的C++二叉排序树.doc
用C++实现的二叉排序树
05-05
用C++实现的二叉排序树，一种简单的数据结构。
C++实现树 - 03 二叉排序树
Newin2020的博客
05-07 2382
写在前面： 上一讲我们介绍了二叉树的代码实现以及其遍历方法，这一讲我们来看一看进阶版的二叉树 —— 二叉排序树。 性质 二叉排序树它和普通的二叉树不同： （1）如果根结点的左子树不为空，那么它左子树的所有结点的值都小于根结点。 （2）如果根结点的右子树不为空，那么它右子树的所有结点的值都大于根结点。 （3）根结点的左子树和右子树同样遵循上面两条性质。 根据性质我们可以知道，这颗排序二叉树的实现必然逃不了递归了，接下来我们来看看排序二叉树的代码是如何实现的。 二叉排序树的构建及插入 假设我们要构建起下面这.
数据结构与算法--二叉排序树（C++实现）
热门推荐
DeeperBlue的博客
04-16 1万+
二叉树也是常用的数据结构。一棵二叉树由根节点（可以为空）和左右子树（也是二叉树）构成。通常情况下，二叉树的效率比线性链表高，因为二叉树上的查询、插入等操作即相当于二分法操作。本文用C++实现二叉树的算法，是C++、数据结构及算法学习的一个小练习。供大家参考。
C++数据结构：二叉排序树
qq_45303986的博客
10-26 1143
按照以上思路写的代码，可以用查找和判段左右孩子函数来精简该代码。
二叉排序树和平衡二叉树算法
08-28
二叉排序树（Binary Search Tree，简称BST）是一种特殊的二叉树，其中每个节点的左子树中的所有键值小于节点的键值，右子树中的所有键值大于节点的键值。这个特性使得二叉排序树可以快速地进行搜索、插入和删除操作。 平衡二叉树（Balanced Binary Tree）是一种特殊的二叉排序树，它的左子树和右子树的高度之差的绝对值小于等于1。这个特性可以使得平衡二叉树的高度保持在一个较小的范围内，从而提高了搜索、插入和删除操作的效率。 实现二叉排序树的算法通常包括插入、搜索和删除操作。当需要插入一个新的节点时，我们首先搜索树中的位置，然后将新节点插入到正确的位置上，保持二叉排序树的特性。搜索操作通过比较节点的键值和目标值来决定向左子树还是右子树搜索。删除操作需要考虑多种情况，包括删除的节点是叶子节点、删除的节点只有一个子节点、删除的节点有两个子节点等。具体的算法实现可以根据需要进行调整和优化。 实现平衡二叉树的算法通常包括插入、搜索和删除操作，同时还需要进行平衡因子的计算和树的调整。在插入过程中，我们首先按照二叉排序树的规则插入新节点，然后计算每个节点的平衡因子，根据平衡因子的大小来进行树的旋转操作，以保持树的平衡性。具体的算法实现可以根据不同的平衡因子定义和旋转规则进行调整。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [二叉排序树、二叉平衡树算法](https://blog.csdn.net/shenwansan_gz/article/details/41516127)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [二叉排序树和二叉平衡树](https://blog.csdn.net/weixin_43829058/article/details/126978715)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

cctv1324

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

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

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

打赏作者

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

抵扣说明：

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

余额充值