AVL树的模拟实现（c++）-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_65665343/article/details/127816795

本文详细介绍了AVL树的概念，包括其定义、插入过程中的平衡因子控制以及旋转操作，包括左单旋、右单旋和双旋。通过实例演示了如何确保插入后树的平衡，适用于需要高效搜索的数据结构优化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

前言
一、AVL树是什么？
二、使用步骤
- 1.引入库
- 2.读入数据
总结

前言

前面的博客介绍了二叉搜索树，虽然二叉搜索树能提高效率，但是如果数据有序且接近有序二叉搜索树，将会退化成为单支树，查找元素会退化成相当于在顺序表中搜索元素，效率会比较低，因此

俄罗斯的两位大佬发明了AVL树

一、AVL树是什么？

： 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右

子树高度之差的绝对值不超过 1( 需要对树中的结点进行调整 ) ，即可降低树的高度，从而减少平均

搜索长度。

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

它的左右子树都是 AVL 树

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

二、AVL树的模拟及其实现

2.1 AVL树的节点及定义

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;//父亲指针

	pair<K, V> _kv;
	int _bf;//平衡因子

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

这里用三叉链的方式进行实现，只不过多了一个平衡因子的控制

2.2AVL树的插入

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

			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}


		}
		//开始插入过程
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		//处理三叉链子
		cur->_parent = parent;
		//控制平衡
		while (parent)//父节点不为空继续更新
		{
			//按照图中的条件归类写
			if (cur == parent->_right)
			{
				parent->_bf++;//图中如果cur在做平衡因子++

			}
			else if (cur==parent->_left)
			{
				parent->_bf--;
			}
			if (parent->_bf == 0)
			{
				break;//说明不需要更新
			}
			else if (abs(parent->_bf) == 1)//判断平衡因子是1 或者-1 这个是取绝对值
			{
				//继续往上更新
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (abs(parent)==2)
			{
				//需要旋转处理
				//判断什么时候需要左旋 父亲的平衡因子==2 并且 cur的平衡因子==1
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					//左旋处理 根据图来进行位置矫正
					RotateL(parent);//左旋函数
					
				}
				else if ((parent->_bf==2 && cur->_bf==-1))//需要右旋处理
				{
					RotateR(parent);
				}
				break:
			}
			else
			{
				assert(false);
			}

		}

		return true;

	}

AVL树的插入的规则和二叉搜索树差不多比kv.first小就去左边找，比他大就去右边找，只不过这里需要控制平衡因子。

插入总结：

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

2. 调整节点的平衡因子

先说一下更新平衡因子的规则吧，话不多说请看图

2.3.AVL树的旋转

如果在一棵原本是平衡的 AVL 树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，

使之平衡化。根据节点插入位置的不同， AVL 树的旋转分为四种：

2.3.1. 为什么要旋转

不管是什么方式的旋转，旋转的目的是为了降低树的高度，使其平衡，假如树结构如下图，

将“A”节点添加到树中，变成如下结构，树产生了不平衡，于是检查哪里不平衡，当到“C”节点时发现高度差超过1，

所以需要对“C”节点进行右单旋操作将高度降到2，达到平衡。

2.3.2 左单旋

如图，此时这棵树是一根平衡的二叉搜索树，所以我们也可以称这棵树为AVL树。每个节点的平衡因子用红色字体标出。我们可以看到，每个节点的平衡因子的绝对值都没有超过1.此时该树平衡。

此时，我们插入新的节点，节点值为85，我们发现，50这个节点的平衡因子超过1了。这棵树已经是不平衡的了，如下图所示：

根据我们的旋转规则：从新加入的节点开始沿根的路径回溯，找到不平衡的节点，从这个不平衡的节点开始沿刚才回溯的路径向下寻找两层节点，如果这三个节点在同一直线上，我们就是用单旋转，否则使用双旋转。依据这个规则，我们找到了不平衡的节点50，向下两层找到了节点70、节点80。这三个节点在同一直线上，所以我们采用单旋转。

具体情况还是得看巨像图


	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;//图上看到subR是父亲的右边
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)//最后一层节点subL可能为空
			subRL->_parent = parent;//防止找不到上一个指针

		Node* ppNode = parent->_parent;//有两种情况需要改变跟所以来保存值

		subR->_left = parent;//改变后的值
		parent->_parent = subR;

		if (_root == parent)
		{
			_root = subR;//改新节点
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)//判断新节点在左边还是右边进行链接
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}

			subR->_parent = ppNode;
		}

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

2.3.3 右单旋

右单旋转和左单旋转的思路是一样的，只不过是旋转的方向不同，我们还是用图示来说明。

如图，此时是一棵平衡的AVL树。

当我们向这棵AVL树中添加节点10时，如下图所示：

此时，我们从新插入的节点10开始，沿着根路径向上回溯的查找，直到查找到80这个节点，发现该节点的平衡因子的绝对值大于1，于是，从该节点向下，沿着刚才回溯的路径，找到下两层节点40、30。这三个节点在同一条直线上，此时以40这个节点为旋转点，进行右单旋转。

如下图：

巨像图


	void RotateR(const Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		
		parent->_left = subLR;

		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node*ppNode = parent->_parent;//保存的值
		subL->_right = parent;
		parent->_parent = subL;
		if (_root==parent)
		{
			_root = subL;
			subLR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;//改变后的方向
			}
			subL->_parent = ppNode;
			subL->_bf = parent->_bf = 0;//平衡因子改成0
		}

		


	}

2.3.4双旋插入在a

双旋转

若某一个节点的平衡因子发生改变，沿着回溯路径，以最后一层的节点为旋转点，进行先左单旋后右单旋，或者进行先右单旋后左单旋。

现有一棵AVL树，每个节点的平衡因子的绝对值都没有超过1，所以该AVL是平衡的。

此时，我们新节点插入的位置有四种，分别为上述图中标出来的1、2、3、4这四个位置。

情况一：
首先分析，如果我们插入的位置为1或者2这两个位置其中之一，则有：

此时，我们发现无论我们插入的是1位置还是 2位置，节点B的平衡因子都会变成-1，而节点A的平衡因子都会变成-2。都会导致AVL树不平衡，需要旋转。

巨像图

双旋有两种情况一种在b插入一种在c插入平衡因子控制的变化在b插入平衡因子是-2

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

		RotateL(parent->_left);
		RotateR(parent);

		subLR->_bf = 0;
		if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subL->_bf = 1;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

此外还有双旋的第二种情况在c插入

#pragma once
#include<assert.h>
#include<iostream>
template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _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>
struct AVLTree
{
	typedef AVLTreeNode<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 (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first>ke.first)

			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}


		}
		//开始插入过程
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		//处理三叉链子
		cur->_parent = parent;
		//控制平衡
		while (parent)//父节点不为空继续更新
		{
			//按照图中的条件归类写
			if (cur == parent->_right)
			{
				parent->_bf++;//图中如果cur在做平衡因子++

			}
			else if (cur==parent->_left)
			{
				parent->_bf--;
			}
			if (parent->_bf == 0)
			{
				break;//说明不需要更新
			}
			else if (abs(parent->_bf) == 1)//判断平衡因子是1 或者-1 这个是取绝对值
			{
				//继续往上更新
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (abs(parent)==2)
			{
				//需要旋转处理
				//判断什么时候需要左旋 父亲的平衡因子==2 并且 cur的平衡因子==1
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					//左旋处理 根据图来进行位置矫正
					RotateL(parent);//左旋函数
					
				}
				else if ((parent->_bf==2 && cur->_bf==-1))//需要右旋处理
				{
					RotateR(parent);
				}
				break:
			}
			else
			{
				assert(false);
			}

		}

		return true;

	}
void InOrder()//中序便利
	{
		_InOrder(_root);
		cout << endl;
	}
		

	
private:
void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;//图上看到subR是父亲的右边
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)//最后一层节点subL可能为空
			subRL->_parent = parent;//防止找不到上一个指针

		Node* ppNode = parent->_parent;//有两种情况需要改变跟所以来保存值

		subR->_left = parent;//改变后的值
		parent->_parent = subR;

		if (_root == parent)
		{
			_root = subR;//改新节点
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)//判断新节点在左边还是右边进行链接
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}

			subR->_parent = ppNode;
		}

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




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

		RotateL(parent->_left);
		RotateR(parent);

		subLR->_bf = 0;
		if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subL->_bf = 1;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}


	


	void RotateR(const Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		
		parent->_left = subLR;

		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node*ppNode = parent->_parent;//保存的值
		subL->_right = parent;
		parent->_parent = subL;
		if (_root==parent)
		{
			_root = subL;
			subLR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;//改变后的方向
			}
			subL->_parent = ppNode;
			subL->_bf = parent->_bf = 0;//平衡因子改成0
		}

		


	}





	Node* _root = nullptr;
};

2.3.5验证是否为AVL树

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	int Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
 
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
 
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 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 << "现在是:" << root->_bf << endl;
			cout << root->_kv.first << "应该是:" << rightHeight - leftHeight << endl;
			return false;
		}
 
		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

void TestAVLTree()
{
	AVLTree<int, int> t;
	//int a[] = { 5,4,3,2,1,0 };
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16,14 };
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
		cout << "Insert" << e << ":" << t.IsBalance() << endl;
	}
	t.InOrder(); //中序遍历是可以验证是搜索二叉树
	cout << t.IsBalance() << endl; //判断每棵树是否平衡
}

总结：假如以 pParent 为根的子树不平衡，即 pParent 的平衡因子为 2 或者 -2 ，分以下情况考虑
1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
当 pSubR 的平衡因子为 1 时，执行左单旋
当 pSubR 的平衡因子为 -1 时，执行右左双旋
2. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL
当 pSubL 的平衡因子为 -1 是，执行右单旋
当 pSubL 的平衡因子为 1 时，执行左右双旋
旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。