AVL 树

于 2023-11-07 14:21:47 发布
阅读量189 收藏
点赞数
分类专栏： C++进阶 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Adz1119/article/details/134265254
版权

目录

AVL树

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下

为了解决上诉问题有这么一种方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

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

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

在这里插入图片描述

AVL树的结构

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode* _left;
	AVLTreeNode* _right;
	AVLTreeNode* _parent;
	pair<K,V> _kv;

	int _bf;//平衡因子
	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:
	bool Insert(const pair<K, V>& kv);//
protected:
	Node* _root = nullptr;
};

AVL树的插入

先按照二叉搜索树的方式插入新节点(二叉搜索树的实现)

然后调整节点的平衡因子
在这里插入图片描述
bf平衡因子==2 or -2时，需要通过旋转操作来让其正常
有四种旋转情况：
在这里插入图片描述
左左的情况和上图类似，需要的是右单旋

在这里插入图片描述
当碰到右左的情况，发现左单旋不能解决问题，引出第三种旋转操作，右左双旋：
在这里插入图片描述
对应的还有右左的情况，和上图类似

插入代码：

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 (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	Node* newnode = new Node(kv);
	if (parent->_kv.first > kv.first)
	{
		parent->_left = newnode;
		newnode->_parent = parent;
		parent->_bf--;
	}
	else if (parent->_kv.first < kv.first)
	{
		parent->_right = newnode;
		newnode->_parent = parent;
		parent->_bf++;
	}
	else
	{
		assert(false);
	}

	//通过平衡因子的变化判断是否需要旋转
	while (parent)
	{
		//cout << "parent-val=" << parent->_kv.first << endl;
		//cout << "parent-bf=" << parent->_bf << endl;
		if (parent->_bf == 0)
		{
			//父亲所在子树高度不变，不需要向上更新平衡因子
			return true;
		}
		else if (parent->_bf == 1 || parent->_bf == -1)
		{
			//父亲所在子树高度变化，可能会影响到上面的树，需要向上更新
			if (parent->_parent == nullptr)
				;
			else if (parent == parent->_parent->_right)
				parent->_parent->_bf++;
			else if (parent == parent->_parent->_left)
				parent->_parent->_bf--;
			else
				assert(false);
			parent = parent->_parent;
		}
		else if (parent->_bf == 2 || parent->_bf == -2)
		{
			//平衡因子出现异常，需要进行旋转
			if (parent->_bf == 2 && parent->_right->_bf == 1)
			{
				//右右的情况，需要左单旋
				RotateL(parent);
			}
			else if (parent->_bf == -2 && parent->_left->_bf == -1)
			{
				//左左的情况，需要右单旋
				RotateR(parent);
			}
			else if (parent->_bf == 2 && parent->_right->_bf == -1)
			{
				//右左的情况，需要右单旋然后左单旋
				RotateRL(parent);
			}
			else if (parent->_bf == -2 && parent->_left->_bf == 1)
			{
				//左右的情况，需要左单旋然后右单旋
				RotateLR(parent);
			}
			else
			{
				cout <<"parent->bf=" << parent->_bf << endl;
				cout << "parent->left->bf=" << parent->_left->_bf << endl;
				cout << "parent->right->bf=" << parent->_right->_bf << endl;
				assert(false);
			}
			//经过旋转，该子树的高度已经降低，所以不会影响到上面树
			break;
		}
		else
		{
			assert(false);
		}
	}
	return true;
}

能用else if就用else if，留else来快速判断错误出现位置

AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

  1. 验证其为二叉搜索树
    如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
  2. 验证其为平衡树
  • 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
  • 节点的平衡因子是否计算正确
public:
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()//检查平衡因子是否正确
	{
		return _IsBalance(_root);
	}
protected:
	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 == " <<root->_kv.first<< " 时平衡因子异常:" << root->_bf << 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 ? rightHeight + 1 : leftHeight + 1;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

可以先用指定数据测试，没问题了之后使用随机数进行测试，可以通过手动打断点的方式快速定位到出问题的数据。

int main()
{
	const int N = 1000;
	srand(time(0));
	vector<int> v;
	v.reserve(N);
	for (int i=0;i<N;i++)
	{
		v.push_back(rand());
		cout << v.back() << " ";
	}
	cout << endl;

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

	return 0;
}

AVL树的性能

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

完整代码

#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode* _left;
	AVLTreeNode* _right;
	AVLTreeNode* _parent;
	pair<K,V> _kv;

	int _bf;//平衡因子
	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:
	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 (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		Node* newnode = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = newnode;
			newnode->_parent = parent;
			parent->_bf--;
		}
		else if (parent->_kv.first < kv.first)
		{
			parent->_right = newnode;
			newnode->_parent = parent;
			parent->_bf++;
		}
		else
		{
			assert(false);
		}

		//通过平衡因子的变化判断是否需要旋转
		while (parent)
		{
			//cout << "parent-val=" << parent->_kv.first << endl;
			//cout << "parent-bf=" << parent->_bf << endl;
			if (parent->_bf == 0)
			{
				//父亲所在子树高度不变，不需要向上更新平衡因子
				return true;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				//父亲所在子树高度变化，可能会影响到上面的树，需要向上更新
				if (parent->_parent == nullptr)
					;
				else if (parent == parent->_parent->_right)
					parent->_parent->_bf++;
				else if (parent == parent->_parent->_left)
					parent->_parent->_bf--;
				else
					assert(false);
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//平衡因子出现异常，需要进行旋转
				if (parent->_bf == 2 && parent->_right->_bf == 1)
				{
					//右右的情况，需要左单旋
					RotateL(parent);
				}
				else if (parent->_bf == -2 && parent->_left->_bf == -1)
				{
					//左左的情况，需要右单旋
					RotateR(parent);
				}
				else if (parent->_bf == 2 && parent->_right->_bf == -1)
				{
					//右左的情况，需要右单旋然后左单旋
					RotateRL(parent);
				}
				else if (parent->_bf == -2 && parent->_left->_bf == 1)
				{
					//左右的情况，需要左单旋然后右单旋
					RotateLR(parent);
				}
				else
				{
					cout <<"parent->bf=" << parent->_bf << endl;
					cout << "parent->left->bf=" << parent->_left->_bf << endl;
					cout << "parent->right->bf=" << parent->_right->_bf << endl;
					assert(false);
				}
				//经过旋转，该子树的高度已经降低，所以不会影响到上面树
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}


	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		//subR变成新的子树的头，parent链接到subR左边，并把subRL链接到自己右边
		subR->_left = parent;
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* parentParent = parent->_parent;
		parent->_parent = subR;
		if (parentParent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			subR->_parent = parentParent;
			if (parentParent->_left == parent)
			{
				parentParent->_left = subR;
			}
			else if (parentParent->_right == parent)
			{
				parentParent->_right = subR;
			}
			else
			{
				assert(false);
			}
		}
		//左单旋后树高度降低平衡因子更正
		parent->_bf = subR->_bf = 0;
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		//subL变成新的子树的头，parent链接到subL右边，并把subLR链接到自己左边
		subL->_right = parent;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		Node* parentParent = parent->_parent;
		parent->_parent = subL;
		if (parentParent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			subL->_parent = parentParent;
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else if (parentParent->_right == parent)
			{
				parentParent->_right = subL;
			}
			else
			{
				assert(false);
			}
		}
		//右单旋后树高度降低，平衡因子更正
		parent->_bf = subL->_bf = 0;
	}
	void RotateRL(Node* parent)
	{
		//先记录当前subRL的bf，不然右和左旋转后就找不到了
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;
		//对subR进行右单旋，再对自己左单旋
		RotateR(subR);
		RotateL(parent);

		//旋转完之后位置正确，高度降低，但是bf需要调整回正确值
		if (bf == 0)
		{
			parent->_bf = subR->_bf = subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			subRL->_bf = 0;//新的头
			parent->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 1)
		{
			subRL->_bf = 0;//新的头
			parent->_bf = -1;
			subR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void RotateLR(Node* parent)
	{
		//先记录当前subLR的bf，不然左右分别旋转后就找不到了
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;
		//对subL进行左单旋，再对自己右单旋
		RotateL(subL);
		RotateR(parent);

		//旋转完之后位置正确，高度降低，但是bf需要调整回正确值
		if (bf == 0)
		{
			parent->_bf = subL->_bf = subLR->_bf = 0;
		}
		else if (bf == -1)
		{
			subLR->_bf = 0;//新的头
			parent->_bf = 1;
			subL->_bf = 0;
		}
		else if (bf == 1)
		{
			subLR->_bf = 0;//新的头
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else
		{
			assert(false);
		}
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()//检查平衡因子是否正确
	{
		return _IsBalance(_root);
	}
protected:
	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 == " <<root->_kv.first<< " 时平衡因子异常:" << root->_bf << 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 ? rightHeight + 1 : leftHeight + 1;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
};

//测试
int main()
{
	const int N = 1000;
	srand(time(0));
	vector<int> v;
	v.reserve(N);
	for (int i=0;i<N;i++)
	{
		v.push_back(rand());
		cout << v.back() << " ";
	}
	cout << endl;

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

	return 0;
}
Adz1119
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
AVL树
数据联盟
12-23 3408
在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是O(log n)。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL树得名于它的发明者G. M. Adelson-Velsky和Evgenii Landis，他们在1962年的论文《An algorithm for the organization of information》中公开了这一数据结
AVL树（动图详解）
热门推荐
2021dragon的博客
12-02 1万+
AVL树（C++实现）
AVL树详解
北川_的博客
03-09 1570
目录AVL树的概念AVL树节点的定义AVL树如何高度平衡？右单旋左单旋左右双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。 因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)， 即可降低树的高度，从而减少平均搜索长度。 AVL
C++ AVL树
weixin_53946312的博客
01-27 1016
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
【 C++ 】AVL树
bit_zyx的博客
09-04 811
目录 1、底层结构 2、AVL树的概念 3、AVL树节点的定义 4、基本框架 5、AVL树的插入 6、AVL树的旋转 左单旋 右单旋 左右双旋 右左双旋 7、AVL树的验证 8、AVL树的查找 9、AVL树的删除（了解） 10、AVL树的性能 11、源码链接.........
构建AVL树
weixin_43796767的博客
06-02 899
AVL（Adelson-Velskii and Landis）树是满足平衡条件的二叉搜索树：左右子树的深度差不大于1。 一、理解AVL树 目标：通过调整二叉树结构，提高二叉查找的效率。 构建手段：左旋转、右旋转、双旋转。 类似抖葡萄那样，找到合适的节点作为新的根，拎起来抖两下，树结构就得到了调整。 四种失衡情况： 1）LL（left-left）型： 失衡位置从名字可以看出，左子树的左侧挂了太多节点； 此时需要的调整是右旋，顺时针旋转一下，即可恢复平衡。 2）RR（right-right）型 3）LR
AVL树的 插入 和 删除
潜心钻研技术
03-11 1766
AVL树的 插入 和 删除
c++——AVL树
Britney_dark的博客
11-08 1399
如果结果不如你所愿，就在尘埃落定前奋力一搏！
二叉查找树，AVL树
01-07
AVL树（平衡二叉查找树） 具有二叉查找树的全部特性。 每个节点的左子树的高度和右子树高度差值小于等于1（平衡二叉树的性质） 左旋：逆时针旋转两个节点，原先的右节点成为新的父节点，原先的父节点成为原先的右...
AVL.rar_AVL树
09-24
自己写的数据结构的AVL树的算法，大二的时候写的，写的不好请不要见怪
avl.rar_AVL树
09-19
基本的avl树，实现构造插入和删除节点的功能
AVL.zip_AVL树
09-14
实现avl树插入删除搜索操作 可以进行演示
avl.rar_AVL树_树
09-23
AVL树的分析，及其源码。 包括树的左旋右旋操作讲解，和实验报告。
C语言AVL树的创建，功能函数具有，左旋右旋，前序遍历，插入数据等等
最新发布
06-13
AVL树（Adelson-Velsky and Landis Tree）是一种自平衡二叉搜索树，以其发明者G. M. Adelson-Velsky和E. M. Landis命名。它在插入和删除节点之后，通过旋转操作保持树的平衡，从而确保查找、插入和删除操作的时间...
AVL树的模拟实现代码
06-19
AVL树代码
AvlTree.rar_AVL树
09-19
AVL树，里面包含范例，包含基础的AVL树的构建和改进后的AVL树的构建
avl树红黑树java
05-14
AVL树和红黑树都是常见的自平衡二叉搜索树，可以保证在插入、删除节点时树的高度始终在 O(log n) 的范围内。相对于AVL树，红黑树的旋转操作更少，因此在大部分情况下，红黑树的性能表现更优秀一些。 AVL树是一种高度平衡的二叉搜索树，它要求每个节点的左右子树高度差的绝对值不超过 1。AVL树在进行插入、删除操作时，会通过旋转操作来维护平衡性。 红黑树是一种近似平衡的二叉搜索树，它要求满足如下性质： 1. 每个节点要么是红色，要么是黑色； 2. 根节点是黑色； 3. 每个叶子节点（NIL节点）是黑色； 4. 如果一个节点是红色，则它的两个子节点都是黑色； 5. 对于任意一个节点而言，其到叶子节点的每条路径上包含相同数目的黑色节点。 红黑树通过着色和旋转操作来维护平衡性，不同于AVL树，它只保证了最长路径不超过最短路径的两倍。 Java中提供了TreeSet和TreeMap这两种基于红黑树实现的数据结构。其中TreeSet是基于TreeMap实现的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值