C++AVL树

本期我们来实现详细讲解AVL树

目录

AVL树的概念

代码实现

全部代码

---

AVL树的概念

二叉搜索树虽可以缩短查找的效率，但 如果数据有序或接近有序二叉搜索树将退化为单支树，查 找元素相当于在顺序表中搜索元素，效率低下 。因此，两位俄罗斯的数学家 G.M.Adelson-Velskii和E.M.Landis 在 1962 年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过 1( 需要对树中的结点进行调整 ) ，即可降低树的高度，从而减少平均搜索长度。
一棵 AVL 树或者是空树，或者是具有以下性质的二叉搜索树：
它的左右子树都是 AVL 树 左右子树高度之差 ( 简称平衡因子 ) 的绝对值不超过 1(-1/0/1)
平衡因子 = 右子树的高度 - 左子树的高度

AVL树的增删查改最多走高度次，也就是O(logN)

代码实现

template<class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K,V>* _left;
	AVLTreeNode<K,V>* _right;
	AVLTreeNode<K,V>* _parent;
	int _bf;//平衡因子
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_bf(0)
	{}
};

template<class K,class V>
class 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 > kv.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;
		//控制平衡
		
		return true;
	}
private:
	Node* _root = nullptr;
};

我们先写出基础框架，然后我们来完成insert，此时我们完成的是平衡搜索树的，而AVL树还要控制平衡，另外需要注意的是，AVL树是三叉树，还有一个指针指向父亲节点

我们插入新节点后，平衡因子会发生变化，有多种情况，我们进行分析

1.新增节点在左，parent的平衡因子减一

2.新增节点在右，parent的平衡因子加一

3.更新后parent平衡因子 == 0，说明parent所在子树高度不变，不会再影响祖先，不用再继续沿着root的路径往上更新

4.更新后parent平衡因子 == 1 或者 -1，说明parent所在子树高度发生变化，会影响祖先，需要继续沿着root的路径往上更新

5.更新后parent平衡因子 == 2 或者 -2，说明parent所在子树高度发生变化，且不平衡，需要对parent所在子树进行旋转，让他重新平衡

6.更新到根节点

在上面的条件中，如果是3和5，那么就结束插入，如果是4，那么继续循环，更新祖先的平衡因子

6也是插入结束，这是最坏的情况，比如满二叉树插入新节点，他的平衡因子就会一直更新到根节点

//控制平衡
		while (parent)
		{
			if (cur == parent->_left)
			{
				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)
			{
				//旋转

			}
			else
			{
				return false;
			}
		}

控制平衡代码也非常长，这里是我们对于上面的逻辑进行的实现，最后为什么还要有一个else呢？这是当我们的代码出现错误时，如果错误在这里，说明平衡因子在插入前就有问题，方便我们判断，当然，上面的逻辑还差一个旋转，下面我们来看看到底怎么进行旋转

我们在旋转时要注意两个问题，一个是旋转后要保证它还是搜索树，二是要变为平衡树且降低这个子树的高度

假设我们有这样两棵树，其中红色的节点是我们新插入的节点，此时的平衡因子就出现了问题，需要我们进行旋转

我们对第一棵树这样旋转，这是什么操作呢？3作为1的左子树，下面的节点一定是比1大的，所以我们把3的左子树作为1的右子树（这里3的左子树是空，所以1的右子树也是空），然后把1作为3的左子树，这样就可以把1按下来，使整棵树的高度降低

同样的，我们看第二棵树，我们一样的把3的左子树作为1的右子树，也就是2变为1的右子树 ，然后把1变为3的左子树，这样整棵树的高度就降下来了，平衡因子问题也就解决了

当然这还没完，当我们旋转完后，还要把父亲节点给更正

上面的只是一种情况，我们的parent，也就是平衡因子为2的节点都是根节点，如果不是根节点，我们是需要提前保存一下，然后更正父亲节点的位置

void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;
		parent->_right = curleft;
		if (curleft)
		{
			curleft->_parent = parent;
		}
		cur->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = cur;
		if (parent == _root)//parent是根节点
		{
			_root = cur;
			cur->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
		parent->_bf = cur->_bf = 0;
	}

整个过程是非常复杂的，大家需要画图来进行辅助理解 ，我们给这个函数传的参数是平衡因子为2的节点，也就是parent

我们的旋转其实还没有完成，因为旋转的情况不可能只有这么简单的两种，我们把上面的这副图叫做抽象图，它没有画出具体的图，但是这里是一个代表，画了abc3棵子树，插入之前，abc是3棵AVL子树，如果在c里插入一个新节点，导致c的高度变为h+1，就会导致60的平衡因子变为1，进而导致30的平衡因子变为2，这棵树就不平衡了，就需要旋转

下面我们来分情况进行讨论

第一种情况是h=0，大概是这个样子

第二种情况是h=1，新增节点是60的右孩子的孩子，无论是左右孩子都会导致30的平衡样子变为2，而需要旋转，这里是有两种情况的

第三种情况是h=2，此时情况就非常复杂了 ，我们可以确定ab是xyz的任意一种，而c是z，只有这样在c新增节点才能让这棵树进行旋转，再加上ab的选择，这棵树插入前的可能形状组合有 3*3*1 = 9种，而在c插入新节点有4种情况，所以这里一共是有 4*9 = 36种情况的，大家想想，这还只是h为2的情况，如果h是3，4，5呢？所以是这里的情况是无穷无尽的，于是就需要有抽象图来帮助我们进行理解

但是不管它是什么情况，我们只需把60的左边作为30的右边，再把30作为60的左边即可，以不变应万变

上面我们实现了左单旋，下面我们就需要实现右单旋了

结合这副图，我们可以理解，右单旋是将30的右边给60的左边，再把60作为30的右边，这里和左单旋是类似的，下面我们继续分情况讨论

我们看h=0和h=1的情况，h=0只有一种情况，而h=1是有两种情况的，在30左孩子的左右新增节点都会发生旋转

h=2 也与左单旋基本一样，只不过此时a是z，bc是xyz中的一种，这里同样一共有36种情况

下面我们来写代码

void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;
		parent->_left = curright;
		if (curright)
		{
			curright->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		cur->_right = parent;
		parent->_parent = cur;
		if (ppnode == nullptr)
		{
			_root = cur;
			cur->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
		parent->_bf = cur->_bf = 0;
	}

有了左旋的经验，我们可以轻松写出右旋

实现了单旋，下面我们来看看双旋

这种情况我们该如何进行旋转呢？这里就需要进行双旋，我们可以看出，如果插入新节点后，路径长的像直线就是单旋，是折线就是双旋

首先我们来看h=0的情况，这里60就是新增的节点

​​​​​​​

再看h=1，在60的左边或者右边新增都会导致双旋

我们再看h=2的情况，首先a和d是xyz中的任意一种， 而60的左右子树高度为h-1，也就是1，所以60的左右孩子就是一个节点，此时新增节点有4种情况，在60的两个孩子的左右子树4个位置

这里有共用 3*3*4 = 36种情况，h=3，4，5的情况就更加复杂，这里也是无穷无尽的

接着我们来看双旋的操作，我们先以90为旋转点，进行右单旋，再以30为旋转点，进行左单旋

我们先以90为旋转点进行右单旋，也就是90为parent，我们把60的右边作为90的左边，再把90作为60的右边，然后我们就可以发现，这棵树从折线变成了直线

再以30作为旋转点，也就是parent，我们就可以得到一棵正常的树

我们再看这棵树，同样的，我们先以90为旋转点，进行右单旋

再以30为旋转点，进行左单旋，就完成了

我们分析可以得到，双旋结果的本质是：60的左边给30的右边，60的右边给90的左边，60成了这棵树的根

根据插入节点位置的不同，30和90的平衡因子也是不同的

而当60自己就是新增节点时，又是一种情况

我们来看，当h>0时，我们在c插入新节点诱发旋转，c从h-1变为h，最终30的平衡因子是-1 ，c最后变成了90的左边

如果是在b插入新节点诱发旋转，b最终变为30的右边，90的平衡因子变为1

上面是两种情况，还有一种就是60本身是新增，60的平衡因子就是0，所以这里我们一共分出3种情况

也就是说，这里最终的平衡因子是需要看60的，30是parent，90是cur，60是curleft，也就是说，我们要看curleft的平衡因子

void RotateRL(Node* parent)//右左双旋
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;
		int bf = curleft->_bf;
		RotateR(parent->_right);
		RotateL(parent);
		if (bf == 0)
		{
			cur->_bf = 0;
			curleft->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			cur->_bf = 0;
			curleft->_bf = 0;
			parent->_bf = -1;
		}
		else if(bf == -1)
		{
			cur->_bf = 1;
			curleft->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

我们根据curleft的平衡因子来确定最终的平衡因子

既然有右左双旋，那么就肯定还有左右双旋

这里的代码其实是基本一样的，我这里就不详细说了，下面我们直接来实现代码

void RotateLR(Node* parent)//左右双旋
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;
		int bf = curright->_bf;
		RotateL(parent->_left);
		RotateR(parent);
		if (bf == 0)
		{
			cur->_bf = 0;
			curright->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			cur->_bf = -1;
			curright->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			cur->_bf = 0;
			curright->_bf = 0;
			parent->_bf = 1;
		}
		else
		{
			assert(false);
		}
	}

我们根据curright的平衡因子来确定最终的平衡因子

这些旋转完成后，我们需要把insert补全

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 > kv.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->_left)
			{
				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)
				{
					RotateL(parent);
				}
				else if(parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if(parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

可以看到，我们是分了非常多的情况进行讨论的

下面我们再写一个函数来判断我们的AVL树是否正常

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()
	{
		return IsBalance(_root);
	}
	bool IsBalance(Node* root)//判断是否为AVL树
	{
		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;
			return false;
		}
		return abs(rightHeight - leftHeight) < 2
			&& IsBalance(root->_left)  //所有的子树都要符合
			&& IsBalance(root->_right);
	}

这里有两个IsBalance，空参数的那个是为了在外边使用，因为_root是私有的，下面的那个可以写成子函数，不写也没事，因为构成了函数重载

接着我们测试一下，没有问题

再用1w个随机值测试一下（有些同学写的代码跑不过某些随机值），这里也没有问题

我们上面实现了插入，删除我这里就不写了，给大家提供一下思路，感兴趣的可以自己去实现一下

删除也是分为三部，按搜索树查找节点删除，更新平衡因子，出现异常时旋转

我们看这张图片，我们删除了2，此时1的平衡因子变成了-1，但是此时是不需要更新的，因为高度没有发生变化

而如果我们把9删掉，8的平衡因子变为了0 ，此时就需要更新了，因为高度是发生了变化

大家想想，插入时我们是填充低的树，高度才会变化，而删除是删掉高的树，高度会变化，原来的平衡因子是-1或者1，就是一边高一边低，然后变成了0，说明高的那一端被删掉了，所以就需要更新

所以我们一路往上更新，这里到根节点结束了

我们继续删除，这次我们把6和8删掉，此时根节点的平衡因子变成了-2

然后我们进行旋转，这里是右单旋，旋转其实没什么区别，就是那几种，但是平衡因子的更新会变得非常麻烦，旋转我们也是根据删除的路径，而不是插入时的路径，是非常麻烦的

具体的大家可以在网上查一查，或者根据数据结构相关的书籍来看一看

全部代码

using namespace std;
#include<iostream>
#include<assert.h>

template<class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K,V>* _left;
	AVLTreeNode<K,V>* _right;
	AVLTreeNode<K,V>* _parent;
	int _bf;//平衡因子
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_bf(0)
	{}
};

template<class K,class V>
class 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 > kv.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->_left)
			{
				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)
				{
					RotateL(parent);
				}
				else if(parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if(parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}
	void RotateL(Node* parent)//左单旋
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;
		parent->_right = curleft;
		if (curleft)
		{
			curleft->_parent = parent;
		}
		cur->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = cur;
		if (parent == _root)//parent是根节点
		{
			_root = cur;
			cur->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
		parent->_bf = cur->_bf = 0;
	}

	void RotateR(Node* parent)//右单旋
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;
		parent->_left = curright;
		if (curright)
		{
			curright->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		cur->_right = parent;
		parent->_parent = cur;
		if (ppnode == nullptr)
		{
			_root = cur;
			cur->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
		parent->_bf = cur->_bf = 0;
	}

	void RotateRL(Node* parent)//右左双旋
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;
		int bf = curleft->_bf;
		RotateR(parent->_right);
		RotateL(parent);
		if (bf == 0)
		{
			cur->_bf = 0;
			curleft->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			cur->_bf = 0;
			curleft->_bf = 0;
			parent->_bf = -1;
		}
		else if(bf == -1)
		{
			cur->_bf = 1;
			curleft->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateLR(Node* parent)//左右双旋
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;
		int bf = curright->_bf;
		RotateL(parent->_left);
		RotateR(parent);
		if (bf == 0)
		{
			cur->_bf = 0;
			curright->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			cur->_bf = -1;
			curright->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			cur->_bf = 0;
			curright->_bf = 0;
			parent->_bf = 1;
		}
		else
		{
			assert(false);
		}
	}
	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()
	{
		return IsBalance(_root);
	}
	bool IsBalance(Node* root)//判断是否为AVL树
	{
		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;
			return false;
		}
		return abs(rightHeight - leftHeight) < 2
			&& IsBalance(root->_left)  //所有的子树都要符合
			&& IsBalance(root->_right);
	}
private:
	Node* _root = nullptr;
};

以上即为本期全部内容，希望大家可以有所收获

如有错误，还请指正