二叉树进阶 ---AVL树的介绍 AVL树插入的4种情况 (详细图解+代码演示)

最新推荐文章于 2023-06-20 00:29:35 发布
最新推荐文章于 2023-06-20 00:29:35 发布
阅读量309 收藏 2
点赞数 2
分类专栏： C++语法/实现/相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45818891/article/details/114363713
版权

之前几篇对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是：
其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。

不知道大家还记不记得, 之前说map和set都是用红黑树实现的, 我们今天先不看红黑树, 先来看看高度平衡的AVL树

文章目录

AVL树的介绍

1. 概念

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

因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：

当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

因此, 平衡二叉树(AVL树)诞生了

2. 定义

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

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

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在O( l o g 2 n {log_2{n}} log2​n ) ，搜索时间复杂度O( l o g 2 n {log_2{n}} log2​n )。

AVL树在二叉搜索树的基础上新增了平衡因子, 平衡因子的绝对值要<=1
平衡因子: 右子树的高度 - 左子树高度

给出一个例子 :
在这里插入图片描述

3. AVL树结点的定义

AVL树采用 数据 + 三叉链 + 平衡因子的结构

//平衡二叉树结点
template<class T>
struct AVLTreeNode {
	//数据
	T _data;
	//左右孩子指针
	AVLTreeNode<T>* _left;
	AVLTreeNode<T>* _right;
	//父节点指针
	AVLTreeNode<T>* _parent;
	//平衡因子
	int _bf;

	AVLTreeNode(const T& val = T())
		: _data(val)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{}
};

AVL树的插入

AVL树的重中之重也就是它的插入操作了, 接下来我们一起来看

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。

那么AVL树的插入过程可以分为两步：

  • 1. 按照二叉搜索树的方式插入新节点
  • 2. 调整节点的平衡因子

1. 二叉搜索树方式插入新节点

与之前二叉搜索树的插入一样, 也是搜索+插入的过程, 只不过要多连接一个parent指针

	bool insert(const T& val) {
		//空树, 创建根节点
		if (_root == nullptr) {
			_root = new Node(val);
			return true;
		}
		
		//搜索: 不包含重复数据, 左子树小于根, 右子树大于根
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur) {
			parent = cur;
			if (val == cur->_data)
				return false;
			else if (val < cur->_data)
				cur = cur->_left;
			else
				cur = cur->_right;
		}
		//循环走完之后, cur走到nullptr, 而parent就是要插入位置的父节点
		
		//创建新节点, 判断在父节点的哪边, 然后插入
		cur = new Node(val);
		if (val < parent->_data)
			parent->_left = cur;
		else
			parent->_right = cur;

		//最后连接parent指针
		cur->_parent = parent;
	}

2. 调整平衡因子

直接给出图解
在这里插入图片描述
在这里插入图片描述

我们先把这部分写出代码, 如下 :

		//更新平衡因子
		//更新范围: 从parent一直到root, 这条路径上的祖先结点
		while (parent) {
			if (parent->_left == cur) {
				//左子树插入, 左边高度+1, 平衡因子-1
				parent->_bf--;
			}
			else {
				//右子树插入, 右边高度+1, 平衡因子+1
				parent->_bf++;
			}

			//判断parent的平衡因子
			if (parent->_bf == 0) {
				//parent结点某一个子树补齐
				//parent的高度并没有发生变化, 所以对上层没有影响, 结束循环
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1) {
				//说明插入之前parent的平衡因子是0
				//插入之后+1/-1, 高度发生了变化
				//要继续向上更新
				cur = parent;
				parent = parent->_parent;
			}
			else {
				//平衡因子为2/-2, 要调整avl树, 重新达到平衡
			}

3. AVL树的旋转

右旋

直接给出图解
在这里插入图片描述

下面给出代码:

	//右旋
	void rotateR(Node* parent) {
		//左子树的根结点
		Node* subL = parent->_left;
		//左子树的右子树的根节点
		Node* subLR = subL->_right;
		//parent的父结点
		Node* grandp = parent->_parent;


		//修改6个链接
		//一对一对的写, 比较容易写出来
		subL->_right = parent;
		parent->_parent = subL;
		
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		//如果parent为根节点, 需要更新根节点
		if (parent == _root) {
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
			//链接grandp
			if (grandp->_left == parent)
				grandp->_left = subL;
			else
				grandp->_right = subL;
			subL->_parent = grandp;
		}

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

可以对着代码看图, 更容易理解

左旋

在这里插入图片描述

左旋代码

	//左旋
	void rotateL(Node* parent) {
		//右子树的根节点
		Node* subR = parent->_right;
		//右子树的左子树的根节点
		Node* subRL = subR->_left;
		//parent的父节点
		Node* grandp = parent->_parent;

		//修改6个指针链接
		subR->_left = parent;
		parent->_parent = subR;
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		//判断parent是否为根节点
		if (parent == _root) {
			_root = subR;
			subR->_parent = nullptr;
		}
		else {
			//链接grandp
			if (grandp->_left == parent)
				grandp->_left = subR;
			else
				grandp->_right = subR;
			subR->_parent = grandp;
		}

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

左右双旋

在这里插入图片描述

代码如下 :

else if (parent->_bf == -2 && cur->_bf == 1) {
					//记录subLR的平衡因子
					Node* subLR = cur->_right;
					int bf = subLR->_bf;

					//左边的右边高: 左右双旋
					rotateL(cur);
					rotateR(parent);

					//  cur  subLR  p
					//双旋之后, subLR是新的根, subLR的左子树放在cur的右边, 右子树放在p的左边
					if (bf == -1) {
						//subLR的左边高
						cur->_bf = 0;
						parent->_bf = 1;
					}
					else if (bf == 1) {
						//subLR的右边高
						parent->_bf = 0;
						cur->_bf = -1;
					}
				}

右左双旋

在这里插入图片描述

代码如下 :

else if (parent->_bf == 2 && cur->_bf == -1) {
					Node* subRL = cur->_left;
					int bf = subRL->_bf;
					
					//右边的左边高: 右左双旋
					rotateR(cur);
					rotateL(parent);

					//  p  subRL  cur
					//双旋之后, subRL是新的根, subRL的左子树放在p的右边, 右子树放在cur的左边
					if (bf == -1) {
						//subRL的左边高
						parent->_bf = 0;
						cur->_bf = 1;
					}
					else if (bf == 1) {
						//subRL的右边高
						cur->_bf = 0;
						parent->_bf = -1;
					}
				}

到这里插入接口就结束了, 下面给出完整的插入代码

完整插入代码

	bool insert(const T& val) {
		//空树, 创建根节点
		if (_root == nullptr) {
			_root = new Node(val);
			return true;
		}
		
		//搜索: 不包含重复数据, 左子树小于根, 右子树大于根
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur) {
			parent = cur;
			if (val == cur->_data)
				return false;
			else if (val < cur->_data)
				cur = cur->_left;
			else
				cur = cur->_right;
		}

		cur = new Node(val);
		if (val < parent->_data)
			parent->_left = cur;
		else
			parent->_right = cur;

		//连接parent指针
		cur->_parent = parent;

		//更新平衡因子
		//更新范围: 从parent一直到root, 这条路径上的祖先结点
		while (parent) {
			if (parent->_left == cur) {
				//左子树插入, 左边高度+1, 平衡因子-1
				parent->_bf--;
			}
			else {
				//右子树插入, 右边高度+1, 平衡因子+1
				parent->_bf++;
			}

			//判断parent的平衡因子
			if (parent->_bf == 0) {
				//parent结点某一个子树补齐
				//parent的高度并没有发生变化, 所以对上层没有影响, 结束循环
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1) {
				//说明插入之前parent的平衡因子是0
				//插入之后+1/-1, 高度发生了变化
				//要继续向上更新
				cur = parent;
				parent = parent->_parent;
			}
			else {
				//平衡因子为2/-2, 要调整avl树, 重新达到平衡
				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) {
					//记录subLR的平衡因子
					Node* subLR = cur->_right;
					int bf = subLR->_bf;

					//左边的右边高: 左右双旋
					rotateL(cur);
					rotateR(parent);

					//  cur  subLR  p
					//双旋之后, subLR是新的根, subLR的左子树放在cur的右边, 右子树放在p的左边
					if (bf == -1) {
						//subLR的左边高
						cur->_bf = 0;
						parent->_bf = 1;
					}
					else if (bf == 1) {
						//subLR的右边高
						parent->_bf = 0;
						cur->_bf = -1;
					}
				}
				else if (parent->_bf == 2 && cur->_bf == -1) {
					Node* subRL = cur->_left;
					int bf = subRL->_bf;
					
					//右边的左边高: 右左双旋
					rotateR(cur);
					rotateL(parent);

					//  p  subRL  cur
					//双旋之后, subRL是新的根, subRL的左子树放在p的右边, 右子树放在cur的左边
					if (bf == -1) {
						//subRL的左边高
						parent->_bf = 0;
						cur->_bf = 1;
					}
					else if (bf == 1) {
						//subRL的右边高
						cur->_bf = 0;
						parent->_bf = -1;
					}
				}

				break;
			}
		}
		return true;
	}

	//右旋
	void rotateR(Node* parent) {
		//左子树的根结点
		Node* subL = parent->_left;
		//左子树的右子树的根节点
		Node* subLR = subL->_right;
		//parent的父结点
		Node* grandp = parent->_parent;


		//修改6个链接
		subL->_right = parent;
		parent->_parent = subL;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		//如果parent为根节点, 需要更新根节点
		if (parent == _root) {
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
			//链接grandp
			if (grandp->_left == parent)
				grandp->_left = subL;
			else
				grandp->_right = subL;
			subL->_parent = grandp;
		}

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

	//左旋
	void rotateL(Node* parent) {
		//右子树的根节点
		Node* subR = parent->_right;
		//右子树的左子树的根节点
		Node* subRL = subR->_left;
		//parent的父节点
		Node* grandp = parent->_parent;

		//修改6个指针链接
		subR->_left = parent;
		parent->_parent = subR;
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		//判断parent是否为根节点
		if (parent == _root) {
			_root = subR;
			subR->_parent = nullptr;
		}
		else {
			//链接grandp
			if (grandp->_left == parent)
				grandp->_left = subR;
			else
				grandp->_right = subR;
			subR->_parent = grandp;
		}

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

AVL树的其他接口

1. 中序遍历

老生常谈了, 直接上代码吧

	//中序遍历
	void inoder() {
		_inorder(_root);
		cout << endl;
	}

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

		_inorder(root->_left);
		cout << root->_data << " ";
		_inorder(root->_right);
	}

2. 判断是否为AVL树

遍历整棵树, 如果每个结点的平衡因子都在[-1, 1]区间, 则是AVL树, 否则不是

为了检查平衡因子更新错误的问题, 在遍历每一个结点的时候先计算并判断当前结点的平衡因子是否正确, 如果不正确, 输出结点数据信息并退出, 正确则继续遍历

	//判断平衡二叉树
	bool isBalance() {
		return _isBalance(_root);
	}

	bool _isBalance(Node* root) {
		if (root == nullptr)
			return true;

		int rightHeight = getHeight(root->_right);
		int leftHeight = getHeight(root->_left);

		//判断平衡因子的值是否正确
		//bf = right - left
		if (root->_bf != rightHeight - leftHeight) {
			//平衡因子更新有问题
			cout << "当前位置: " << root->_data << " bf: " << root->_bf << endl;
			cout << "left: " << leftHeight << " right: "<< rightHeight << endl;
			return false;
		}

		return abs(root->_bf) < 2
			&& _isBalance(root->_left)
			&& _isBalance(root->_right);
	}

	//获取高度
	int getHeight(Node* root) {
		if (root == nullptr)
			return 0;
		int left = getHeight(root->_left);
		int right = getHeight(root->_right);
		return left > right ? left + 1 : right + 1;
	}
殇&璃
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
AVL树的插入操作
Rinki123456的博客
08-08 2724
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：它的左右子树都是AVL树。......
IT笔试面试--红黑树详细解析，代码+图解
04-14
红黑树是一种自平衡二叉查找树，它的统计性能要好于平衡二叉树（AVL 树），因此，红黑树在很多地方都有应用。在 C++ STL 中，很多部分（包括 set, multiset, map, multimap）应用了红黑树的变体（SGI STL 中的红黑树...
AVL树的插入
D_tom_cat的博客
06-02 368
原文连接：https://www.geeksforgeeks.org/avl-tree-set-1-insertion/ AVL是一个自平衡的二叉搜索树(BST)，和普通二叉搜索树的区别是AVL树的所有节点的左子树和右子树的高度差不大于1. 一个AVL树的例子： 上面是一个AVL树因为每一个树节点的左子树和右子树的高度差小于或者等于1. 一个不是AVL树的例子： 上面不是一个AVL树因为左子树...
二叉搜索树
精致的灰的博客
11-16 4716
文章目录一、什么是二叉搜索树1.1. 二叉搜索树查找的时间复杂度二、二叉搜索树的实现2.1. 接口概览2.2. 构造函数和析构函数构造和拷贝构造重载=运算符析构函数2.3. 插入节点的函数非递归实现递归实现2.4. 查找的函数非递归实现递归实现2.5. 删除节点的函数非递归实现递归实现三、二叉搜索树的应用模型及实例3.1. k模型宿舍门禁3.2. KV模型：中英文对应字典统计次数 一、什么是二叉搜索树 二叉搜索树又称为二叉排序树，是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有结点的值都小
【数据结构】——二叉搜索树
sjp11的博客
10-31 6447
目录 前言 二叉搜索树的概念 二叉搜索树的操作 树的节点实现 搜索树的基本结构 插入数据 查找 删除 拷贝构造函数 二叉搜索树的应用 前言 在c++中的容器里map和set的学习需要二叉搜索树的铺垫，也为后边的的红黑树和AVL树做铺垫，也就是说，今天主要讲搜索树的基本结构和应用。 二叉搜索树的概念 所有的根节点大于左子树的节点，小于右子树的节点的二叉树就叫做二叉搜索树。 二叉搜索的性质： 如果左子树不为空，则左子树上的所有节点都小于根节点。 如果右子树不为...
DataStructure-UsingPython：《图解数据结构使用python》的范例程序代码
02-05
5. **树**：树是一种非线性的数据结构，包括二叉树、平衡树（如AVL树、红黑树）等。Python中通常通过类来实现树结构，每个节点包含数据、左子节点和右子节点的引用。 6. **图**：图是由顶点和边构成的抽象概念，...
DS-Algos-Kotlin：Kotlin中的数据结构和算法
02-15
- **树**：包括二叉树、平衡树（如AVL树、红黑树）等，用于高效搜索和排序。 - **图**：表示对象之间的关系，支持遍历和最短路径计算。 3. **算法** 算法是解决问题的步骤或指令集。DS-Algos-Kotlin可能涵盖了...
数据结构算法图解-第七章图例.docx
12-09
平衡二叉树（如AVL树）确保了左右子树的高度差不超过1，从而保证了高效的查找、插入和删除操作。当树失去平衡（如图7-14(b)所示）时，可以通过旋转操作（如RR型调整）来重新平衡树，如图7-14(c)所示，这是维护平衡...
算法图解笔记以及代码文件.zip
08-09
4. **树算法**：如二叉搜索树、AVL树、红黑树等平衡二叉树，以及最小生成树的Prim算法和Kruskal算法。这些数据结构和算法在数据存储和检索中起着关键作用。 5. **动态规划**：用于解决最优化问题，如背包问题、最长...
AVL树的插入操作（四种情况）
PYH的博客
08-25 4334
主要内容为AVL树的插入操作（不包含重复值），主要分为四种情况
⚡【C++要笑着学】(29) BS树：二叉搜索树的概念 | BST 时间复杂度 | BST 的改良方案 | BST 的定义 | 查找插入和删除 | BST 的应用 | K 模型 | KV 模型
有道无术, 术尚可求。有术无道, 止于术。
04-10 2712
本章倒回数据结构专栏去讲解搜索二叉树，主要原因是讲解 map 和 set 的特性需要二叉搜索树做铺垫，理解搜索二叉树有助于更好地理解 map 和 set 的特性。第二个原因是为了后期讲解查找效率极高的平衡搜索二叉树，随后再讲完红黑树，我们就可以模拟实现 map 和 set 了。二叉树的基础知识讲解在我的《树锯结构》专栏中有写，这里放上链接方便复习。
二叉树搜索树详解
choudan8888的博客
08-29 623
二叉搜索树的特点 二叉搜索树:二叉树的每一个结点最多有两个子数的树结构，也就是说除了叶子结点，其余结点最多有两个子节点 二叉搜索树的性质 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树 二叉搜索树的时间复杂度 增：循环遍历每个节点，比较各节点的值，直到找到相应位置，时间...
二叉树查找的时间复杂度
热门推荐
风从北边来的博客
10-30 5万+
原文链接：https://blog.csdn.net/li_huai_dong/article/details/79911069 给定值的比较次数等于给定值节点在二叉排序树中的层数。如果二叉排序树是平衡的，则n个节点的二叉排序树的高度为Log2(n+1),其查找效率为O(Log2n)，近似于折半查找。如果二叉排序树完全不平衡，则其深度可达到n，查找效率为O(n)，退化为顺序查找。一般的，二叉排序...
数据结构——平衡二叉树(AVL树)之插入
weixin_57023347的博客
06-17 7310
文章目录前言一.定义二.基本操作1.查找，删除2.插入(如何调整)如何调整代码实现插入 前言 首先我们来思考一下一个普通二叉树保存数据，如果想查找一个数据，由于普通二叉树保存数据是随机的，要找到数据的时间复杂度为O(n)。后面为了方便 ，我们又学习二叉搜索树，它的定义是将比根节点小的数放左边，比根节点大的数放右边，并且每一课子树都是二叉搜索树这样使得数据在树上存储有一定 的规律，在一定情况下查找起来很方便。但是，二叉搜索数当给出数据的顺序不同时，二叉搜索树也会不同。比如如果给出的序列为{1，2，3，4，5}
AVL树原理以及插入代码讲解（插入操作画图~细节）
最新发布
2201_75352618的博客
06-20 753
AVL 树是一种平衡搜索二叉树，得名于其发明者的名字（ Adelson-Velskii 以及 Landis）。（可见名字长的好处，命名都能多占一个字母出来）。我们以SGI版本AVL树先来查看树中每个结点内容。左子树与右子树指针我们不做过多介绍。我们存储AVL树是一种存储key_value数据的树，所以我们使用pair库中类型存储数据。
【C++】AVL树（插入）
weixin_56916549的博客
01-26 901
AVL树的概念 平衡化旋转 右单旋转 左单旋转 先左后右双旋转 先右后左双旋转 AVL树的插入 根据BST树规则进行节点插入 平衡化处理 重新连接节点 完整的插入函数代码 AVL树的验证 AVL树的性能
树的类型与二叉树定义 - 数据结构第六章概览
"这篇资料是关于数据结构课程中的第六章——树和二叉树的内容，主要探讨了树的类型定义、基本术语、二叉树的性质、存储结构、遍历方法以及线索二叉树、树和森林的关系，还提到了哈夫曼树与哈夫曼编码。特别强调了树...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

殇&璃

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

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

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

打赏作者

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

抵扣说明：

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

余额充值