数据结构（高阶）—— AVL树

已于 2022-11-27 00:28:16 修改
阅读量1.1k 收藏 18
点赞数 18
分类专栏： 高阶数据结构 文章标签： 数据结构 算法
于 2022-11-25 21:52:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjsjnsjnn/article/details/128024804
版权

目录

一、AVL树的基本概念

二、AVL树的结点定义

三、AVL树的插入

四、AVL树的旋转

1. 右单旋

2. 左单旋

3. 右左双旋

4. 左右双旋 

五、AVL树的验证 

六、AVL树的性能

七、源代码 

一、AVL树的基本概念

        二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M. A delson- V elskii和E.M. L andis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

AVL树可以是一棵空树，也可以是具有以下性质的一棵二叉搜索树：

  1. 树的左右子树都是AVL树。
  2. 树的左右子树高度之差（简称平衡因子）的绝对值不超过1（-1/0/1）。

        我们以 右树的高度 - 左树的高度 为例进行标注，只要所有的子树满足其绝对值不超过1，那么该二叉搜索树就是AVL树；

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 O(logN) ，搜索时间复杂度 O(logN) 。

二、AVL树的结点定义

        这里将AVL树中的结点定义为三叉链结构，并在每个结点当中引入平衡因子（右子树高度-左子树高度 <= 1）。除此之外，还需编写一个构造新结点的构造函数，由于新构造结点的左右子树均为空树，所以新构造结点的平衡因子初始设置为0即可。

        注意： 给每个结点增加平衡因子并不是必须的，只是实现AVL树的一种方式，不引入平衡因子也可以实现AVL树，只不过会麻烦一点。

template<class k, class v>
struct AVLTreeNode
{
    //三叉链
	AVLTreeNode<k, v>* _left;   //该结点的左孩子
	AVLTreeNode<k, v>* _right;  //该结点的右孩子
	AVLTreeNode<k, v>* _parent; //该结点的父亲

    //存储键值对
	pair<k, v> _kv;
    
    //平衡因子 (规则：右子树-左子树<=1)
	int _bf; //blance factor 平衡因子 

    //构造函数
	AVLTreeNode(const pair<k, v>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)
	{}
};

三、AVL树的插入

        AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

  1. 按照二叉搜索树的插入方法，找到待插入位置并插入到树中。
  2. 更新平衡因子，如果出现不平衡，则需要进行旋转。

以上图为例：

1. 按照二叉搜索树的方式插入新节点
  • 当新插入结点的key值 比 当前结点的key值小就插入到该结点的左子树。
  • 当新插入结点的key值 比 当前结点的key值大就插入到该结点的右子树。
  • 当新插入结点的key值 和 当前结点的key值相等就插入失败。

        当新增结点插入之前，每个结点的平衡因子都已经确定好了（是满足条件的）；新增结点插入以后，它会影响从根结点到其自身这条路径上的平衡因子（有可能不满足条件），所以就需要我们从新增结点的父节点开始不断向上调整平衡因子（如：新增结点->6->7->5    这条路径的平衡因子）

2. 调整节点的平衡因子
规定如下：
  • 新增结点如果在parent的右边，parent的平衡因子++
  • 新增结点如果在parent的左边，parent的平衡因子−−

每更新完一个结点的平衡因子后，都需要进行以下判断：

  • 如果parent的平衡因子等于-1或者1，表明还需要继续往上更新平衡因子。
  • 如果parent的平衡因子等于0，表明无需继续往上更新平衡因子了。
  • 如果parent的平衡因子等于-2或者2，表明此时以parent结点为根结点的子树已经不平衡了，需要进行旋转处理。

如果parent的平衡因子等于-1或者1，表明还需要继续往上更新平衡因子：

        只有0经过−−/++ 操作后会变成-1/1，说明新增结点的插入使得parent的左子树或右子树增高了，即改变了以parent为根结点的子树的高度，从而会影响parent的父结点的平衡因子，因此需要继续往上更新平衡因子。

-------------------------------------------------------------------------------------------------------------------------

如果parent的平衡因子等于0，表明无需继续往上更新平衡因子了：

        只有-1/1经过 ++/−− 操作后会变成0，说明新增结点插入到了parent左右子树当中高度较矮的一棵子树，插入后使得parent左右子树的高度相等了，此操作并没有改变以parent为根结点的子树的高度，从而不会影响parent的父结点的平衡因子，因此无需继续往上更新平衡因子。

 -------------------------------------------------------------------------------------------------------------------------

如果parent的平衡因子等于-2或者2，表明此时以parent结点为根结点的子树已经不平衡了，需要进行旋转处理：

        此时parent结点的左右子树高度之差的绝对值已经超过1了，不满足AVL树的要求，因此需要进行旋转处理。

         通过对上面的平衡因子分析来看，我们可以发现，当parent的平衡因子为-2/2时，已经反映出对于某个节点的左右子树高度差已经超过了1，就需要进行旋转，对于旋转又分为四种旋转，我们先进行简单的分析：

        我们假设新增结点为cur，父节点为parent，更新平衡因子的操作就是通过不断调整cur和parent的位置是更新平衡因子，就有如下操作

cur = parent;             //新增结点更新到其父节点的位置
parent = parent->_parent; //父节点更新到自己父节点的位置

先简单介绍一下四种情况，后面具体介绍：

情况1：当parent的平衡因子为-2，cur的平衡因子为-1时，进行右单旋

情况2：当parent的平衡因子为2，cur的平衡因子为1时，进行左单旋

情况3：当parent的平衡因子为2，cur的平衡因子为-1时，进行右左双旋

情况4：当parent的平衡因子为-2，cur的平衡因子为1时，进行左右双旋

以下是基本的代码结构：

bool Insert(const pair<k, v>& kv)
{
	if (_root == nullptr)//若AVL树为空树，则插入结点直接作为根结点
	{
		_root = new Node(kv);
		return true;
	}

    //按照二叉搜索树的插入规则，先找到正确的插入点
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_kv.first < kv.first)//待插入结点的key值小于当前结点的key值
		{
            //往该结点的左子树走
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > kv.first)//待插入结点的key值大于当前结点的key值
		{
            //往该结点的右子树走
			parent = cur;
			cur = cur->_left;
		}
		else  //待插入结点的key值等于当前结点的key值
		{
			return false;   //插入失败
		}
	}
	cur = new Node(kv);//直接new一个节点插入

	if (parent->_kv.first < kv.first)//新结点的key值大于parent的key值
	{
        //插入到parent的右边
		parent->_right = cur;
		cur->_parent = parent;
	}
	else  //新结点的key值小于parent的key值
	{
        //插入到parent的左边
		parent->_left = cur;
		cur->_parent = parent;
	}

	/*
        控制平衡
	    1.更新平衡因子---更新新增结点到根结点的祖先路劲
	    2.出现异常平衡因子，那么就需要旋转平衡处理
    */

	while (parent) //最坏的情况一路更新到根结点
	{
		if (cur == parent->_left)//cur插入在parent的左边
		{
			parent->_bf--;  //parent的平衡因子--
		}
		else   //cur插入在parent的右边
		{
			parent->_bf++;  //parent的平衡因子++
		}
         //判断是否更新结束或需要进行旋转
		if (parent->_bf == 0)//更新结束（新增结点把parent左右子树矮的那一边增高了，此时左右高度一致）
		{
			break;
		}
		else if (parent->_bf == 1 || parent->_bf == -1)//需要继续往上更新平衡因子
		{
			cur = parent;
			parent = parent->_parent;
		}
		else if (parent->_bf == 2 || parent->_bf == -2)//需要进行旋转（此时parent树已经不平衡了）
		{
			//旋转处理
			if (parent->_bf == -2 && cur->_bf == -1)//右单旋
			{
				RotateR(parent);
			}
			else if (parent->_bf == 2 && cur->_bf == 1)//左单旋
			{
				RotateL(parent);
			}
			else if (parent->_bf == -2 && cur->_bf == 1)//左右双旋
			{
				RotateLR(parent);
			}
			else if (parent->_bf == 2 && cur->_bf == -1)//右左双旋
			{
				RotateRL(parent);
			}
			else
			{
				assert(false);
			}
			break;//部分子树旋转完毕后高度和插入之前一样，不会影响上一层，可以直接break

		}
		else //说明插入,更新平衡因子之前，树中平衡因子就有问题了
		{			
			assert(false);
		}
	}
	return true; //插入成功
}

四、AVL树的旋转

1. 右单旋

        从下面的抽象图可以看出树是处于平衡的一种状态，当h变化时，所得到的的树是不同的，当h=2时当然不只有这一种情况，所以我们就不可能将所有情况都画出来一一分析，对于右单旋来说，是因为插入的结点导致原本平衡的树，其左子树变高了，所以我们就要试图改变右子树的高度来解决左子树和右子树的高度差 <= 1;那么就需要对其进行右单旋的操作。

        当我们在a这棵树插入一个结点的时候，就会导致该树左子树高了，分别对应到h=0/1/2的情况，都是类似的，这样子思考下来整体就容易理解了；

我们先对h=0/1/2这三种情况在a出进行插入节点，然后来进行右单旋

新节点插入较高左子树的左侧---左左：右单旋（抽象图旋转演示）

右单旋代码如下：

void RotateR(Node* parent)
{
    //首先确定好subL/subLR的位置
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	parent->_left = subLR;     //让父节点指向subLR

	if (subLR)
	{
		subLR->_parent = parent;//如果subLR不为空，我们需要维护三叉链的关系，确定好subLR的父节点
	}

	Node* parentParent = parent->_parent;//记录一下父节点的父节点
	subL->_right = parent;  //让subL的右子树指向父节点
	parent->_parent = subL; //让subL作为parent的父亲

	if (parent == _root)//这里表明parent原来是根，让subL作为新的根
	{
		_root = subL;
		_root->_parent = nullptr;
	}
	else//这里表明parent是这棵树的局部子树，parent可能是某个节点的左孩子或右孩子
	{
		if (parentParent->_left == parent)//如果parent是某个节点的左孩子
		{
			parentParent->_left = subL;//让subL成为新的左孩子
		}
		else
		{
			parentParent->_right = subL;//如果parent是某个节点的右孩子
		}
		subL->_parent = parentParent;//让subL成为新的右孩子
	}

	subL->_bf = parent->_bf = 0;//更新平衡因子
}

2. 左单旋

 左单旋和右单旋如出一辙

  

 我们先对h=0/1/2这三种情况在c出进行插入节点，然后来进行左单旋

新节点插入较高右子树的右侧---右右：左单旋（抽象图旋转演示）

左单旋代码如下： 

//左单选
void RotateL(Node* parent)
{
    //首先确定好subR/subRL的位置
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	parent->_right = subRL; //让父节点指向subRL

	if (subRL)
	{
		subRL->_parent = parent;//如果subRL不为空，我们需要维护三叉链的关系，确定好subRL的父节点
	}

	Node* parentParent = parent->_parent;//记录一下父节点的父节点
	subR->_left = parent;   //让subR的左子树指向父节点
	parent->_parent = subR; //让subR作为parent的父亲

	if (parent == _root)//这里表明parent原来是根，让subR作为新的根
	{
		_root = subR;		
		subR->_parent = nullptr;
	}
	else //这里表明parent是这棵树的局部子树，parent可能是某个节点的左孩子或右孩子
	{
		if (parentParent->_left == parent)//如果parent是某个节点的左孩子
		{
			parentParent->_left = subR; //让subR成为新的左孩子
		}
		else  //如果parent是某个节点的右孩子
		{
			parentParent->_right = subR;
		}
		subR->_parent = parentParent; //让subR成为新的右孩子
	}
	subR->_bf = parent->_bf = 0;//更新平衡因子
}

3. 右左双旋

        从下面给出的抽象图可以看出，当h=0/1/2时，和左单旋给出的图是一样的，只不过刚刚是在90的右侧插入的（即：新节点插入较高右子树的右侧---右右：左单旋），那我们在90的左侧插入一个新结点（即：新节点插入较高右子树的左侧---左右：先右单旋再左单旋），此时单旋是解决不了问题的。

为什么一个单旋解决不了问题？

        从上面给出的旋转图可以看出，我们将90的右子树给到30的右边，然后将30给到90的左边，然后更新平衡因子，按照正常更新完毕后的状态，平衡因子应该都是0，但是此图还是一种不平衡的状态，所以单旋解决不了问题。

 我们先对h=0/1/2这三种情况在90左侧进行插入节点，然后来进行右左双旋

 新节点插入较高右子树的左侧---左右：先右单旋再左单旋（抽象图旋转演示）

 旋转步骤:

  1. 以subR为旋转点进行右单旋。
  2. 以parent为旋转点进行左单旋。
  3. 更新平衡因子。

右左双旋后，平衡因子的更新随着subRL原始平衡因子的不同分为以下三种情况： 

1. 当subRL原始平衡因子是1时，左右双旋后parent、subR、subRL的平衡因子分别更新为-1、0、0。

2. 当subRL原始平衡因子是-1时，左右双旋后parent、subR、subRL的平衡因子分别更新为0、1、0。

3. 当subRL原始平衡因子是0时，左右双旋后parent、subR、subRL的平衡因子分别更新为0、0、0。 

右左双旋代码如下：

//右左双旋
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;

	RotateR(subR);   //1、以subR为轴进行右单旋
	RotateL(parent); //2、以parent为轴进行左单旋

    //3、更新平衡因子
	if (bf == 1)
	{
		parent->_bf = -1;
		subR->_bf = 0;
		subRL->_bf = 0;
	}
	else if (bf == -1)
	{
		parent->_bf = 0;
		subR->_bf = 1;
		subRL->_bf = 0;
	}
	else if (bf == 0)
	{
		parent->_bf = 0;
		subR->_bf = 0;
		subRL->_bf = 0;
	}
	else
	{
		assert(false);//在旋转前树的平衡因子就有问题
	}
}

4. 左右双旋 

左右双旋和右左双旋如出一辙，这里就不做过多的演示

左右双旋的步骤如下：

  1. 以subL为旋转点进行左单旋。
  2. 以parent为旋转点进行右单旋。
  3. 更新平衡因子。

左右双旋后，平衡因子的更新随着subLR原始平衡因子的不同分为以下三种情况： 

1. 当subLR原始平衡因子是-1时，左右双旋后parent、subL、subLR的平衡因子分别更新为1、0、0。 

2. 当subLR原始平衡因子是1时，左右双旋后parent、subL、subLR的平衡因子分别更新为0、-1、0。

3. 当subLR原始平衡因子是0时，左右双旋后parent、subL、subLR的平衡因子分别更新为0、0、0。

 左右双旋代码如下：

//左右双旋
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf;

	RotateL(subL);//1、以subL为旋转点进行左单旋
	RotateR(parent); //2、以parent为旋转点进行右单旋

    //更新平衡因子
	if (bf == -1)
	{
		parent->_bf = 1;
		subL->_bf = 0;
		subLR->_bf = 0;
	}
	else if (bf == 1)
	{
		parent->_bf = 0;
		subL->_bf = -1;
		subLR->_bf = 0;
	}
	else if (bf == 0)
	{
		parent->_bf = 0;
		subL->_bf = 0;
		subLR->_bf = 0;
	}
	else
	{
		assert(false); //在旋转前树的平衡因子就有问题
	}
}

五、AVL树的验证 

        AVL树是在二叉搜索树的基础上加入了平衡性的限制，也就是说AVL树也是二叉搜索树，因此我们可以先获取二叉树的中序遍历序列，来判断二叉树是否为二叉搜索树。 

void InOrder()
{
	_InOrder(_root);
}
void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->_left);
	cout << root->_kv.first << ":" << root->_kv.second << endl;
	_InOrder(root->_right);
}

        对于中序遍历只能保证它是二叉搜索树，要保证该二叉搜索树是否平衡还需要判断其平衡因子是否正确；

bool IsBalance()
{
	return _IsBalance(_root);
}

bool _IsBalance(Node* root)
{
	if (root == nullptr)
	{
		return true;
	}
	//对当前树进行检查
	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);

	return abs(rightHeight - leftHeight) < 2 
                && _IsBalance(root->_left) 
                && _IsBalance(root->_right);
}

int Height(Node* root)
{
	if (root == nullptr)
	{
		return 0;
	}
	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);
	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

六、AVL树的性能

         AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即logN。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如： 插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树， 但一个结构经常修改，就不太适合。

七、源代码 

AVLTree.h

#pragma once

#include <iostream>
#include <assert.h>

template<class k, class v>
struct AVLTreeNode
{
	AVLTreeNode<k, v>* _left;
	AVLTreeNode<k, v>* _right;
	AVLTreeNode<k, v>* _parent;
	pair<k, v> _kv;
	int _bf; //blance factor 平衡因子 (规则：右子树-左子树<=1)
	AVLTreeNode(const pair<k, v>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)
	{}
};

template<class k, class v>
class AVLTree
{
	typedef AVLTreeNode<k, v> Node;
public:
	AVLTree()
		:_root(nullptr)
	{}
	bool Insert(const pair<k, v>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			//插入逻辑
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		//控制平衡
		//1.更新平衡因子---更新新增结点到根结点的祖先路劲
		//2.出现异常平衡因子，那么就需要旋转平衡处理
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				//继续向上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//旋转处理
				//由单旋
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)//左单旋
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}
				break;//部分子树旋转完毕后高度和插入之前一样，不会影响上一层，可以直接break

			}
			else//说明插入,更新平衡因子之前，树中平衡因子就有问题了
			{			
				assert(false);
			}
		}
			return true;
	}
	//左单选
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* parentParent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root)//这里表明原来是根
		{
			_root = subR;		
			subR->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}
			subR->_parent = parentParent;
		}
		subR->_bf = parent->_bf = 0;
	}

	//由单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node* parentParent = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (parent == _root)//这里表明原来是根
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
		subL->_bf = parent->_bf = 0;
	}
	//左右双旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;
		RotateL(subL);
		RotateR(parent);
		if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	//右左双旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;
		RotateR(subR);
		RotateL(parent);
		if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void InOrder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		//对当前树进行检查
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		if (rightHeight - leftHeight != root->_bf)
		{
			cout << root->_kv.first << "现在是：" << root->_bf << endl;
			cout << root->_kv.first << "应该是：" << rightHeight - leftHeight << endl;
			return false;
		}
		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}
	int Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}


private:
	Node* _root;
};

void test1()
{
	AVLTree<int, int> t;
	//int a[] = { 5,4,3,2,1,0 };
	//int a[] = { 16,3,7,11,9,26,18,14,15 };
	int a[] = { 4,2,6,1,3,5,15,7,16,14 };
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
		cout << "Insert" << e << ":" <<  t.IsBalance() << endl;
	}
	t.InOrder();
	cout << t.IsBalance() << endl;
}

霄沫凡
关注
  • 18
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
AVL树的构造实现
zzp0753的博客
08-13 7558
今天接触的是平衡二叉查找树，对于AVL树来说相比之前的数据结构稍微多了一些需要注意的地方，照例在此总结总结让自己巩固一二。 首先是使用AVL树的动机： 我们知道AVL树本质上是排序二叉树的一类特例，回顾一下，对于排序二叉树的定义考虑使用归纳定义： ①、空树是二叉查找树； ②、若p和q都是二叉查找树，而root是一个“关键字大于p上所有结点的关键字，并小于q上所有结点的关键字”的元素
红黑树和 AVL 树的旋转调整以及性能分析
身在边城 心在编程
08-12 4081
平衡搜索树性能分析，以及插入和删除的旋转方法 红黑树和AVL树的区别，红黑树性能为什么比AVL树高
AVL树详解
夜槿笙歌的博客
06-05 5409
二叉搜索树有了经典的二叉搜索树做铺垫，我们就可以正式开始讲解由它衍生出的几种改进的二叉搜索树结构。首先是AVL树，也就是我们常说的平衡二叉树。从名字就可以看出，AVL树是一种高度平衡的二叉搜索树，即任意节点的左子树和右子树高度之差都不超过1。那么我们为什么要让一棵二叉搜索树尽量平衡呢？我们假设现在有一组输入数据[1,2,3,4,5]，按照先前的插入逻辑，就会形成如下结构的二叉树：这棵树的高度和它的元素个数是一致的，因为二叉搜索树各种操作所消耗的时间与其高度密切相关，因此这棵树所形成的的结构显然不是我们想看到
【数据结构】AVL详解+模拟
m0_62572672的博客
12-25 640
AVL树本质上还是二叉搜索树，但是我们都知道，当插入的数据有序或者接近有序的时候二叉搜索就会退化，时间复杂度会降为O(N)。AVL就是为了解决这种问题而出现的，而后来的红黑树也以avl树为基础实现的。avl树会在当左右子树高度差大于1的时候进行旋转，从而让树的高度下降并保持在logn。
【C++】一篇了解AVL实现细节（易懂图解版）
jhao的博客
07-10 952
高度平衡搜索二叉树的实现细节详解，以及部分易错点总结，适合于小白~
详解AVL树（平衡二叉树）
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
数据结构 —— 图解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...
AVL树（动图详解）
2021dragon的博客
12-02 1万+
AVL树（C++实现）
【数据结构】AVL树
weixin_74078718的博客
05-12 2792
AVL树的概念、定义、插入、旋转等内容。
数据结构--AVL树（全）
weixin_48560325的博客
05-01 7889
目录 什么是AVL树？ AVL树的特点及形成原因 二叉搜索树基本概念 二叉搜索的特点 二叉搜索树的优点及缺点 改进的二叉搜索树——AVL树 AVL树的定义 AVL树的特点 结点的平衡因子balance 构建一个AVL树 构建一个AVL树的节点 什么是AVL树？ AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 AVL树的特点及形成原因 AVL树本质.
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
数据结构课程设计——基于Avl树的用户登陆系统.zip
09-29
1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合...
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
数据结构课程设计（AVL树实现图书管理系统）
02-01
数据结构课程设计（AVL树实现图书管理系统）
数据结构——树和二叉树的基本概念
最新发布
qq_67693066的博客
04-24 1067
数据结构——树和二叉树的基本概念
数据结构中的栈和队列（附实际案例代码）
JAZJD的博客
04-23 765
栈（Stack）和队列（Queue）
数据结构——堆
2301_76613753的博客
04-20 1561
之前我们了解到了一种非线性的数据结构——树，今天我们来学习二叉树的顺序结构——堆的实现，来了解堆这种数据结构。一、堆的概念及结构如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： <=且 <=( >=且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树。
数据结构面试常见问题：什么是二叉树？如何进行二叉树的遍历？
万猫学社
04-21 871
二叉树是一种特殊的数据结构，它的每个元素都有零个、一个或两个子元素。这些元素被称为节点，每个节点都有一个值，以及两个指向其子节点的链接。这种结构就像一个家族树，每个节点都有一个父节点（除了顶部的根节点），以及左右两个子节点。在实际项目中，我们经常会用到二叉树这种数据结构，它在数据存储、搜索等方面都有着广泛的应用。接下来，我们将深入探讨二叉树的结构，包括节点、父节点、子节点、叶节点、根节点等概念。在本文中，我们介绍了二叉树的基本结构，以及前序遍历、中序遍历和后序遍历的实现方式。
数据结构 -- 二叉树&二叉搜索树
2301_79602614的博客
04-20 1431
这样看似prev = node.val 也就是 prev = 5,但因为你的prev是作为一个参数,是对整个方法中生效的,也就是4这个点有doValid(node.left,prev) 和 doValid(node.right,prev)这两个prev都是4这个点传入的prev并不会说因为在doValid(node.prev)中prev=5导致这个方法的所有prev都变为了5,本质也就是这个参数只是这个方法的局部变量,局部变量的修改不会影响到其他的方法。如何知道右子树处理完成呢？
数据结构二叉搜索树avl树
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左...AVL树则是一种自平衡的二叉搜索树，它保证任何节点的左右子树高度差不超过1，因此能够保证树的查找、插入、删除等操作的时间复杂度为O(logN)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

霄沫凡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值