带你手撕AVL树 平衡搜索树！ c++ （附原码）

已于 2024-05-12 23:10:25 修改
阅读量1.3k 收藏 23
点赞数 44
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-05-06 11:50:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51216031/article/details/138473236
版权

目录

不会就画图！不会就画图！不会就画图！

一、AVL树

二、旋转

一、分析

二、旋转处理

1、右单旋

2、左单旋

3、双旋

右左旋

左右旋

三、原码

一、AVL树

二叉搜索树如果接近有序，就接近单只，查找效率极低

所以，为了解决这个缺点，控制平衡，所以推出了AVL树
1962年，两位俄罗斯数学家搞出来的，用名字首字母命名
AVL树也叫二叉搜索平衡树
特点：左右子树都是AVL树，左右子树高度差绝对值不超过1（也叫平衡因子）
平衡因子不一定是1，这只是一种实现方案
为什么不是相等，而是不超过1？因为做不到，例如2/4个节点，就不行

二、旋转

一、分析

1、按照搜索树的规则插入
2、更新插入节点的祖先节点的平衡因子
1）插入父亲的左边，父亲平衡因子--
2）插入父亲的左边，父亲平衡因子--
此时，父亲节点平衡因子变化，有三种情况：
a、父亲平衡因子==0，父亲所在子树高度不变，不必往上更新，插入结束
b、父亲平衡因子==1/-1，父亲所在子树高度变化，需要往上更新祖先平衡因子
c、父亲平衡因子==2/-2，父亲所在子树已经不平衡，需要旋转处理

以上情况，为所有变化情况
变化后的平衡因子只可能会出现0/1//-1-2/2的情况
不可能出现其他情况
为什么？
有兴趣的可以看以下过程

插入左边，父亲平衡因子--；插入右边，父亲平衡因子++（默认右边-左边为平衡因子）
如果插入后，父亲节点变为0
说明两种情况：
1、原来为1，插入左边，--，变为0，依旧平衡
2，原来为-1，插入右边，++，变为0，依旧平衡
不用继续往上更新，插入把矮的那边填上了

如果插入后，父亲节点变为1/-1
也说明两种情况：
1、原来为0，插入左边，--，变为-1，高度变化为-1
2，原来为0，插入右边，++，变为1，高度变化为1
需要继续往上更新，因为以父节点所在的子树的高度已经发生了变化
进而影响了上面的平衡

因为，插入前的AVL树本身就是一个平衡树，平衡因子都是0/-1/1
插入后高度变化，要么左边多一个，要么右边多一个
左边多一个，父节点--；右边多一个，父亲节点++
所以，就只可能在0/1/-1的基础上++/--
所以，结果只可能是0/1/-1/2/-2
因此，
高度变为1/-1，一定是从0++/--变来的
如果高度为-2/2，就说明当前树不平衡了，需要旋转调整

那么，什么时候需要调整呢？
当父节点的平衡因子出现2/-2的时候，就不符合AVL树平衡，需调整
如果父亲平衡因子为0，不必继续往上更新，因为不影响上面的平衡

二、旋转处理

这里需要用到左单旋、右单旋的概念

什么时候左旋？什么时候右旋？
左边高了，右单旋；右边高了，左单旋
具体是什么样子呢？

插入左边/右边，更新父节点的平衡因子--/++
然后一直往上更新祖先节点的平衡因子，直到为空
期间，如果遇到某一个祖先节点平衡因子变为2/-2，旋转

当parent为-2时，说明左子树高度高，插入的左子树，此时cur必定为-1；需要右旋
当parent为2时，说明右子树高度高，插入的右子树，此时cur必定为1，需要左旋
对应的情况，把parent节点作为参数，传入对应的左旋和右旋的逻辑函数实现

(相对命名法，相对于某个对象命名)
parent、subL（相对parent的left）、subLR（相对subL的R）


注意：
subRL可能为空
parent可能为根节点，也可能不是根节点

1、右单旋

2、左单旋：


3、双旋：2 -1/ -2 1

右左旋

左右旋

不是单纯的左边高、右边高


三、原码

#pragma once
#pragma once
#include<iostream>
#include<assert.h>
#include<vector>
#include<time.h>

using namespace std;

namespace myspace
{
	template<class K, class V >
	struct AVLreeNode
	{
		AVLreeNode<K, V>* _left;
		AVLreeNode<K, V>* _right;
		AVLreeNode<K, V>* _parent;
		pair<K, V> _kv;
		int _bf;//balence factor

		AVLreeNode(const pair<K,V>& kv)
			:_left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			,_kv(kv)
			,_bf(0)
		{
		}
	};

	template<class K, class V>
	class AVLTree
	{
		typedef AVLreeNode<K, V> Node;
	public:


	

		//插入
		bool Insert(const pair<K,V>& kv)
		{
			if (_root == nullptr)
			{
				_root = new Node(kv);
				return true;
			}

			Node* cur = _root;
			Node* parent = nullptr;

			while (cur)
			{

				if (kv.first < cur->_kv.first)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (kv.first > cur->_kv.first)
				{
					parent = cur;
					cur = cur->_right;
				}
				else//找到相等key
				{
					return false;
				}

			}

			cur = new Node(kv);

				if (kv.first < parent->_kv.first )//插入左
				{
					parent->_left =cur;
				}
				else //插入右
				{
					parent->_right = cur;
				}

				cur->_parent = parent;
				
				//插入完毕
				//往上更新祖先平衡因子
				while (parent)
				{
					if (parent->_left == cur)
					{
						parent->_bf--;
					}
					else
					{
						parent->_bf++;
					}

					if (parent->_bf == 0)
					{
						break;
					}
					else if(parent->_bf == 1 || parent->_bf == -1)//-1/1
					{
						//继续向上更新
						cur = parent;
						parent = parent->_parent;

					}
					else if (parent->_bf == 2 || parent->_bf == -2)//2/-2
					{
						//旋转处理
						if (parent->_bf == -2 && cur->_bf == -1)
						{
							//右旋
							RotateR(parent);

						}
						else if (parent->_bf == -2 && cur->_bf == 1)
						{
							//双旋
							RotateLR(parent);

						}
						else if (parent->_bf == 2 && cur->_bf == 1)
						{
							//左旋

							RotateL(parent);
						}
						else if (parent->_bf == 2 && cur->_bf == -1)
						{
							//双旋转
							RotateRL(parent);
						}

						break;
					}
					else
					{
						return false;
					}

				}

			return true;
		}

		//右旋
		void RotateR( Node* parent)
		{
			//此时parent已经为-2，cur为-1
			Node* subL = parent->_left;
			Node* subLR = subL->_right;

			parent->_left = subLR;
			if (subLR)//subLR可能为空
			{
				subLR->_parent = parent;
			}

			subL->_right = parent;
			Node* ppNode = parent->_parent;
			parent->_parent = subL;

			//注意修改顺序
			if (parent == _root)
			{
				_root = subL;
				_root->_parent = nullptr;
			}
			else
			{
				if (ppNode->_left == parent)
				{
					ppNode->_left = subL;
				}
				else
				{
					ppNode->_right = subL;
				}
				subL->_parent = ppNode;
			}

			subL->_bf = parent->_bf  = 0;

		}

		//左旋
		void RotateL( Node* parent)
		{
			//此时parent已经为2，cur为1
			Node* subR = parent->_right;
			Node* subRL = subR->_left;


			parent->_right = subRL;
			if (subRL)
			{
				subRL->_parent = parent;
			}

			subR->_left = parent;

			Node* ppNode = parent->_parent;
			parent->_parent = subR;

			if (parent == _root)
			{
				 _root = subR;
				_root->_parent = nullptr;
			}
			else
			{
				if (ppNode->_left == parent)
				{
					ppNode->_left = subR;
				}
				else
				{
					ppNode->_right = subR;
				}
				subR->_parent = ppNode;
			}


			subR->_bf = parent->_bf  = 0;

		}

		//右左旋
		void RotateRL( Node* parent)
		{
			//对折线型插入，进行判断控制
			//插入之后，进行控制

			Node* subR = parent->_right;
			Node* subRL = subR->_left;
			
			int bf = subRL->_bf;

			RotateR(subR);
			RotateL(parent);

			subRL->_bf = 0;
			if (bf == 1)//右边插入,右节点给了右边
			{
				subR->_bf = 0;
				parent->_bf = 0;
			}
			else if (bf == -1)//左边插入
			{
				subR->_bf = 0;
				parent->_bf = 1;
			}
			else //字节本身，只有三个节点情况
			{
				subR->_bf = 0;
				parent->_bf = 0;
			}
			
		}

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

			RotateL(subL);
			RotateR(parent);

			subLR->_bf = 0;
			if (bf == 1)//右边插入
			{
				subL->_bf = 0;
				parent->_bf = -1;
			}
			else if (bf == -1)//插入左边
			{
				subL->_bf = 1;
				parent->_bf = 0;
			}
			else 
			{
				subL->_bf = 0;
				parent->_bf = 0;
			}
			
		}
		
		//查找
		Node* find(const K& key)
		{

			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}

				if (key < cur->_kv.first)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					parent = cur;
					cur = cur->_right;
				}
			}

			//走到这，没有找到
			return nullptr;

		}

		//中序
		void Inorder()
		{
			_Inorder(_root);
			cout << endl;
		}

		int size()
		{
			return  _size(_root);
		}

		bool isBalance()
		{
			return _is_balance(_root);
		}

		int Height()
		{
			return _Height(_root);
		}

	private:

		bool _is_balance(Node* root)
		{

			if (root == nullptr)
			{
				return true;
			}
			//判断平衡：左右两树相减
			//求得每一棵树的左右子树高度差
			int leftHight = _Height(root->_left);
			int rightHeight = _Height(root->_right);

			if (abs( leftHight - rightHeight ) >= 2 )//说明不平衡 
			{
				cout << "insert->" <<root->_kv.first << endl;//输出是那个节点出问题
				return false;
			}
			
			//顺便检查每一个节点的平衡因子
			if (rightHeight - leftHight != root->_bf)
			{
				cout << root->_kv.first << endl;//平衡因子出问题节点位置
				return false;
			}			

			return _is_balance(root->_left) && _is_balance(root->_right);
		}

		int _Height(Node* root)
		{
			//求高度？
			//左树和右树的高度差

			if (root == nullptr)
			{
				return 0;
			}

		/*	int leftHeight = _Height(root->_left) + 1;
			int rightHeight = _Height(root->_right) + 1;
			return max(leftHeight, rightHeight);*/
			return max(_Height(root->_left), _Height(root->_right)) + 1;
		}



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

		void _Inorder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_Inorder(root->_left);
			cout << root->_kv.first << ":" << root->_kv.second << endl;
			_Inorder(root->_right);
		}

	private:
		Node* _root = nullptr;
	};

	void AVLTreetest()
	{

		int a[] = { 1,2,3};
		AVLTree<int, int> t;
		for (auto e : a)
		{
			t.Insert({ e,e });
		}


		t.Inorder();
		cout << t.size() << endl;
		cout << t.Height() << endl;
		
	}

	void AVLTreetest1()
	{

		int a[] = { 8, 3, 1, 10, 6, 4};
		AVLTree<int, int> t;
		for (auto e : a)
		{
			t.Insert({ e,e });
		}

		int b = 0;

		t.Inorder();
		cout << t.isBalance() << endl;

	}



	void AVLTreetest2()
	{

		int n = 10000000;//1000万个节点
		srand(time(0));
		vector<int> v;
		v.reserve(n);
		for (int i  =0 ;i<n;++i)
		{
			v.push_back(rand() + i);
		}

		size_t T1 = clock();
		AVLTree<int, int> t;
		for (auto e : v)
		{
			t.Insert(make_pair(e,e));
		}
		size_t T2 = clock();

		size_t T3 = clock();
		for (auto e : v)
		{
			t.find(e);
		}
		size_t T4 = clock();

		cout << "insert:" << T2 - T1 << endl;
		cout << "find:" << T4 - T3 << endl;
		

	}



}

二十5画生
关注
  • 44
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
AVL树 C++ 实现
03-05
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
【数据结构】AVL树——平衡二叉搜索树
2301_79796701的博客
05-25 1209
平衡树：左子树的高度等于右子树的高度不平衡树：左子树的高度不等于等于右子树的高度二叉搜索树很难是一颗平衡树。对二叉树进行插入和删除的操作，或插入大量的数据不够随机，都会是使二叉搜索树不够平衡。极端情况下，二叉树会退化成类似链表的结构，那么二叉搜索树查询数据的效率荡然无存。在二叉树的基础上加入平衡的概念就是平衡二叉搜索树，也叫AVL树。AVL树也不是一颗绝对的平衡树，AVL树的平衡是相对的，它允许左子树和右子树的高度为 1 ，但不能超过 1。
手把手教你实现AVL树、平衡二叉树
weixin_61857742的博客
04-07 1392
今天，小编带大家一起来学习平衡二叉树（AVL树）吧。以下就简称AVL树了。 想必能点开这篇博客的朋友都是极度深爱计算机的，那今天就让我们一起揭开AVL树的神秘面纱吧！ 目录 一.基本概念 二.实现原理 （一）插入左子树 ①插入左子节点 ②插入右子节点 （二）插入右子树 ①插入右子节点 ②插入左子节点 （三）左旋转 （四）右旋转 三.代码实现 一.基本概念 AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis。 AVL树是搜索二叉树的一
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2508
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
C/C++数据结构（十一）—— 平衡二叉树（AVL树）
热门推荐
Edison's 小宇宙
01-19 2万+
平衡二叉树又称为 AVL 树，其实就是一颗 平衡的二叉搜索树，解决了二叉搜索树的不平衡问题。
avl.rar_avl_平衡树
09-20
avl平衡树做的电话号码系统！！！可支持查询，修改，删除等操作
二叉搜索树，红黑树，AVL平衡树，B树
05-08
完整实现二叉搜索树，红黑树，AVL平衡树，B树的搜索插入删除基本功能和其它功能。红黑树和B树参考自算法导论。
AVL（平衡二叉检索）树模板（带template）
08-17
AVL树模板，支持操作如下 template struct BSTNode { T data; int h; BSTNode<T> * lchild, *rchild; }; template class AVLTree { public: AVLTree() :root(NULL),node_num(0) {} ~AVLTree() { Release...
基于C++ AVL树的航空客运订票系统【100012693】
06-12
实现的功能分有七个模块：① 航班记录的录入 ② 航班数据的加载 ③ 航班记录的清除 ④ 航班的查询 ⑤ 航班的订票业务 ⑥ 航班的退票业务 ⑦ 航班数据的保存。
6-1 求二叉树高度(C语言解法)(PTA)
u012137663的博客
05-23 297
很基本的利用递归的思想求二叉树的高度,相关思路已写在代码内部。
c语言IO
最新发布
欢迎来到jiantaoyab博客
05-26 199
老是忘记c语言IO操作，故写个文章记录一下。
【C++】多态（多态的原理）
EWIAW_ilove的博客
05-23 899
那么知道了什么是多态，现在就来讲解一下多态是如何定义和实现的。首先我们直接来看一段构成多态的代码。看到这里，可能会有同学以及有点分不清了，因为多态有重写，继承有重定义，同时函数又有重载，初学者可能很容易搞混。所以在这里我们进行一个讲解。两个函数在同一个作用域中。函数名相同，参数不同（类型不同，顺序不同，个数不同）。两个函数分别在基类和派生类中。两个函数都是虚函数。函数名、返回类型、参数列表相同（两个例外除外）。两个函数分别在基类和派生类中。函数名相同。不符合重写就是重定义。
【C语言】16进制输出%x和%0x的区别
2301_80069984的博客
05-20 273
后面跟着一个数字，表示以十六进制形式输出整数，并且指定输出的宽度为指定的数字。如果输出的十六进制数位数不足指定的宽度，会在前面用零来填充。：用于以十六进制形式输出整数，不带任何宽度或填充零的设置。输出的十六进制数可能不足两位，不足时不会在前面填充零。被格式化为宽度为 4，不足 4 位时在前面用零填充，因此输出为。的区别在于是否指定了输出的宽度和是否在不足宽度时填充零。在输出宽度和填充零方面的不同效果。举个例子，假设有一个整数。而在第二个例子中，使用。在第一个例子中，使用。
Ubuntu16.04 opencv环境搭建（C++）
hkj887tg的博客
05-21 2730
Ubuntu下vscode跑opencv程序环境搭建。
STL---unordered set和unordered multiset【无序集合】
m0_75266675的博客
05-20 593
unordered set和unordered multiset【无序集合】
C++质数的那些事（判断指数、区间筛质数、互质等等）
A1063348628的博客
05-23 221
质数的定义：若一个正整数除了1和它自身之外不能被任何自然数整除，则该数称为质数，也叫素数。否则为合数。质数的性质：质数的分布较为稀疏，对于一个足够大的数S，不超过S的质数大约有个，也就是说每InN个数约有一个质数，代码： 二、筛出给定区间的质数 代码（欧拉筛（线性筛））： 三、判断两个整数是否互质 代码： 代码会随个人学习进行持续更新，谢谢您的观看！
【C++风云录】解码科学模拟：环境保护与污染控制
记录我的学习历程
05-20 855
本文详尽而全面地介绍了这六个编程库的功能、使用方法以及应用案例。通过对比研究，读者将能够明白这些工具如何在各自的专业领域中发挥作用，并掌握如何根据具体需求选择使用哪一个。
Codeforces Round 821 (Div. 2) C. Parity Shuffle Sorting （构造之全变成一样的）
2302_79440616的博客
05-23 906
并且注意读题，奇偶数是操作相反而不是不能操作，本人读题的时候就读了半句话发现题做不出来。需要注意的是，你并不需要尽量减少运算次数。，那么就可以取一个特殊情况让所有数都相等，这样就是简单的构造方法。每个测试用例的第一行包含一个整数。，如果中间的任何数和a[n]相加等于偶数，就意味着要让。以相加为偶数为例，之后，如果中间的任何数和。对于每个测试用例，在第一行打印一个整数。相等，如果两者相加是偶数，那么就是让。，所以之后的目标就是让所有数都等于。如果有多个解，请打印任意一个。，相加等于奇数时同理。
avl树c++
05-24
AVL树是一种自平衡二叉搜索树，它的每个节点存储一个键值对，且每个节点的左子树和右子树的高度差不超过1。这种平衡特性使得AVL树在查找、插入和删除操作方面都有很好的性能表现。 下面是一个简单的AVL树的C++实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

二十5画生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值