平衡二叉树（AVL）

最新推荐文章于 2021-07-13 18:53:46 发布
最新推荐文章于 2021-07-13 18:53:46 发布
阅读量163 收藏 5
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43598865/article/details/103217814
版权

公众号：CppCoding

平衡二叉树

  • 二叉查找树给我们带来了很多方便，但是由于其在有序序列插入时就会退化成单链表（时间复杂度退化成 O(n)），AVL-tree就克服了上述困难。AVL-tree是一个“加上了平衡条件的”二叉搜索树，平衡条件确保整棵树的深度为O(log n)。

  • AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是 O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

  • 节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。带有平衡因子1、0或-1的节点被认为是平衡的。带有平衡因子-2或2的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。

AVL旋转

在理解AVL旋转之前，首先得知道以下几个概念：

  1. AVL 树节点的插入总是在叶子节点。
  2. AVL 树在插入节点之前总是满足平衡条件的。
  3. 插入新节点后有可能满足平衡条件也有可能不满足。
  4. 当不满足平衡条件后，我们就需要对新的树进行旋转。
单旋转

在这里插入图片描述
解释：
结点18的左子节点的深度是4，右子节点的深度是1，两个的相差为2，不满足平衡条件，即18结点是不平衡点，再其是LL情况，向右旋转，即可。

双旋转

在这里插入图片描述如图，不平衡点仍是18，但是其情况变为LR，即要进行先左转，后右转

关于AVL旋转的四种情况视频

总结：
LL：不满足的点是左子节点的左子节点，要进行右转
RR：不满足的点是右子节点的右子节点，要进行左转
LR：不满足的情况是左子节点的右子节点，先进行左转，后进行右转
RL：不满足的情况是右子节点的左子节点，要先进行右转，再进行左转

AVL树的实现
结点类定义
#ifndef AVLNODE_H
#define AVLNODE_H
#include <iostream>
using namespace std;

template <class T> class AvlTree;// 声明AvlTree类
template <class T>
class AvlNode{
	T data; //关键码
	AvlNode* leftchild;
	AvlNode* rightchild; 
	int balance; //平衡因子
public:
	AvlNode():leftchild(NULL),rightchild(NULL),balance(0){}
	AvlNode(const T& e,AvlNode<T> *lt=NULL,AvlNode<T> *rt=NULL):data(e),leftchild(lt),rightchild(rt),balance(0){}
	int getBalance()const{
		return balance;
	}
	AvlNode<T>* getLeftChild()const{
		return leftchild;
	}
	AvlNode<T> * getRightChild()const{
		return rightchild;
	}
	T getData() cosnt{
		return data;
	}
	friend class AvlTree<T>;
};
#endif
AVL树类定义
template <class T>
class AvlTree{
	AvlNode<T> *root;
	bool Insert(AvlNode<T> *& rt,T x,bool &taller);
	bool Remove(AvlNode<T> *& rt,T x,bool &sharter);
	void RotateLeft(AvlNode<T> *&node); //左旋函数
	void RotateRight(AvlNode<T> *&node); //右旋函数
	void RightBalanceAfterInsert(AvlNode<T> * &sRoot,bool &taller);
	void LeftBalanceAfterInsert(AvlNode<T> * &sRoot,bool &taller);
	void RightBalanceAfterDelete(AvlNode<T> * &sRoot,bool &shorter);
	void LeftBalanceAfterDelete(AvlNode<T> * &sRoot,bool &shorter);
public:
	AvlTree():root(NULL){}
	AvlNode<T> *getRoot() const{
		return root;
	}
	bool Insert(T x){
		bool taller=false;
		return Insert(root,x,taller);
	}
	bool Remove(T x){
		bool shorter=false;
		return Remove(root,x,shorter);
	}
	//输出树形结构
	void DisplayTree(AvlNode<T> *t,int player) const;
};
AVL树类中函数的具体实现
//左旋函数代码
template <typename T>
void AvlTree<T>::RotateLeft(AvlNode<T> *& node){
	if(node == NULL) || (node->rightchild == NULL))  return ;
	AvlNode<T> * tmpNode=new AvlNode<T> (node->data); //申请新的内存存储node数据
	if(temNode == NULL) return;
	tmpNode->leftchild=node->leftchild;//考虑的是node结点下的左子节点
	node->leftchild=tmpNode;
	tmpNode->rightchild=node->rightchild->leftchild;//考虑的是node结点右子节点的左子节点
	AvlNode<T> *toDelete=node->rightchild;
	node->data=toDelete->data;
	node->rightchild=toDelete->rightchild;
	delete toDelete;
}

//右旋函数代码
template<typename T>
void AvlTree<T>::RotateRight(AvlNode<T> *& node){
	if((node==NULL)||(node->leftchild==NULL))  return;
	AvlNode<T> *tmpNode=new AvlNode<T>(node->data);
	tmpNode->rightchild=node->rightchild;
	node->rightchild=tmpNode;
	tmpNode->leftchild=node->leftchild->rightchild;
	AvlNoed<T> *toDelete=node->leftchild;
	node->data=toDelete->data;
	node->rightchild=toDelete->rightchild;
	delete toDelete;
}

//插入结点，rt的右高度增加，则调用函数进行平衡
template<typename T>
void AvlTree<T>::RightBalanceAfterInsert(AvlNode<T> *& sRoot,bool &taller){
	if((sRoot==NULL)||(sRoot->rightchild==NULL)) return;
	AvlNode<T> *rightsub=sRoot->rightchild,*leftsub;
	switch(rightsub->balance){
		case 1:
			sRoot->balance=rightsub->balance=0;
			RotateLeft(sRoot);
			taller=false;
			break;
		case 0:
			cout << "树已经平衡" << endl;
			break;
		case -1:
			leftsub=rightsub->leftchild;
			switch(leftsub->balance){
				case 1:
					sRoot->balance=-1;
					rightsub->balance=0;
					break;
				case 0:
					sRoot->balance=rightsub->balance=0;
					break;
				case -1:
					sRoot->balance=0;
					rightsub->balance=1;
					break;
			}
			leftsub->balance=0;
			RotateRight(rightsub);
			RotateLeft(sRoot);
			taller=false;
			break;
	}
}
//插入结点，rt的左高度增加，调用函数进行平衡
LeftBalanceAfterInsert函数与上面的函数类似，代码的更改只需要将上述的代码中left和right互换即可

//
template <typename T>
void AvlTree<T>::RightBalanceAfterDelete(AvlNode<T>*& sRoot,bool &shorter){
	AvlNode<T>*rightsub=sRoot->rightchild,*leftsub;
	switch(rightsub->balance){
		case 1:
			sRoot->balance=sRoot->balance=0;
			RotateLeft(sRoot);
			break;
		case 0:
			sRoot->balance=0;
			rightsub->balance=-1;
			RotateLeft(sRoot);
			break;
		case -1:
			leftsub=rightsub->leftchild;
			switch(leftsub->balance){
				case -1:
					sRoot->balance=0;
					rightsub->balance=1;
					break;
				case 0:
					sRoot->balance=rightsub->balance=0;
					break;
				case 1:
					sRoot->balance=-1;
					rightsub->balance=0;
					break;
			}
			leftsub->balance=0;
			RotateRight(rightsub);
			RotateLeft(sRoot);
			shorter=false;
			break;
	}
}


template<typename T>
bool AvlTree<T>::Insert(AvlNode<T> *& rt,T x,bool &taller){
	bool success;
	//递归函数的基本条件
	if(rt==NULL){
		rt=new AvlNode<T>(x);
		success=rt!=NULL?true:false;
		if(success) taller=true;
	}
	//如果x的值小于rt的关键码
	else if(x<rt->data){
		//insert的递归调用，从rt的左子树寻找合适的位置插入
		success=Insert(rt->leftchild,x,taller);
		if(taller){
			switch(rt->balance){
				case -1:
					LeftBalanceAfterInsert(rt,taller);
					break;
				case 0:
					rt->balance=-1;
					break;
				case 1:
					rt->balance=0;
					taller=false;
					break;
			}	
		}
	}else if(x>rt->data){
		success=Insert(rt->rightchild,x,taller);
		if(taller){
			switch(rt->balance){
				case -1:
					rt->balance=0;
					taller=false;
					break;
				case 0:
					rt->balance=1;
					break;
				case 1:
					RightBalanceAfterInsert(rt,taller);
					break;
			}
		}
	}
	return success;
}

//
template <typename T>
bool AvlTree<T>::Remove(AvlNode<T> *& rt,T x,bool &shorter){
	 bool success=false;
	 if(rt==NULL) return false;
	 //如果rt是要删除的结点
	 if(x==rt->data){
		if(rt->leftchild!=NULL&&rt->rightchild!=NULL){
			//寻找rt的中序遍历的前驱结点，用r表示
			AvlNode<T> *r=rt->leftchild;
			while(r->rightchild!=NULL){
				r=r->rightchild;
			}
			//交换rt和r的值
			T temp=rt->data;
			rt->data=r->data;
			r->data=temp;
			//递归函数，从rt的左子树中删除关键码为x的结点
			success=Remove(rt->leftchild,x,shorter);
			if(shorter){
				//如果删除后rt的左高度减少
				switch(rt->balance){
					case -1:
						rt->balance=0;
						break;
					case 0:
						rt->balance=1;
						shorter=0;
						break;
					case 1:
						RightBalanceAfterDelete(rt,shorter);
						break;		
				}
			}
		}else{
			//rt最多只有一个子女，这是递归的出口
			AvlNode<T> *p=rt;
			rt=rt->leftchild!=NULL?rt->leftchild:rt->rightchild;
			delete p;
			success=true;
			shorter=true;
		}
	}else if(x<rt->data){
		//递归调用，从rt的左子树中删除关键码为x的结点
		success=Remove(rt->leftchild,x,shorter);
		if(shorter){
			//如果删除后rt的左高渡减少
			switch(rt->balance){
				case -1:
					rt->balance=0;
					break;
				case 0:
					rt->balance=1;
					shorter=0;
					break;
				case 1:
					RightBalanceAfterDelete(rt,shorter);
					break;
			}
		}
	}else if(x>rt->data){
		//递归函数调用，从rt的右子树删除关键码为x的结点
		success=Remove(rt->rightchild,x,shorter);
		if(shorter){
			//如果删除sRoot的右高度减少
			switch(rt->balance){
				case -1:
					LeftBalanceAfterDelete(rt,shorter);
					break;
				case 0:
					rt->balance=-1;
					shorter=0;
					break;
				case 1:
					rt->balance=0;
					break;
			}
		}
	}
	return success;
}
Dorby .
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中const限定符的基本用法
zmbest0的博客
07-09 235
一、const的含义 const的中文意思是常数，也就意味着const修饰的变量不能修改。那么，const限定符就有以下几个性质。 （0）const修饰的变量必须被初始化。 （错误 （正确 其实这个很好理解，const修饰的变量不能被修改，如果仅仅是定义了变量，那之后初始化其实也算是一种修改，这种修改是不道德的。 （1） 默认状态下，const对象仅在文件中有效，也就是说，在其他文件中const对象是无效的。 但是在定义前加个extern就可以使改常量被其他文件访问。...
史上最详细的AVL树（含代码实现）
热门推荐
qq_56999918的博客
02-01 1万+
1.AVL树的相关概念 二叉搜索树在一定程度上可以提高搜索效率，但是当序列是有序时：如果所示 此时二叉搜索树退化成单链表，搜索效率退化为O（N)。为了解决这个问题科学家引入了AVL树，又称平衡搜索二叉树 AVL简称平衡二叉树。由前苏联的数学家 Adelse-Velskil 和Landis 在 1962 年提出的高度平衡的二叉树，根据科学家的英文名也称为 AVL 树。它具有如下几个性质： 可以是空树。 假如不是空树，任何一个结点的左子树与右子树都是平衡二叉树，并且高度之差的绝值不超过...
数据结构及算法 | Java数据结构——AVL平衡二叉搜索树
Toyzmo的博客
07-22 196
一、什么是（AVL)平衡二叉搜索树？ 平衡二叉搜索树在二叉树的概念基础上增加了平衡的概念，所谓平衡就是左右子树的高度差不能大于 1（小于或者等于1都可称作平衡的)。所以为了让二叉树达到平衡，又可以引入四种调节平衡的操作：左旋转、右旋转、左平衡、右平衡。 二、四种旋转的具体过程及如何实现？ 1、左旋转： 当右孩子的右子树太高的时候，用左旋转进行调整，如图： 代码实现参考： /** * 以参数no...
avl树实现
wangxiaohigh
12-02 81
//=================avl 的异常处理类======================= //============== avl_tree_exception.h===================== #ifndef AVL_TREE_EXCEPTION_H_ #define AVL_TREE_EXCEPTION_H_ #include&lt;stdexcept&gt; #i...
平衡二叉树AVL操作模板
09-04
主要介绍了平衡二叉树AVL操作模板,需要的朋友可以参考下
平衡二叉树 AVL
04-30
本程序封装了平衡二叉树（AVL）的基本操作，实现了非递归插入，删除 查找的基本操作。测试通过了一些极端情况，并通过测试。尚未发现的bug，欢迎指正。
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
平衡二叉树（Balanced Binary Tree）又被称为AVL树。具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法。 实验目的： 二叉排序树的实现...
java-平衡二叉树AVL的实现
04-23
NULL 博文链接：https://709002341.iteye.com/blog/2258678
自己动手写数据结构：C++模板类 平衡二叉树 AVL
jobsxiao的专栏
08-10 1039
#ifndef AVLNODE_H #define AVLNODE_H #include using namespace std; template class AvlTree; //声明AvlTree类 template class AvlNode{ public: friend class AvlTree;//友元类
AVL树（C++代码实现）
dududuxy的博客
07-13 261
#include<iostream> #include<queue> #include<String.h> using namespace std; enum State_code { success, fail, range_error, underflow, overflow, fatal, not_present, duplicate_error, entry_inserted, entry_found, internal_error }; enum Balanc.
平衡二叉树（AVL Tree)
further_的博客
09-01 1987
二叉排序树的结点不同插入次序，将导致不同的深度和平均查找长度，即其效率取决于二叉排序树的形态。为了获得较好的查找效率，就要构造一棵形态均匀的二叉排序树（AVL Tree)。 注：在学习平衡二叉树之前应先学习过二叉排序树/二叉搜索树/二叉查找树！！！ **什么是平衡二叉树（AVL Tree) ** 平衡二叉树或者是一棵空的二叉排序树，或者是具有下列性质的二叉排序树：（1）根结点的左子树和右子树的深度最多相差1；（2）根结点的左子树和右子树也都是平衡二叉树。（具有二叉排序树的性质） 平衡因子（Balance F
LeetCode之根据序列求平衡二叉树
Dangerous的博客
07-22 5113
问题描述：/** * Given an array where elements are sorted in ascending order, convert it to a height balanced BST. */给你一个升序的序列，根据这个序列来构造一个平衡二叉树。 解题思路就是先找到根节点，然后递归找到左右子节点。 代码如下：public static TreeNode sort
【查找结构3】平衡二叉查找树 [AVL]
ccnunlp的专栏
03-08 157
在上一个专题中，我们在谈论二叉查找树的效率的时候。不同结构的二叉查找树，查找效率有很大的不同（单支树结构的查找效率退化成了顺序查找）。如何解决这个问题呢？关键在于如何最大限度的减小树的深度。正是基于这个想法，平衡二叉树出现了。   平衡二叉树的定义 （AVL—— 发明者为Adel'son-Vel'skii 和 Landis）   平衡二叉查找树，又称 ...
数据结构-平衡二叉树(AVL树)
理科男同学
11-15 2498
目录 1，平衡二叉树的介绍 1.1，二叉排序树存在的问题 1.2，平衡二叉树 1.3，平衡二叉树的创建 1.4，平衡二叉树的查找 2，代码实现 2.1，平衡二叉树的节点类型 2.2，LL旋转（单右旋转） 2.3，RR旋转（单左旋转） 2.4，向avl树中添加一个节点 2.5，求左右子树的高度 2.6，求平衡二叉树的高度 2.7，中序遍历二叉树 2.8，创建一颗平衡二叉树 3，测试代码 1，平衡二叉树的介绍 1.1，二叉排序树存在的问题 在介绍平衡二叉树之前，我们先来看看.
AVL树前传
selar888的专栏
05-22 162
#include using namespace std; template class AvlTree; template class AvlNode { T data; //关键码 AvlNode *leftChild; AvlNode *rightChild; int balance;//平衡因子 public: AvlNode():leftChild(NULL),r
Python 数据结构 用Python实现AVL树 不同操作的时间复杂度详解
KadeWu的博客
06-15 931
AVL树的Python实现AVL树介绍Python实现NodeaddremovegetHeightrebalance完整代码测试总结1.AVL树2.操作复杂度 AVL树介绍 普通的 二叉搜索树介绍： https://blog.csdn.net/qq_40831558/article/details/106664884 AVL 树是一种平衡二叉树，得名于其发明者的名字（ Adelson-Velskii 以及 Landis）。（可见名字长的好处，命名都能多占一个字母出来）。平衡二叉树递归定义如下： 左右子树的
二叉树相关（上）
财经博主
06-22 229
树，二叉树和二叉查找树 之前介绍过链表，栈与队列。这些数据结构都是线性且一维的。我们为了打破这种限制，创建一个新的数据结构-树。程序世界中的树与自然界中的树是倒过来的：根在顶，叶子在底。根节点只有子节点，没有父节点；而叶子节点没有子节点，或者子节点是空结构。 树的递归定义： 空结构是一棵空树； 如果t1,t2…tk是不相交的树，则以它们的根作为子节点的数据结构也是一棵树； 只有通过(1)(2)产生的数据结构才是树。 之前我们曾经探讨过查找算法及其相应的复杂度。就算是一维的链表，也有自组织链表以及跳跃链表
AVL树【代码实现】
数据联盟
12-23 2780
C# // Finite Ordered Sets - 4State - Balanced using System; using System.Collections.Generic; public enum Direction { FromLeft, FromRight }; public enum State { Header, LeftHigh, Balanced, RightHigh }; public enum SetOperation { Union, Inte
平衡二叉树与avl的区别
最新发布
10-19
平衡二叉树和AVL树都是一种自平衡二叉搜索树，它们的主要区别在于平衡条件的不同。 平衡二叉树是一种二叉搜索树，它的左右子树高度差不超过1，以此来保证树的高度不会过高，从而保证了树的查找、插入、删除等操作的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值