[C++系列] 77. 详解AVL平衡二叉搜索树

最新推荐文章于 2023-08-19 09:59:14 发布

Ypuyu

最新推荐文章于 2023-08-19 09:59:14 发布

阅读量753

点赞数 1

分类专栏： [C++系列] 文章标签： C++

本文链接：https://blog.csdn.net/yl_puyu/article/details/104223118

版权

[C++系列] 专栏收录该内容

91 篇文章 26 订阅

订阅专栏

文章目录

1. AVL树的概念

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

因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

平衡二叉搜索树在实现方面挺困难的，在学习中这发现这张图挺不错的，要知道所学习的数据结构学的是什么，是干啥的这点很关键啊。
在这里插入图片描述
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

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

在这里插入图片描述
如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 $O(log_2 n)$ ，搜索时间复杂度 $O(log_2 n)$ 。

2. AVL树节点的定义

AVL树节点的定义：

template<class T>
struct AVLTreeNode {
    AVLTreeNode(const T& data)
        : _pLeft(nullptr), _pRight(nullptr), _pParent(nullptr)
        , _data(data), _bf(0)
    {}

    AVLTreeNode<T>* _pLeft;   // 该节点的左孩子
    AVLTreeNode<T>* _pRight;  // 该节点的右孩子
    AVLTreeNode<T>* _pParent; // 该节点的双亲
    T _data;
    int _bf;                  // 该节点的平衡因子
};

3. AVL树的插入与失衡

AVL 树就是在二叉搜索树的基础上引入了平衡因子:
在这里插入图片描述
普通二叉搜索树与AVL树：

因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

按照二叉搜索树的方式插入新节点
调整节点的平衡因子并检测是否破坏了AVL树的平衡性

pCur 插入后，pParent 的平衡因子一定需要调整，在插入之前，pParent的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：

如果 pCur 插入到 pParent 的左侧，只需给 pParent 的平衡因子 -1 即可
如果 pCur 插入到 pParent 的右侧，只需给 pParent 的平衡因子 +1 即可

此时：pParent 的平衡因子可能有三种情况：0，正负1，正负2

如果 pParent 的平衡因子为 0，说明插入之前 pParent 的平衡因子为正负1，插入后被调整成0，此时满足AVL树的性质，插入成功
如果 pParent 的平衡因子为正负1，说明插入前 pParent 的平衡因子一定为0，插入后被更新成正负1，此时以pParent为根的树的高度增加，需要继续向上更新
如果pParent的平衡因子为正负2，则pParent的平衡因子违反平衡树的性质，需要对其进行旋转处理

失衡情况展示：
在这里插入图片描述

4. AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：

4.1 新节点插入较高左子树的左侧—左左：右单旋

在这里插入图片描述

上图在插入前，AVL 树是平衡的，新节点插入到 30 的左子树(注意：此处不是左孩子)中，30 左子树增加了一层，导致以 60 为根的二叉树不平衡，要让 60 平衡，只能将60左子树的高度减少一层，右子树增加一层，即将左子树往上提，这样 60 转下来，因为 60 比 30 大，只能将其放在 30 的右子树，而如果 30 有右子树，右子树根的值一定大于 30，小于 60，只能将其放在 60 的左子树，旋转完成后，更新节点的平衡因子即可。在旋转过程中，有以下几种情况需要考虑：

30 节点的右孩子可能存在，也可能不存在
60 可能是根节点，也可能是子树
如果是根节点，旋转完成后，要更新根节点
如果是子树，可能是某个节点的左子树，也可能是右子树

在这里插入图片描述

4.2 新节点插入较高右子树的右侧—右右：左单旋

在这里插入图片描述
实现及情况考虑可参考右单旋。

4.3. 新节点插入较高左子树的右侧—左右：先左单旋再右单旋

在这里插入图片描述
将双旋变成单旋后再旋转，即：先对 30 进行左单旋，然后再对 90 进行右单旋，旋转完成后再考虑平衡因子的更新。

4.4. 新节点插入较高右子树的左侧—右左：先右单旋再左单旋

在这里插入图片描述
参考右左双旋。

5. AVL树旋转总结：

假如以 pParent 为根的子树不平衡，即 pParent 的平衡因子为2或者-2，分以下情况考虑

pParent 的平衡因子为 2，说明 pParent 的右子树高，设 pParent 的右子树的根为 pSubR 当 pSubR 的平衡因子为 1 时，执行左单旋当 pSubR 的平衡因子为 -1 时，执行右左双旋
pParent 的平衡因子为 -2，说明 pParent 的左子树高，设 pParent 的左子树的根为 pSubL 当 pSubL 的平衡因子为 -1 是，执行右单旋当 pSubL 的平衡因子为 1 时，执行左右双旋旋转完成后，原 pParent 为根的子树个高度降低，已经平衡，不需要再向上更新。

6. AVL树的删除

删除节点比插入节点的操作还要稍微复杂一点，因为插入时，进行一次平衡处理（一次平衡处理可能包含多次旋转），整棵树都会处于平衡状态，而在删除时，需要进行多次平衡处理，才能保证树处于平衡状态

AVL 树的删除操作前半部分和二叉搜索树相同，只不过删除后要检查树是否失去平衡，如果失衡就需要重新调整平衡，并更新节点高度，总的来说可以分为如下几种情况：
在这里插入图片描述
AVL 树也是二叉搜索树，即按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的是，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

若删除导致父节点失衡，那么一定删除的是较短的那个叶子节点。
在这里插入图片描述

7. AVL树的实现

#include <iostream>

using namespace std;

template<class T>
struct AVLNode {
	AVLNode(const T& val = T())
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(val)
		, _bf(0)
	{}

	AVLNode<T>* _left;
	AVLNode<T>* _right;
	AVLNode<T>* _parent;

	T _data;
	int _bf;	// 平衡因子（Balance Factor）
};

template<class T>
class AVLTree {
public:
	typedef AVLNode<T> Node;

	bool Insert(const T& val) {
		// 1. 先按照二叉搜索树的规则将节点插入到AVL树中
		if (_root == nullptr) {
			_root = new Node(val);
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur) {
			if (val > cur->_data) {
				parent = cur;
				cur = cur->_right;
			}
			else if (val < cur->_data) {
				parent = cur;
				cur = cur->_left;
			}
			else 
				return false;
		}

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

		// 2. 新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，
		//    并检测是否破坏了AVL树的平衡性
		/*
			pCur 插入后，pParent 的平衡因子一定需要调整，在插入之前，pParent
			的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：
			  1. 如果 pCur 插入到 pParent 的左侧，只需给 pParent 的平衡因子 -1 即可
			  2. 如果 pCur 插入到 pParent 的右侧，只需给 pParent 的平衡因子 +1 即可

			此时：pParent 的平衡因子可能有三种情况：0，正负1， 正负2
			  1. 如果 pParent 的平衡因子为 0，说明插入之前 pParent 的平衡因子为正负1，插入后被调整成0，
				 此时满足AVL树的性质，插入成功
			  2. 如果 pParent 的平衡因子为正负1，说明插入前 pParent 的平衡因子一定为0，插入后被更新成正负1，
				 此时以pParent为根的树的高度增加，需要继续向上更新
			  3. 如果pParent的平衡因子为正负2，则pParent的平衡因子违反平衡树的性质，需要对其进行旋转处理
		*/

		while (parent) {
			// 更新平衡因子
			if (parent->_left == cur)	
				--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) {
					Node* subR = parent->_right;
					Node* subRL = subR->_left;
					int bf = subRL->_bf;
					RotateR(subR);
					RotateL(parent);

					if (bf == -1) {
						parent->_bf = 0;
						subR->_bf = 1;
					}
					else if (bf == 1) {
						parent->_bf = -1;
						subR->_bf = 0;
					}
				}
				else if (parent->_bf == -2 && cur->_bf == 1) {
					RotateL(cur);
					RotateR(parent);
				}
				break;
			}
		}
		return true;
	}

	void RotateR(Node* parent) {
		// subL: pParent的左孩子
		// subLR: pParent左孩子的右孩子
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		// 单向链接 subL , parent, subLR
		subL->_right = parent;	// 旋转完成之后，30的右孩子作为双亲的左孩子
		parent->_left = subLR;  // 60 作为 30的右孩子

		// 向上链接subLR
		if (subLR)	subLR->_parent = parent;  // 如果30的左孩子的右孩子存在，更新亲双亲

		// subL, parent->praent 双向链接
		if (parent != _root) {
			Node* gParent = parent->_parent;
			// 如果60是子树，可能是其双亲的左子树，也可能是右子树
			if (gParent->_left == parent)
				gParent->_left = subL;
			else
				gParent->_right = subL;
			subL->_parent = gParent;
		}
		else {
			_root = subL;  // 如果60是根节点，根新指向根节点的指针
			subL->_parent = nullptr;
		}

		// 向上链接 parent， subL
		parent->_parent = subL;  // 更新60的双亲

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

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

		subR->_left = parent;
		parent->_right = subRL;

		if (subRL)		
			subRL->_parent = parent;
		if (parent != _root) {
			Node* gParent = parent->_parent;
			if (gParent->_left == parent)	
				gParent->_left = subR;
			else 
				gParent->_right = subR;
			subR->_parent = gParent;
		}
		else {
			subR->_parent = nullptr;
			_root = subR;
		}

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

	

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

	bool _IsBalance(Node* root) {
		if (root == nullptr)	
			return true;
		int right = Height(root->_right);
		int left = Height(root->_left);

		if (root->_bf != right - left) {
			cout << "节点：   " << root->_data << "异常" << endl;
			return false;
		}

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

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

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

	void _Inorder(Node* root) {
		if (root) {
			_Inorder(root->_left);
			cout << root->_data << " ";
			_Inorder(root->_right);
		}
	}

private:
	Node* _root = nullptr;
};

int main() {
	AVLTree<int> avlt;
	int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 }; //{ 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//{ 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 }; 
	for (const auto& e : arr)
	{
		avlt.Insert(e);
		cout << avlt.IsBalance() << endl;
	}
	avlt.Inorder();
	cout << avlt.IsBalance() << endl;
	getchar();
	return 0;
}

8. AVL树的验证

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

8.1 验证其为二叉搜索树

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

8.2 验证其为平衡树

每个节点子树高度差的绝对值不超过 1 (注意节点中如果没有平衡因子)
节点的平衡因子是否计算正确

int _Height(PNode pRoot);
bool _IsBalanceTree(PNode pRoot)
{
     // 空树也是AVL树
     if (nullptr == pRoot) return true;
    
     // 计算pRoot节点的平衡因子：即pRoot左右子树的高度差
     int leftHeight = _Height(pRoot->_pLeft);
     int rightHeight = _Height(pRoot->_pRight);
     int diff = rightHeight - leftHeight;
 
     // 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
     // pRoot平衡因子的绝对值超过1，则一定不是AVL树
     if (diff != pRoot->_bf || (diff > 1 || diff < -1))
         return false;
 
     // pRoot的左和右如果都是AVL树，则该树一定是AVL树
     return _IsBalanceTree(pRoot->_pLeft) && _IsBalanceTree(pRoot->_pRight);
 }

9. AVL树的性能分析

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过 1，这样可以保证查询时高效的时间复杂度。但是如果要对 AVL 树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。

因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

Ypuyu

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
1
评论
[C++系列] 77. 详解AVL平衡二叉搜索树

文章目录1. AVL 树的概念2. AVL 树节点的定义3. AVL树的插入与失衡4. AVL树的旋转4.1 新节点插入较高左子树的左侧---左左：右单旋4.2 新节点插入较高右子树的右侧---右右：左单旋4.3. 新节点插入较高左子树的右侧---左右：先左单旋再右单旋4.4. 新节点插入较高右子树的左侧---右左：先右单旋再左单旋5. AVL树旋转总结：6. AVL树的实现7. AVL树的验证7...
复制链接

扫一扫