数据结构与算法-平衡二叉搜索树

已于 2022-09-14 10:31:38 修改
阅读量248 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
于 2022-07-05 14:39:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45366970/article/details/125616164
版权

平衡二叉搜索树

1.自平衡的二叉搜索树

2.平衡

（1）空树平衡

（2）非空树平衡

  • 左右子树平衡
  • 左右子树高度差绝对值 <= 1

3.平衡因子

左右子树的高度差的衡量值 -1 0 1

（一）平衡操作

1.左左单旋 LL：插入节点在左子树的左节点，导致二叉树失衡

LL单旋

template<class Elem>
BinNode<Elem>* AVLTree<Elem>::LLrotate(BinNode<Elem>* r){
	
	BinNode<Elem>* child;
	child = r->left;
	r->left = child->right;
	child->right = r;
	
	r->height = max(height(r->left),height(r->right))+1;
	child->height = max(height(r->left),height(r->right))+1;

	return child;
}

2.左右双旋 LR：插入节点在左子树的右节点，导致二叉树失衡

在这里插入图片描述

template<class Elem>
BinNode<Elem>* AVLTree<Elem>::LRrotate(BinNode<Elem>* r){
	
	r->left = RRrotate(r->left);
	r = LLrotate(r);
	return r;

}

3.右右单旋RR：与LL单旋对称

template<class Elem>
BinNode<Elem>* AVLTree<Elem>::RRrotate(BinNode<Elem>* r){

	BinNode<Elem>* child;
	child = r->right;
	r->right = child->left;
	child->left = r;
	
	r->height = max(height(r->left),height(r->right))+1;
	child->height = max(height(r->left),height(r->right))+1;

	return child;

}

4.右左双旋RL：与LR双旋对称

template<class Elem>
BinNode<Elem>* AVLTree<Elem>::RLrotate(BinNode<Elem>* r){
	
	r->right = LLrotate(r->right);
	r = RRrotate(r);
	return r;

}

（二）代码实现

#include <iostream>
#include <stack>
#include <queue>

using namespace std;



template<class Elem>
struct BinNode{

	Elem data;
	BinNode<Elem>* left;
	BinNode<Elem>* right;
	
	int height;
	BinNode(Elem x){
	
		data = x;
		left = right = NULL;
		height = 0;
		
	}
	
};

/********************************************************************************************/
/********************************************二叉树******************************************/
/********************************************************************************************/
template<class Elem>
class BinTree{
	
	public:
		BinNode<Elem>* root;
		
		void pre(BinNode<Elem>* root);
		void ipre(BinNode<Elem>* root);
		
		void mid(BinNode<Elem>* root);
		void imid(BinNode<Elem>* root);
		
		void pos(BinNode<Elem>* root);
		void ipos(BinNode<Elem>* root);
		
		void lay(BinNode<Elem>* root);
		
		BinNode<Elem>* find(Elem p,BinNode<Elem>* root);
	public:
		BinTree(){ root = NULL; };
		BinTree(Elem x){
			
			root = new BinNode<Elem>(x);
		}
		~BinTree(){}
		
		void preOrderTraversal();
		void midOrderTraversal();
		void posOrderTraversal();
		void layOrderTraversal();
		bool insert(Elem p,int LR,int data);
};

//前序递归：递和归（有去有回）
template<class Elem>
void BinTree<Elem>::pre(BinNode<Elem>* root){
	
	if(root == NULL)
		return;
	cout << root->data << " ";
	pre(root->left);
	pre(root->right);
}

//前序迭代（用栈数据结构实现）：按顺序入栈，直到走不通出栈（入栈、出栈顺序按照前序方式）
template<class Elem>
void BinTree<Elem>::ipre(BinNode<Elem>* root) {

	stack<BinNode<Elem>*> st;
	
	while(root)
	{
		cout << root->data << " ";
		st.push(root);
		root = root->left;
		
		//不断判断节点是否为空（节点访问到头，回到前一个节点再判断）
		while(root == NULL && !st.empty())
		{
			root = st.top();
			st.pop();
			root = root->right;
		}
	}
}

//前序遍历
template<class Elem>
void BinTree<Elem>::preOrderTraversal(){

	cout << "1.递归方法：";
	pre(root);
	cout <<endl;
	cout << "2.迭代方法：";
	ipre(root);
}

//中序递归
template<class Elem>
void BinTree<Elem>::mid(BinNode<Elem>* root){

	if(root == NULL)
		return;
	mid(root->left);
	cout << root->data << " ";
	mid(root->right);

}

//中序迭代
template<class Elem>
void BinTree<Elem>::imid(BinNode<Elem>* root){
	
	stack<BinNode<Elem>*> st;
	
	while(root)
	{
		st.push(root);
		root = root->left;
		while(root == NULL && !st.empty())
		{
			root = st.top();
			st.pop();
			cout << root->data <<" ";
			root = root->right;
		}
	}

}

//中序遍历
template<class Elem>
void BinTree<Elem>::midOrderTraversal(){
	cout << "1.递归方法：";
	mid(root);
	cout <<endl;
	cout << "2.迭代方法：";
	imid(root);
}

//后序递归
template<class Elem>
void BinTree<Elem>::pos(BinNode<Elem>* root){
	
	if(root == NULL)
		return;
	pos(root->left);
	pos(root->right);
	cout << root->data << " ";

}

//后序迭代
template<class Elem>
void BinTree<Elem>::ipos(BinNode<Elem>* root){

	stack<BinNode<Elem>*> st;
	BinNode<Elem>* pre = NULL;
	
	while(root)
	{
		st.push(root);
		root = root->left;
		while(root == NULL && !st.empty())
		{
			root = st.top();
			if(pre == root->right || !root->right)
			{
				cout << root->data << " ";
				st.pop();
			}
			pre = root;
			root = root->right;
		}
	}

}

//后序遍历
template<class Elem>
void BinTree<Elem>::posOrderTraversal(){
	
	cout << "1.递归方法：";
	pos(root);
	cout <<endl;
	cout << "2.迭代方法：";
	//ipos(root);
	
}

//层序遍历（用队列实现）
template<class Elem>
void BinTree<Elem>::lay(BinNode<Elem>* root){

	queue<BinNode<Elem>*> q;
	q.push(root);
	
	while(root)
	{
		cout << root->data << " ";
		if(root->left)
			q.push(root->left);
		if(root->right)
			q.push(root->right);
		q.pop();
		root = q.front();
	}
	
}

template<class Elem>
void BinTree<Elem>::layOrderTraversal(){

	lay(root);
}

template<class Elem>
BinNode<Elem>* BinTree<Elem>::find(Elem p,BinNode<Elem>* root){

	BinNode<Elem>* temp = NULL;

	if(root == NULL)
		temp = NULL;
	else
	{
		if(root->data == p)
		{
			temp = root;
		}
		else
		{
			return find(p,root->left);
			return find(p,root->right);
		}
	}
	
	return temp;

}

template<class Elem>
bool BinTree<Elem>::insert(Elem p,int LR,int data){

	bool flag = false;
	
	BinNode<Elem>* temp = find(p,root);
	BinNode<Elem>* node = new BinNode<Elem>(data);
	if(temp)
	{
		if(LR == 0)
		{
			if(temp->left == NULL)
			{
				temp->left = node;
				flag = true;
			}
				
		}
		if(LR == 1)
		{
			if(temp->right == NULL)
			{
				temp->right = node;
				flag = true;
			}
		}
	}
	
	return flag;
}



/********************************************************************************************/
/********************************************二叉搜索树**************************************/
/********************************************************************************************/
template<class Elem>
class BSTree:public BinTree<Elem>{

	private:
		BinNode<Elem>* rfindMax(BinNode<Elem>* root);
		virtual BinNode<Elem>* rinsert(BinNode<Elem>* root,Elem x);
		BinNode<Elem>* remove(BinNode<Elem>* root,Elem x);

	public:
		BSTree(){ this->root = NULL;}
		BinNode<Elem>* findMax();
		BinNode<Elem>* findMin();
		BinNode<Elem>* findX(Elem x);
		bool insert(Elem x);
		bool remove(Elem x);

};

template<class Elem>
BinNode<Elem>* BSTree<Elem>::rfindMax(BinNode<Elem>* root){

	BinNode<Elem>* temp = NULL;

	if(root->right == NULL)
		temp = root;
	else
		root = rfindMax(root->right);
		
	return temp;
	
	
	
}

//二叉搜索树查找最大值
template<class Elem>
BinNode<Elem>* BSTree<Elem>::findMax(){

	BinNode<Elem>* temp = this->root;
	
	while(temp->right)
	{
		temp = temp->right;
	}
	
	return temp;
	
}

//二叉搜索树查找最小值
template<class Elem>
BinNode<Elem>* BSTree<Elem>::findMin(){

	BinNode<Elem>* temp = this->root;
	
	while(temp->left)
	{
		temp = temp->left;
	}
	
	return temp;
	
}

//二叉搜索树查找某值
template<class Elem>
BinNode<Elem>* BSTree<Elem>::findX(Elem x){
	
	BinNode<Elem>* temp = this->root;
	
	while(temp && x!=temp->data)
	{
		if(x < temp->data)
			temp = temp->left;
		else
			temp = temp->right;
	}
	
	return temp;
}

//二叉树插入递归
template<class Elem>
BinNode<Elem>* BSTree<Elem>::rinsert(BinNode<Elem>* root,Elem x){

	if(root == NULL)
	{
		root = new BinNode<Elem>(x);
		if(!root)
			throw -1;
	}
	else if(x < root->data)
		root->left = rinsert(root->left,x);
	else if(x > root->data)
		root->right = rinsert(root->right,x);
	else
		throw -2;
	
	return root;
	
}

//二叉搜索树插入
template<class Elem>
bool BSTree<Elem>::insert(Elem x){
	
	bool flag = false;
	try{
		this->root = rinsert(this->root,x);
		flag = true;
	}
	catch(int error){
		
		flag = false;
	}
	
	return flag;
	
	

}

//二叉搜索树删除递归
template<class Elem>
BinNode<Elem>* BSTree<Elem>::remove(BinNode<Elem>* root,Elem x){

	BinNode<Elem>* temp = NULL;
	
	if(!root) throw -1;
	else
	{
		if(x < root->data)
			root->left = remove(root->left,x);
		else if(x > root->data)
			root->right = remove(root->right,x);
		else
		{
			if( root->left && root->right)
			{
				temp = rfindMax(root->left);
				root->data = temp->data;
				root->left = remove(root->left,x);
			}
			else
			{
				temp = root;
				root = root->left ? root->left : root->right;
				delete temp;
			}
		}
	}
	return root;
}

//二叉搜索树删除
template<class Elem>
bool BSTree<Elem>::remove(Elem x){
	
	bool flag = false;
	try {
		this->root = remove(this->root,x);
		flag = true;
	}
	catch(int error){
		flag = false;
	}
	
	return flag;

}

/********************************************************************************************/
/********************************************平衡二叉树**************************************/
/********************************************************************************************/
template<class Elem>
class AVLTree:public BSTree<Elem>{

	protected:
		int height(BinNode<Elem>* r);
		BinNode<Elem>* rinsert(BinNode<Elem>* r,Elem x);
	public:
		BinNode<Elem>* LLrotate(BinNode<Elem>* r);
		BinNode<Elem>* RRrotate(BinNode<Elem>* r);
		BinNode<Elem>* LRrotate(BinNode<Elem>* r);
		BinNode<Elem>* RLrotate(BinNode<Elem>* r);
		
		AVLTree(){ this->root = NULL; };
		

};

//树高度
template<class Elem>
int AVLTree<Elem>::height(BinNode<Elem>* r){
	if(!r) return -1;
	return r->height;
}

//AVL树插入
template<class Elem>
BinNode<Elem>* AVLTree<Elem>::rinsert(BinNode<Elem>* r,Elem x){
	
	if(!r)
	{
		r = new BinNode<Elem>(x);
		if(!r) throw -1;
	}
	else if(x < r->data)
	{
		r->left = rinsert(r->left,x);
		//失去平衡
		if(height(r->left) - height(r->right) == 2)
		{
			if(x < r->left->data)
				r = LLrotate(r);
			else
				r = LRrotate(r);
		}
	}
	else if(x > r->data)
	{
		r->right = rinsert(r->right,x);
		if(height(r->right) - height(r->left) == 2)
		{
			if(x > r->right->data)
				r = RRrotate(r);
			else
				r = RLrotate(r);
		}
	}
	else throw -2;
	
	r->height = max(height(r->left),height(r->right))+1;
	
	return r;

}

//LL单旋
template<class Elem>
BinNode<Elem>* AVLTree<Elem>::LLrotate(BinNode<Elem>* r){
	
	BinNode<Elem>* child;
	child = r->left;
	r->left = child->right;
	child->right = r;
	
	r->height = max(height(r->left),height(r->right))+1;
	child->height = max(height(r->left),height(r->right))+1;

	return child;

}

//RR单旋
template<class Elem>
BinNode<Elem>* AVLTree<Elem>::RRrotate(BinNode<Elem>* r){

	BinNode<Elem>* child;
	child = r->right;
	r->right = child->left;
	child->left = r;
	
	r->height = max(height(r->left),height(r->right))+1;
	child->height = max(height(r->left),height(r->right))+1;

	return child;

}

//LR双旋
template<class Elem>
BinNode<Elem>* AVLTree<Elem>::LRrotate(BinNode<Elem>* r){
	
	r->left = RRrotate(r->left);
	r = LLrotate(r);
	return r;

}

//RL双旋
template<class Elem>
BinNode<Elem>* AVLTree<Elem>::RLrotate(BinNode<Elem>* r){
	
	r->right = LLrotate(r->right);
	r = RRrotate(r);
	return r;

}

/********************************************************************************************/
/********************************************主函数******************************************/
/********************************************************************************************/

int main(int argc,const char* argv[]){
	
	AVLTree<int> avl;
	avl.insert(8);
	avl.insert(7);
	avl.insert(6);
	avl.insert(5);
	avl.insert(10);
	avl.insert(9);
	
	avl.layOrderTraversal();
	
	return 0;
}
TUTU-Jack
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法设计与分析-最优二叉搜索树PPT
11-05
二叉搜索树是一种满足特定条件的数据结构，每个节点的左子树上的所有节点的值都小于该节点的值，而右子树上的所有节点的值都大于该节点的值。这样的结构确保了搜索操作的高效性。 在最优二叉搜索树的概念中，我们有...
平衡二叉树（AVL）图解与实现
小张的专栏
10-31 6万+
个人技术博客：http://blog.ztgreat.cn 平衡二叉树（Balanced BinaryTree）又被称为AVL树。它具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。   平衡二叉树一般是一个有序树，它具有二叉树的所有性质，其遍历操作和二叉树的遍历操作相同。但是由于其对二叉树施加了额外限制，因而其添加、删除操作都必须...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2622
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
平衡二叉搜索树（AVLTree）
是胖胖没错了的博客
08-08 1450
AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 它的左右子树都是AVL树 左右
二叉查找树与平衡二叉树
热门推荐
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
平衡二叉搜索树
Cui's Blog
08-20 2336
文章目录平衡二叉搜索树AVL树平衡因子平衡二叉树不平衡的二叉树旋转BBST插入e 递归算法 平衡二叉搜索树 平衡二叉搜索树（英语：Balanced Binary Search Tree）是一种结构平衡的[二叉搜索树] ，它是一种每个节点的左右两子[树] 高度差都不超过一的[二叉树] 。它能在O(logn)内完成插入、查找和删除操作，最早被发明的平衡二叉搜索树为[AVL树] 。 之前的BST已经可以解决很多查找问题，而且时间复杂度在O(logN),但是如果出现单支树的情况，时间复杂度就会退化到O(N),也就是
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据...理解并熟练掌握二叉搜索树的删除操作对于学习数据结构和算法是非常重要的，因为这涉及到如何高效地管理和操作数据，是计算机科学的基础之一。
数据结构实验--基于二叉排序树的商品查询系统
10-16
为了解决这个问题，可以使用自平衡二叉搜索树，如AVL树或红黑树。但在这个实验中，可能没有涉及自平衡二叉树，而是专注于基础的二叉排序树操作。 在调试过程中，需要对各种操作进行测试，确保它们都能正确地在二叉...
数据结构平衡二叉排序树
02-13
AVL树是一种自平衡的二叉搜索树，它的每个节点都包含一个平衡因子，这个因子是该节点的左子树高度与右子树高度的差值。平衡因子的取值范围是-1、0或1，这确保了树的高度始终保持在一个相对较小的范围内，从而保证了...
数据结构之平衡二叉搜索树
最新发布
m0_69767208的博客
02-23 681
AVL是一种自平衡二叉搜索树（self-balancing binary search tree）的数据结构，它的名称来源于其发明者G.M. Adelson-Velsky和E.M. Landis。AVL树通过在每次插入或删除节点时进行旋转操作，来确保树的高度始终保持在一个较小的范围内，从而保持树的平衡性。AVL树的平衡性是通过节点的高度差（即左子树高度和右子树高度之差）来衡量的。在一个平衡的AVL树中，任何节点的左子树和右子树的高度差不超过1。
平衡二叉搜索树（AVL）详解
芮萌萌的博客
07-09 3万+
1.二叉搜索树（Binary Sort Tree） 二叉搜索树，又称之为二叉排序树（二叉查找树），它或许是一棵空树，或许是具有以下性质的二叉树： 若他的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别是二叉搜索树 二叉搜索树的这种特性，使得我们在此二叉树上查找某个值就很方便了，从根节点开始，若要寻找的值...
AVL树（平衡二叉搜索树）
langk_的博客
09-03 3285
带你手撕AVL树，左单旋，右单旋，左右双旋，右左双旋
平衡二叉搜索树详解
sorryking_的博客
08-27 348
待删除的节点左右子树非空，根据左右子树高度，选择高的一边，如果是左高则选择左子树中的最大值替换待删除节点的值，然后删除左子树中的最大值节点，反之则选择右子树的最小值节点进行同样操作。如果一个有序二叉树呈现接近单支状(类似链表)，它的查找效率接近链表，因此只有达到平衡时它的查找效率最高。前提是有序的二叉树，它的左右子树的高度差不超过1，而且它的所有子树也满足这个条件。由于节点的值受限，因此只能通过调整达到有序，而不能进行值的修改。待删除的节点是叶子节点，直接删除。...
平衡二叉查找树 (AVL Tree)
m0_56321153的博客
08-13 1327
左单旋 treePtr singleLeft(treePtr T){ treePtr tmpPtr; tmpPtr = T; T = T->Left; tmpPtr->Left = T->Right; T->Right = tmpPtr; tmpPtr->Height = max(GetHeight(tmpPtr->Left),GetHeight(tmpPtr->Right))+1; T->Height = max(GetHeight(T-
平衡二叉搜索树的创建
qq_41891805的博客
03-03 775
平衡二叉搜索树 平衡二叉树：每个结点的左右子树高度差不超过1，左右子树均为平衡二叉树 搜索二叉树：左结点 < 根结点 <右结点 平衡二叉搜索树则是优化后的搜索二叉树，使得查找的效率提升，但是在添加数据时，需要进行复杂的判断，所以一般使用在查找频繁而修改很少的存储结构中。 平衡二叉树的建立 整个建立过程分为三大部分： ①插入新的结点 ②判断插入结点后树是否平衡，并找到不平衡的点 ③若不平...
平衡二叉树详解及C++实现
c661280411470yb的博客
06-08 734
平衡二叉搜索树
动图详解平衡树——平衡的二叉搜索树
tunmang5421的博客
04-10 1335
【多动图警告】本文详细介绍了平衡树，加了一些动图和自己的理解
数据结构 —— 图解AVL树(平衡二叉树)
猎人在吃肉
07-28 3万+
文章目录1、AVL树(平衡二叉树)的定义1.1、平衡因子2、AVL树的作用：3、AVL树的基本操作3.1、插入—— 左左型的右旋：3.1.1、右旋的具体步骤：3.1.2、右旋的动画演示：3.1.3、右旋示例：3.2、插入——右右型的左旋：3.2.1、左旋的具体步骤：3.2.2、动画演示：3.2.3、左旋举例：3.3、插入——左右型的左右旋 ( 即先左后右)：3.3.1、左右旋的两次旋转步骤：3.3...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值