C++:AVL树-CSDN博客

本文链接：https://blog.csdn.net/m0_61088872/article/details/140359647

概念

AVL树是一种自平衡二叉搜索树（BST），被命名为Adelson-Velskii和Landis树，以它们的发明者们的名字命名。AVL树通过在插入和删除操作后进行自旋操作来保持树的平衡，以确保树的高度始终保持在O(logN)。这样可以减少树的平均长度，提高搜索效率。

一颗二叉搜索树，如果每个根节点的左右子树的高度差的绝对值不超过1，那么这就是一颗AVL树

一般的二叉搜索树在插入新节点以及删除节点时，都有可能会破坏树的平衡，所以AVL树需要对插入以及删除接口做修改，每次插入删除时，都要检测一下当前的树时候符合AVL树，如果不符合，要做出相应的调整措施。

实现

插入

限制于AVL树的要求，每个根节点的左右子树高度差绝对值不超过1，我们在此处为AVL树增加一个成员_bf，称为平衡因子(balance factor)，其值为左右子树高度的差值，当这个差值的绝对值>=2，就说明这个节点的左右子树不平衡，那么我们就要使用相应的手段调整这棵树。在此处，本博客的平衡因子为右子树高度 - 左子树高度，这样顺序没有严格要求。

AVL树节点类：

template<class K, class V>
struct AVLTreeNode
{
    AVLTreeNode* _left;
    AVLTreeNode* _right;
    AVLTreeNode* _parent;
    int _bf;
    pair<K, V> _kv;

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

首先，由于平衡因子的限制，我们的AVL树任何一颗高为h + 1的子树只有可能会出现以下三种情况：

三种情况分别是：

两棵子树等高的情况，在任意一边插入
两棵子树不等高的情况，在矮的子树插入
两颗子树不等高的情况，在高的子树插入

情况一：_bf = 0变成_bf = 1或_bf = -1，不影响AVL结构，影响父节点

情况二：_bf = 1或_bf = -1变成_bf = 0，不影响AVL结构，不影响父节点

情况三：_bf = 1或_bf = -1变成_bf = 2或_bf = -2，影响AVL结构，立刻调整子树

那么我们先写出当前的代码逻辑，既然要插入，那么就要先找到合适的位置插入，代码如下：

bool Insert(const pair<K, V>& kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
    }

    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->_left = cur;
    else
        parent->_right = cur;

    cur->_parent = parent;
   
   //调整平衡
   //......
   //......
   //......
   
    return true;
}

既然我们在parent处插入了节点，那么我们第一步就是更新parent的平衡因子：

如果cur是parent的左子树，那么平衡因子-1
如果cur是parent的右子树，那么平衡因子+1

更新完平衡因子后，就要判断属于三种情况的哪一种

代码实现：

情况一：_bf = 0变成_bf = 1或_bf = -1，不影响AVL结构，影响父节点

其不会影响自身的AVL结构，所以不用对自生做操作，但是由于其高度增加了，所以有可能会影响其父节点，那么此时我们就要去看看父节点是否平衡。而对于其父节点而言，也必然会是三种情况之一，所以我们只需要一个循环即可：

 while (parent)
 {
     if (cur == parent->_left)
         parent->_bf--;
     else
         parent->_bf++;

     if (parent->_bf == 0)
     {
     	//情况二
     }
     else if (parent->_bf == 1 || parent->_bf == -1)
     {
         cur = cur->_parent;
         parent = parent->_parent;
     }
     else if (parent->_bf == 2 || parent->_bf == -2)
     {
     	//情况三
     }
     else
     {
         assert(false);
     }
 }

情况二：_bf = 1或_bf = -1变成_bf = 0，不影响AVL结构，不影响父节点

因为其不会影响自己以外的节点，也没有破坏平衡，所以直接跳出while循环，啥也不用做。

 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 = cur->_parent;
         parent = parent->_parent;
     }
     else if (parent->_bf == 2 || parent->_bf == -2)
     {
     	//情况三
        //调整平衡
        //......
        //......
        //......
     }
     else
     {
         assert(false);
     }
 }

第三种情况如下：也就是子树不等高的情况下，在高子树插入节点，导致原本高的子树更高了，破坏了平衡。
以左侧为例，我们将高度为h的子树拆分出来，其一定是是以下情况之一：

对于左侧情况，叫做LL失衡（L表示left），对于右侧情况，叫做LR失衡（R表示right）。
与LL失衡对应的是RR失衡，我们先解决这两种情况的失衡：

右单旋

我们先看到右单旋的示意图，再做讲解：

插入前后高度不变，不会影响父节点，直接跳出循环。

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

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

    subL->_right = parent;
    Node* ppNode = parent->_parent;
    parent->_parent = subL;

    if (parent == _root)
    {
        _root = subL;
        subL->_parent = nullptr;
    }
    else
    {
        if (ppNode->_left == parent)
            ppNode->_left = subL;
        else
            ppNode->_right = subL;

        subL->_parent = ppNode;
    }

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

代码解析：

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

此代码完成了parent与subLR之间的链接，要注意的是，subLR有可能是空指针，比如这样：

所以在访问 subLR->_parent之前，需要先确保subRL不是空指针。

subL->_right = parent;
Node* ppNode = parent->_parent;
parent->_parent = subL;

这一段代码完成了subL与parent之间的链接，由于parent可能还有父节点，所以我们先把parent的父节点ppNode保存下来，后续完成subL与ppNode链接。

if (parent == _root)
{
    _root = subL;
    subL->_parent = nullptr;
}
else
{
    if (ppNode->_left == parent)
        ppNode->_left = subL;
    else
        ppNode->_right = subL;

    subL->_parent = ppNode;
}

这一段代码，完成了ppNode与subL之间的链接，但是如果parent原先是_root节点的话，那么ppNode就是空指针，此时直接把_root更新为subR即可。
如果parent不是_root，那么直接进行链接即可，由于不确定parent原先是ppNode的左子树还是右子树，所以链接前需要检测一下。

parent->_bf = 0;
subL->_bf = 0;

这段代码则是完成平衡因子的更新，左单旋后，parent与subL的平衡因子都变成0。

左单旋

左单旋与右单旋同理，此处直接放出代码：

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

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

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

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

        subR->_parent = ppNode;
    }

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

我们现在还有两种失衡没有解决：

左右双旋

当AVL树出现LR失衡，我们就需要用到左右双旋，LR失衡又分为以下两种情况：

在subLR的左子树插入后旋转：在subLR的右子树插入后旋转：

现在我们来完成代码：

//左右双旋
void RotateLR(Node* parent)
{
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    //更新平衡因子
}

在subLR的左子树插入后旋转：在subLR的右子树插入后旋转：当subLR就是新插入的节点：

可以看到，整体上有三种情况，三种情况对应的平衡因子最后都不同，所以我们要分类讨论。三种情况的区别在于：第一种情况subLR的平衡因子为-1，第二种情况subLR的平衡因子为1，第三种情况subLR的平衡因子为0。

这样我们就可以写出以下代码：

//左右双旋
void RotateLR(Node* parent)
{
    Node* subL = parent->_left;
    Node* subLR = subL->_right;

    int bf = subLR->_bf;
    RotateL(parent->_left);
    RotateR(parent);

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

右左双旋

代码如下：

//右左双旋
void RotateRL(Node* parent)
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;

    int bf = subRL->_bf;
    RotateR(parent->_right);
    RotateL(parent);

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

总代码展示

由于插入操作已经可以很好的理解AVL控制平衡的手段了，此处就不讲解erase操作了，总代码如下：

AVLTree.h：

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>
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* parent = nullptr;
		Node* cur = _root;
		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)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(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 RotateR(Node* parent)
	{
		//左左偏移
		//右单旋
		Node* subL = parent->_left;//不用cur的原因是只需要传递一个参数parent就可以解耦出一个右单旋函数
		Node* subLR = subL->_right;

		//调整爷爷节点和孙子节点的指向关系
		parent->_left = subLR;
		if (subLR)
		{
			//如果subLR不为空，则调整其父亲
			subLR->_parent = parent;
		}

		subL->_right = parent;
		//将parent的parent的子节点指向subL
		Node* ppNode = parent->_parent;
		parent->_parent = subL;


		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			//调整parent的parent的指向
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}

		//调节后的parent和subL的平衡因子都为0
		parent->_bf = subL->_bf = 0;
	}

	//左单旋
	void RotateL(Node* parent)
	{
		//右右偏移
		//左单旋
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

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

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

		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			//判断parent是ppNode的左节点还是右节点
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
				subR->_parent = ppNode;
			}
			else
			{
				ppNode->_right = subR;
				subR->_parent = ppNode;
			}
		}
		parent->_bf = subR->_bf = 0;
	}

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

		RotateR(subR);
		RotateL(parent);

		subRL->_bf = 0;
		if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
		}
		else
		{
			parent->_bf = 0;
			subR->_bf = 0;
		}
	}

	void RotateLR(Node*parent)
	{
		//左右双旋
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		int bf = subLR->_bf;

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


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

	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

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

	int Height()
	{
		return _Height(_root);
	}

	int Size()
	{
		return _Size(_root);
	}


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

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

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

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		return max(_Height(root->_left), _Height(root->_right)) + 1;
	}

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

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		// 不平衡
		if (abs(leftHeight - rightHeight) >= 2)
		{
			cout << root->_kv.first << endl;
			return false;
		}

		// 顺便检查一下平衡因子是否正确
		if (rightHeight - leftHeight != root->_bf)
		{
			cout << root->_kv.first << endl;
			return false;
		}

		return _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

private:
	Node* _root = nullptr;
};