二叉排序树 My_Bst && 二叉平衡树

已于 2023-04-23 18:24:17 修改
阅读量53 收藏
点赞数
文章标签： 数据结构
于 2023-04-18 00:37:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52343363/article/details/130212162
版权 
#include<iostream>
#include<assert.h>
#include<vector>

using namespace std;

template<class Type>
class BST;

template<class Type>
class BSTNode
{
	friend class BST<Type>;
public:
	BSTNode(Type d = Type(), BSTNode<Type>* left = nullptr, BSTNode<Type>* right = nullptr)
		:data(d), leftChild(left), rightChild(right)
	{}
	~BSTNode()
	{}
private:
	Type data;
	BSTNode<Type>* leftChild;
	BSTNode<Type>* rightChild;
};

template<class Type>
class BST
{
public:
	BST() :root(nullptr)
	{}
	~BST()
	{
		Destroy();
	}
public:
	BSTNode<Type>* Find(const Type& key)const
	{
		return Find(root, key);
	}
	bool Insert(const Type& v)
	{
		return Insert(root, v);
	}
	bool Remove(const Type& key)
	{
		return Remove(root, key);
	}
	Type Min()const
	{
		return Min(root);
	}
	Type Max()const
	{
		return Max(root);
	}
	void SortPrint()const
	{
		SortPrint(root);
	}
	void Destroy()
	{
		Destroy(root);
	}
protected:
	BSTNode<Type>* Find(BSTNode<Type>* t, const Type& key)const
	{
		//空树或者传入的根节点就是我们要找的节点,返回节点
		if (t == nullptr || t->data == key)
			return t;
		//如果要找的data小于当前的节点  则在左树进行查找
		if (key < t->data)
			return Find(t->leftChild, key);
		else //大于则在右树寻找
			return Find(t->rightChild, key);
	}
	void SortPrint(BSTNode<Type>* t)const
	{
		if (t != nullptr)
		{
			//根据二叉排序树特性中序遍历后得到便是由小到的节点
			SortPrint(t->leftChild);
			cout << t->data << " ";
			SortPrint(t->rightChild);
		}
	}
	Type Min(BSTNode<Type>* t)const
	{
		//二叉搜索树最左边的节点是最小值
		assert(t != nullptr);
		while (t->leftChild != nullptr)
			t = t->leftChild;
		return t->data;
	}
	Type Max(BSTNode<Type>* t)const
	{
		//二叉搜索树最右边的节点是最大值
		assert(t != nullptr);
		while (t->rightChild != nullptr)
			t = t->rightChild;
		return t->data;
	}
	bool Insert(BSTNode<Type>*& t, const Type& v)
	{
		//First 查找插入位置
		//我们另一个先驱节点指针以记录父的位置,因为你如果用t一直跑，跑到最后为空了就不知道往哪里插入了
		BSTNode<Type>* p = t, * pre = nullptr;

		while (p != nullptr)
		{
			if (v == p->data)
				return false;

			pre = p;

			if (v < p->data)
				p = p->leftChild;
			else
				p = p->rightChild;
		}
		//生成插入节点
		p = new BSTNode<Type>(v);
		//判断传入的是否是空节点,是的话就将该节点给root

	  //判断是该插入pre  的左右子树
		if (pre == nullptr)
		{
			t = p;
			return true;
		}

		if (v < pre->data)
			pre->leftChild = p;
		else
			pre->rightChild = p;
		return true;
	}

	bool Remove(BSTNode<Type>*& t, const Type& key)
	{
		//如果根节点是空的直接返回false;
		if (t == nullptr)
			return false;
		if (key < t->data)
			Remove(t->leftChild, key);
		else if (key > t->data)
			Remove(t->rightChild, key);

		else
		{
			//找到 要删除的节点了
			if (t->leftChild != nullptr && t->rightChild != nullptr)
			{
				// 一，要删除的t节点 有左右子树 删除后要重新合成二叉树 
				//我们在待删除 节点的左子树找最大值覆盖t的值域 ，再将最大值的节点删除就完成了,删除与拼接 
				BSTNode<Type>* p = t->leftChild;
				while (p->rightChild != nullptr)
					p = p->rightChild;

				t->data = p->data;
				Remove(t->leftChild, p->data);
			}
			else
			{
				//删除的节点至少含有一个子树
				BSTNode<Type>* p = t;
				if (t->leftChild != nullptr)
					t = p->leftChild;
				else
					t = p->rightChild;
				delete p;
			}

			return true;
		}
	}

	void Destroy(BSTNode<Type>*& t)
	{
		if (t != nullptr)
		{
			Destroy(t->leftChild);
			Destroy(t->rightChild);
			delete t;
			t = nullptr;
		}
	}
private:
	BSTNode<Type>* root;
};

int main()
{
	vector<int> iv = { 8, 4, 9, 2, 1, 3, 15, 18, 14, 7 };

	//vector<int> iv = {16, 3, 7, 11, 9, 26, 18 ,14, 15};

	BST<int> bst;   //binary search tree

	for (int i = 0; i < iv.size(); ++i)
	{
		bst.Insert(iv[i]);
	}

	cout << "min value = " << bst.Min() << endl;
	cout << "max value = " << bst.Max() << endl;
	bst.SortPrint();
	cout << endl;

	BSTNode<int>* p = bst.Find(15);
	bst.Remove(3);
	bst.Remove(2);

	return 0;
}

#include<iostream>
#include<stack>
using namespace std;

template<class Type>
class AVL;

//定义AVL节点类型
template<class Type>
class AVLNode
{
	friend class AVL<Type>;
public:
	AVLNode(Type d=Type(),AVLNode<Type>*left=nullptr,AVLNode<Type>*right=nullptr)
		:data(d),leftChild(left),rightChild(right),bf(0)
	{}
	~AVLNode()
	{}
private:
	Type data;
	AVLNode *leftChild;
	AVLNode *rightChild;
	int bf;
};

template<class Type>
class AVL
{
public:
	AVL() : root(nullptr)
	{}
public:
	bool Insert(const Type &v)
	{
		return Insert(root, v);
	}
	bool Remove(const Type &key)
	{
		return Remove(root, key);
	}
protected:
	bool Insert(AVLNode<Type> *&t, const Type &v);
	bool Remove(AVLNode<Type> *&t, const Type &key);
protected:
	void RotateR(AVLNode<Type> *&ptr);
	void RotateL(AVLNode<Type> *&ptr);
	void RotateLR(AVLNode<Type> *&ptr);
	void RotateRL(AVLNode<Type> *&ptr);
private:
	AVLNode<Type> *root;
};

//
template<class Type>
void AVL<Type>::RotateR(AVLNode<Type> *&ptr)
{
	AVLNode<Type> *subR = ptr;
	ptr = subR->leftChild;
	subR->leftChild = ptr->rightChild;
	ptr->rightChild = subR;

	ptr->bf = subR->bf = 0;
}
template<class Type>
void AVL<Type>::RotateL(AVLNode<Type> *&ptr)
{
	AVLNode<Type> *subL = ptr;
	ptr = subL->rightChild;
	subL->rightChild = ptr->leftChild;
	ptr->leftChild = subL;

	ptr->bf = subL->bf = 0;
}

template<class Type>
void AVL<Type>::RotateLR(AVLNode<Type> *&ptr)
{
	AVLNode<Type> *subR = ptr;
	AVLNode<Type> *subL = ptr->leftChild;
	ptr = subL->rightChild;

	subL->rightChild = ptr->leftChild;
	ptr->leftChild = subL;
	//调整subL的bf
	if(ptr->bf <= 0)
		subL->bf = 0;
	else
		subL->bf = -1;

	subR->leftChild = ptr->rightChild;
	ptr->rightChild = subR;
	//调整subR的bf
	if(ptr->bf >= 0)
		subR->bf = 0;
	else
		subR->bf = 1;

	ptr->bf = 0;
}

template<class Type>
void AVL<Type>::RotateRL(AVLNode<Type> *&ptr)
{
	AVLNode<Type> *subL = ptr;
	AVLNode<Type> *subR = ptr->rightChild;
	ptr = subR->leftChild;

	subR->leftChild = ptr->rightChild;
	ptr->rightChild = subR;
	//调整subR的bf
	//subR->bf = ?
	if(ptr->bf >= 0)
		subR->bf = 0;
	else
		subR->bf = 1;

	subL->rightChild = ptr->leftChild;
	ptr->leftChild = subL;
	//调整subL的bf
	if(ptr->bf <= 0)
		subL->bf = 0;
	else
		subL->bf = -1;

	ptr->bf = 0;
}

//
template<class Type>
bool AVL<Type>::Insert(AVLNode<Type> *&t, const Type &v)
{
	//1 按照bst规则进行节点插入
	AVLNode<Type> *p = t, *pr = nullptr;

	stack<AVLNode<Type>*> st;

	while(p != nullptr)
	{
		if(v == p->data)
			return false;

		pr = p;
		st.push(pr);

		if(v < p->data)
			p = p->leftChild;
		else
			p = p->rightChild;
	}

	p = new AVLNode<Type>(v);
	if(pr == nullptr)
	{
		t = p;
		return true;
	}

	if(p->data < pr->data)
		pr->leftChild = p;
	else
		pr->rightChild = p;

	//2 调整平衡
	while(!st.empty())
	{
		pr = st.top();
		st.pop();

		if(p == pr->leftChild)
			pr->bf--;
		else
			pr->bf++;

		if(pr->bf == 0) //结束调整
			break;
		if(pr->bf==1 || pr->bf==-1) //需要向根回溯
			p = pr;
		else
		{
			//发生不平衡，调整平衡
			if(pr->bf < 0)
			{
				if(p->bf < 0)  //    / 
				{
					RotateR(pr);
				}
				else   //   < 
				{
					RotateLR(pr);
				}
			}
			else
			{
				if(p->bf > 0)    //  \  
				{
					RotateL(pr);
				}
				else    //  >
				{
					RotateRL(pr);
				}
			}
			break;
		}
	}

	//重新链接
	if(st.empty())
		t = pr;
	else
	{
		AVLNode<Type> *ppr = st.top();
		if(pr->data < ppr->data)
			ppr->leftChild = pr;
		else
			ppr->rightChild = pr;
	}

	return true;
}
template<class Type>
bool AVL<Type>::Remove(AVLNode<Type> *&t, const Type &key)
{
	//1 按照bst的规则删除节点

	stack<AVLNode<Type>*> st;

	AVLNode<Type> *p = t, *pr = nullptr;
	while(p != nullptr)
	{
		if(key == p->data)
			break;
		
		pr = p;
		st.push(pr);
		
		if(key < p->data)
			p = p->leftChild;
		else
			p = p->rightChild;
	}

	if(p == nullptr)
		return false;

	AVLNode<Type> *q;
	if(p->leftChild!=nullptr && p->rightChild!=nullptr)
	{
		pr = p;
		st.push(pr);

		q = p->leftChild;
		while(q->rightChild != nullptr)
		{
			pr = q;
			st.push(pr);

			q = q->rightChild;
		}
		p->data = q->data;
		p = q;
	}
	
	if(p->leftChild != nullptr)
		q = p->leftChild;
	else
		q = p->rightChild;
	

	//摘除节点
	if(p->data < pr->data)
		pr->leftChild = q;
	else
		pr->rightChild = q;


	q = p;
	//2 调整平衡
	while(!st.empty())
	{
		pr = st.top();
		st.pop();

		if(q->data < pr->data)
			pr->bf++;
		else
			pr->bf--;

		if(pr->bf==1 || pr->bf==-1) //结束调整
			break;

		if(pr->bf==2 || pr->bf==-2)
		{
			//让q指向较高子树
			if(pr->bf < 0)
				q = pr->leftChild;
			else
				q = pr->rightChild;

			if(q->bf == 0)
			{
				if(pr->bf > 0)
				{
					RotateL(pr);
					pr->leftChild->bf = 1;
				}
				else
				{
					RotateR(pr);
					pr->rightChild->bf = -1;
				}
				break;   //调整完成，结束调整
			}
			else
			{
				if(pr->bf > 0)
				{
					if(q->bf > 0)
						RotateL(pr);
					else
						RotateRL(pr);
				}
				else
				{
					if(q->bf < 0)
						RotateR(pr);
					else
						RotateLR(pr);
				}
				//注意，需要继续向上回溯，因为子树的高度降低，同时重新链接节点
				if(st.empty())
					t = pr;
				else
				{

					AVLNode<Type> *ppr = st.top();
					if (pr->data < ppr->data)
						ppr->leftChild = pr;
					else
						ppr->rightChild = pr;
				}
			}
		}
		else
		{
			//回溯
			q = pr;
		}
	}

	if(st.empty())
		t = pr;
	else
	{
		
		AVLNode<Type> *ppr = st.top();
		if(pr->data < ppr->data)
			ppr->leftChild = pr;
		else
			ppr->rightChild = pr;
	}

	delete p;
}


void main()
{
	int ar[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
	int n = sizeof(ar) / sizeof(ar[0]);

	AVL<int> avl;
	for(int i=0; i<n; ++i)
	{
		avl.Insert(ar[i]);
	}

	avl.Insert(8);

	avl.Remove(3);
	avl.Remove(11);
	avl.Remove(7);
}

曹叡不是睿
关注
数据结构二叉排序树建立_数据结构101什么是二叉搜索树
weixin_26714375的博客
08-19 420
数据结构二叉排序树建立In everyday life, we need to find things or make decisions, and one way to make that process easier is to cut those choices in half. 在日常生活中，我们需要找到事情或做出决定，而简化这一过程的一种方法就是将这些选择减少一半。 Let’s say...
算法：二叉平衡树（AVL树）
OceanStar的博客
10-07 7339
平衡二叉树定义 平衡二叉树 全称叫做 平衡二叉搜索（排序）树，简称 AVL树。英文：Balanced Binary Tree （BBT），注：二叉查找树(BST) AVL 什么意思？AVL 是大学教授 G.M. Adelson-Velsky 和 E.M. Landis 名称的缩写，他们提出的平衡二叉树的概念，为了纪念他们，将 平衡二叉树 称为 AVL树。 AVL树本质上是一颗二叉查找树，但是它又具有以下特点： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1， 左右两个子树 也都是一棵平衡二叉树。
二叉排序树(Binary Sort Tree)
weixin_34220179的博客
04-28 369
2019独角兽企业重金招聘Python工程师标准>>> ...
5.5.1二叉排序树
江船夜雨听笛的博客
09-23 367
加油加油哦ε٩(๑⌓̈๑)۶з 那么今天我们先来回忆一下什么是22排序数22排序数，它的简称叫做BSt battery such as tree，所以它也称为2叉查找数，那么他的第一是22排的树，可以为空当他不为空时我们对他有如下的要求，第1个要求是若泽自述飞空时再择自树上所有结点关键字的值均小于它的根节点，而柚子树非公时，所有柚子树上结点关键字的值均大于他跟几点的关键4，并且左子树和柚子树本身也是一个2叉排序树，我们发现二束定义是采用一种递归的形式，22还学术当中的每一个子数都是2叉排序树，而...
【LeetCode题目记录-9】排序后的数组生成平衡的二叉搜索树
BrilliantEagle的专栏
09-15 1623
排序后的数组生成平衡的二叉搜索树
数据结构与算法——27. 二叉查找树的实现及算法分析
花城的博客
12-06 826
文章目录一、二叉查找树（Binary Search Tree）二叉查找树BST的性质二、二叉查找树的实现（python代码）节点和链接结构1. `BST.put`方法2. `BST.__setitem__`方法3. `BST.get`方法4. `BST.__getitem__`和`BST.__contains__`方法5. TreeNode类的`__iter__`方法（迭代器）6. `BST.delete`方法7. `BST.remove`方法TreeNode类：寻找“后继”节点8. 完整代码三、算法分析（
小蚂蚁学习数据结构（32）——二叉排序树的概念
weixin_34138139的博客
02-07 132
2019独角兽企业重金招聘Python工程师标准>>> ...
排序链表转换成二叉排序树
weixin_33938733的博客
12-21 198
2019独角兽企业重金招聘Python工程师标准>>> ...
从二叉查找树到B*树，一文搞懂搜索树的演进！｜原创
Daniel的博客
11-14 130
本文从二分查找讲起，讲解了BST、AVL、红黑树、B树、B+树最后到B*树的演进过程，知其所以然！点击上方“后端开发技术”，选择“设为星标” ，优质资源及时送达在计算机中有一些数据结构总是与数据的查找分不开，比如二叉查找树（Binary Search Tree）、红黑树、B树、B+树等等数据结构。你可曾想过为什么会有这么多种用于搜索的数据结构？为什么红黑树结构在计算机中内存中被广泛应用？为什么My...
mybinarytree
06-22
二叉查找树（Binary Search Tree，BST），又称为二叉排序树，是二叉树的一个特殊类型，具有以下特性： 1. 每个节点的左子树只包含比该节点小的元素。 2. 每个节点的右子树只包含比该节点大的元素。 3. 左右子树都是...
leetcodepushfront-My-Algorithms-and-Data-Structures-Implementations-In-
07-07
算法（热平衡二叉搜索树） - 也应该了解更多关于 AVL 和 RB 树的知识 **寻找 BST 问题集 - 在 leetcode 上很少 **需要一个基于节点的 BST 实现来解决很多旋转问题 这些是我在处理算法类型问题时采取的步骤： 听问题 ...
详解数据结构-树、单调队列、优先级队列、哈希表
m0_71124168的博客
05-07 792
【代码】详解数据结构-树、单调队列、优先级队列。
百度2021校招C /PHP研发工程师笔试卷（第三批）
lvlongjuan的博客
03-11 708
配接器是STL的一个重要配件，一种用来修饰容器、仿函数、迭代器接口的东西。以下那一项是配接器的是（D）。A、SetB、ListC、deque2.AVL树是平衡二叉查找树，在AVL树中任何节点的两个子树的高度最大差别为1，现有一结点序列（100，70，50，80，90，60），逐个插入一颗空的AVL树，插入过程中，树不断调整，则在上述情境下，分析正确的是（ B ）A、树中插入90时，破坏平衡了，需要进行RL调整C、树中插入50时，破坏平衡了，需要将50变为70的父节点。
C~排序算法
weixin_60461563的博客
09-27 1094
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 130
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
数据结构-4.2.串的定义和基本操作
最新发布
ADCvbV的博客
10-01 220
1.单/双引号不是字符串里的内容，他只是一个边界符，用来表示字符串的头和尾；2.空串也是字符串的子串，空串长度为0；3.字符的编号是从1开始，不是0；4.空格也是字符；
排序算法之归并排序
qq_64039411的博客
10-01 322
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
18年408数据结构
weixin_62182040的博客
09-28 860
如图所示：因为只存上三角部分的元素（包含对角线元素），经分析可知第一层存12个元素，第二层存11个元素，第三层存10个元素，第四层存9个元素，第五层存8个元素，接着第6层只存m6,6，一共是12+11+10+9+8+1=51.A.1出队并输出，2出队并输出，345存入栈中，5出栈并输出，6出队并输出，4出栈并输出，3出栈并输出，A正确。B.1出队入栈，2出队并输出，3出队并输出，4出队并输出，5出队并输出，6出队并输出,1出栈并输出。此时储存在数组中的序列是：6,9,7,1,8,4,5，排除D。
二叉排序树（BST）详解与性质
"BST二叉排序树讲义涵盖了二叉检索树的基本定义、性质以及在实际操作中的应用，包括结点的删除等概念。" 二叉排序树（Binary Search Tree，简称BST），又称为二叉查找树，是一种特殊的二叉树数据结构，它具有以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值