（C++ 进阶）AVL树（高度平衡二叉搜索树）

Zhang丶&｜！

已于 2022-07-22 21:31:57 修改

阅读量329

点赞数 1

分类专栏： C/C++学习笔记文章标签： AVL树插入操作旋转平衡因子二叉搜索树

于 2022-07-22 21:31:19 首次发布

本文链接：https://blog.csdn.net/qq_57594025/article/details/125933213

版权

C/C++学习笔记专栏收录该内容

41 篇文章 2 订阅

订阅专栏

一 AVL树的概念

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

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

③ 一棵AVL 树或者是空树，或者是具有以下性质的二叉搜索树： 它的左右子树都是 AVL 树

左右子树高度之差 ( 简称平衡因子 ) 的绝对值不超过 1(-1/0/1)， 如果一棵二叉搜索树是高度平衡的，它就是 AVL 树。如果它有 n 个结点，其高度可保持在 O(log2N) ，搜索时 间复杂度O(log2N)。

二 AVL树节点的定义

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

	int _bf; //平衡因子 balance factor = 右减左

	pair<K, V> _kv;

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

三 AVL树的插入

1 思路

AVL树是在二叉搜索树的基础上引入了平衡因子，AVL树是一种特殊的二叉搜索树。所以：

①按照二叉搜索树的方式插入新节点 ②调整节点的平衡因子。

2 代码实现

//插入数据
	pair<Node*, bool> Insert(const pair<K, V>& kv)
	{
		//如果树为空，直接插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return make_pair(_root, true);
		}

		// 找到存储位置，把数据插入进去
		Node *parent = _root,  *cur = _root;
		while (cur)
		{
			//依据键值来比较
			if (cur->_kv.first > kv.first)//比键值小，去左边找位置
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)//比键值大，去右边找位置
			{
				parent = cur;
				cur = cur->_right;
			}
			else //已经有了相同键值的结点，返回。
			{
				return make_pair(cur, true);
			}
		}

		//插入位置已经找到
		cur = new Node(kv);
		Node* newnode = cur;
		if (parent->_kv.first < kv.first)//键值比父结点大，链接到右边
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else //键值比父结点小，链接到左边
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		//更新平衡因子，如果出现不平衡，则需要旋转
		while (cur != _root) //如果不满足平衡条件，需要一直向上更新到根结点为止。
		{
			if (parent->_left == cur) //插入到结点左边，平衡因子减一
			{
				parent->_bf--;
			}
			else  //插入到结点右边，平衡因子加一
			{
				parent->_bf++;
			}

			if (parent->_bf == 0) //由 -1 1 改变而来，插入不改变树的高度，不破坏平衡，跳出循环。
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1) //由 0 改变而来。高度改变
			{
				//parent所在的子树高度变了，会影响parent->parent，继续往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2) //parent所在子树已经不平衡，需要旋转处理一下
			{
				if (parent->_bf == -2)//pParent的平衡因子为 - 2，说明pParent的左子树高，设pParent的左子树的根为pSubL
				{
					if (cur->_bf == -1)//当pSubL的平衡因子为 - 1是，执行右单旋
					{
						//右单旋
						RotateR(parent);
					}
					else //cur->_bf == 1  （当pSubL的平衡因子为1时，执行左右双旋）
					{
						RotateLR(parent);
					}
				}
					
				else //parent->_bf  == 2 （pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR）
				{
					if (cur->_bf == 1) //当pSubR的平衡因子为1时，执行左单旋
					{
						//左单旋
						RotateL(parent);
					}
					else //cur->_bf == -1 （当pSubR的平衡因子为 - 1时，执行右左双旋）
					{
						RotateRL(parent);
					}
				}
				break; //旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。
			}
			else
			{
				//bf出现异常。
				assert(false);
			}
		}
		return make_pair(newnode, true);
	}

四 AVL树的旋转

1 基础概念

AVL树的插入可能会打破平衡，此时需要通过旋转来保证树的平衡。根据节点插入位置的不同，AVL 树的旋转分为四种：

①新节点插入较高左子树的左侧 --- 左左：右单旋 。

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

③ 新节点插入较高左子树的右侧 --- 左右：先左单旋再右单旋

④ 新节点插入较高右子树的左侧 --- 右左：先右单旋再左单旋

2 代码实现

2.1 单旋

//（右右）左单旋（2 1）
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

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

		subR->_left = parent;
		Node* parentParent = parent->_parent;
		parent->_parent = subR;

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

	//（左左）右单旋（-2  -1）
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;
		Node* parentParent = parent->_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;
	}

2.2 双旋

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

		RotateL(parent->_left);
		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);
		}
	}

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

		RotateR(parent->_right);
		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);
		}
	}

五 AVL树的验证

1 概念

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

1. 验证是否为二叉搜索树：中序遍历得到的序列是否有序。

2. 验证其为平衡树：每个节点子树高度差的绝对值不超过1。

2 代码实现

	//求从root开始，到叶子节点的高度（最大）
	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		return rightHeight > leftHeight ? rightHeight + 1 : leftHeight + 1;
	}

	//检查一颗树是不是平衡二叉树
	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 << endl;
			return false;
		}

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