AVL树介绍与模拟实现

个人主页：Lei宝啊 

愿所有美好如期而遇

---

前言：

虽然说二叉搜索树可以缩短查找的效率，但是如果数据有序或接近有序进入二叉搜索树，那么二叉搜索树就会退化成单支树，查找数据的效率也就降低了。

因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：

当向二叉搜索树中插入新节点后，如果能保证每个节点的左右子树高度差不超过1（需要对树做出调整），即可降低树的高度，从而减少平均搜索长度。

AVL树概念

如果一颗二叉搜索树高度是平衡的（每个节点左右子树高度差不超过1），那么就是一颗AVL树。

AVL树节点定义

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

	AVLTreeNode(const K& key, const V& val)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
		,_p(key, val)
	{}
};

AVL树节点插入

这里我们先按照二叉搜索树的插入规则将节点插入：

Node* newnode = new Node(key, val);

if (_root == nullptr)
{
	_root = newnode;
	return true;
}

Node* cur = _root;
Node* par = nullptr;
while (cur)
{
	par = cur;

	if (cur->_p.first == key) return false;
	else if (cur->_p.first < key) cur = cur->_right;
	else cur = cur->_left;
}

if (par->_p.first > key) par->_left = newnode;
else par->_right = newnode;

newnode->_parent = par;

接着我们就要考虑这个节点的插入对于他的父亲，爷爷，甚至祖先的平衡因子的影响(平衡因子：节点左右子树高度差，我们这里全篇将以右树高度减去左树高度为基准使用平衡因子)。

我们就可以发现，新插入节点如果是父节点的左子树，那么父节点的平衡因子bf--，如果是父节点的右子树，那么bf++，并且在bf = 0和 bf绝对值大于1时停止向上更新，bf = 0时树的高度平衡，而bf 绝对值大于1我们就需要对树进行处理了。

cur = newnode;
while (par != nullptr)
{
	//bf = r_high - l_high
	if (par->_left == cur)   
	{
		par->_bf--;
	}
	else
	{
		par->_bf++;
	}
	
	//平衡因子_bf为1或负一，继续向上更迭
	if (par->_bf == 1 || par->_bf == -1)
	{
		cur = par;
		par = par->_parent;
	}
	else if (par->_bf == 0) // _bf为0时，达到平衡，停止更迭
	{
		return true;
	}
	else if(par->_bf == 2 || par->_bf == -2)
	{
		//旋转
		//旋转分为左单旋，右单旋，双旋

		}
	}
	else
	{
		assert(false);
	}
}

AVL树节点旋转

新节点插入较高右子树的右侧--右右：左单旋 + 调整平衡因子

 

 

我们可以发现第一种的逻辑和第二种其实是相同的：

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

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

	Node* p_par = par->_parent;
	subR->_left = par;
	par->_parent = subR;

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

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

新节点插入较高左子树的左侧--左左：右单旋 + 调整平衡因子

这个和左单旋逻辑是一样的，这里不多做解释，图片参考上面，这里直接给出代码：

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

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

	Node* p_par = par->_parent;
	subL->_right = par;
	par->_parent = subL;

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

	par->_bf = 0;
	subL->_bf = 0;

}

新节点插入较高左子树的右侧--左右：左单旋 + 右单旋 + 调整平衡因子

先进行一次左旋

再进行一次右旋

这个代码倒是很简单，复用就好：

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

这里的关键点其实是平衡因子的调节，par在调整后平衡因子是多少？par->left呢？par->left->right呢？这些都是问题。

我们可以发现的是，不管怎么样，调整后， par->left->right的平衡因子总是0，而par，par->left的平衡因子在不同情况下会有不同的结果。

这里有三种情况：

因为我们发现节点4的左右子树是要给到节点3和6的，那么在节点4不同位置插入节点自然会影响节点3和节点6的平衡因子。

    Node* subL = par->_left;
    Node* subLR = subL->_right;
    int bf = subLR->_bf;

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

    //此处开始
    if (bf == -1)
    {
	    subLR->_bf = 0;
    	subL->_bf = 0;
	    par->_bf = 1;
    }
    else if(bf == 1)
    {
	    subLR->_bf = 0;
    	subL->_bf = -1;
	    par->_bf = 0;
    }
    else if (bf == 0)
    {
	    subLR->_bf = 0;
    	subL->_bf = 0;
	    par->_bf = 0;
    }
    else
    {
	    assert(false);
    }

    return true;

新节点插入较高右子树的左侧--右左：右单旋 + 左单旋 + 调整平衡因子

也是逻辑同上，直接上代码：

    Node* subR = par->_right;
    Node* subRL = subR->_left;
    int bf = subRL->_bf;

    RotateR(par->_right);
    RotateL(par);

    //此处开始
    if (bf == -1)
    {
	    subRL->_bf = 0;
	    subR->_bf = 1;
   	    par->_bf = 0;
    }
    else if (bf == 1)
    {
	    subRL->_bf = 0;
	    subR->_bf = 0;
	    par->_bf = -1;
    }    
    else if (bf == 0)
    {
	    subRL->_bf = 0;
	    subR->_bf = 0;
	    par->_bf = 0;
    }
    else
    {
	    assert(false);
    }

    return true;

整体代码

#pragma once
#include <iostream>
#include <map>
#include <cassert>

using namespace std;

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

	AVLTreeNode(const K& key, const V& val)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
		,_p(key, val)
	{}
};

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K,V> Node;
public:

	bool Insert(const K& key, const V& val)
	{
		Node* newnode = new Node(key, val);

		if (_root == nullptr)
		{
			_root = newnode;
			return true;
		}

		Node* cur = _root;
		Node* par = nullptr;
		while (cur)
		{
			par = cur;

			if (cur->_p.first == key) return false;
			else if (cur->_p.first < key) cur = cur->_right;
			else cur = cur->_left;
		}

		if (par->_p.first > key) par->_left = newnode;
		else par->_right = newnode;

		newnode->_parent = par;

		cur = newnode;
		while (par != nullptr)
		{
			//bf = r_high - l_high
			if (par->_left == cur)   
			{
				par->_bf--;
			}
			else
			{
				par->_bf++;
			}
			
			//平衡因子_bf为1或负一，继续向上更迭
			if (par->_bf == 1 || par->_bf == -1)
			{
				cur = par;
				par = par->_parent;
			}
			else if (par->_bf == 0) // _bf为0时，达到平衡，停止更迭
			{
				return true;
			}
			else if(par->_bf == 2 || par->_bf == -2)
			{
				//旋转
				//旋转分为左单旋，右单旋，双旋

				//右右，左单旋
				if (par->_bf == 2 && par->_right->_bf == 1)
				{
					RotateL(par);
				}
				else if (par->_bf == -2 && par->_left->_bf == -1)
				{
					RotateR(par);
				}
				else if (par->_bf == 2 && par->_right->_bf == -1)
				{
					Node* subR = par->_right;
					Node* subRL = subR->_left;
					int bf = subRL->_bf;

					RotateR(par->_right);
					RotateL(par);

					//此处开始
					if (bf == -1)
					{
						subRL->_bf = 0;
						subR->_bf = 1;
						par->_bf = 0;
					}
					else if (bf == 1)
					{
						subRL->_bf = 0;
						subR->_bf = 0;
						par->_bf = -1;
					}
					else if (bf == 0)
					{
						subRL->_bf = 0;
						subR->_bf = 0;
						par->_bf = 0;
					}
					else
					{
						assert(false);
					}

					return true;
				}
				else if (par->_bf == -2 && par->_right->_bf == 1)
				{
					Node* subL = par->_left;
					Node* subLR = subL->_right;
					int bf = subLR->_bf;

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

					//此处开始
					if (bf == -1)
					{
						subLR->_bf = 0;
						subL->_bf = 0;
						par->_bf = 1;
					}
					else if(bf == 1)
					{
						subLR->_bf = 0;
						subL->_bf = -1;
						par->_bf = 0;
					}
					else if (bf == 0)
					{
						subLR->_bf = 0;
						subL->_bf = 0;
						par->_bf = 0;
					}
					else
					{
						assert(false);
					}

					return true;
				}
			}
			else
			{
				assert(false);
			}
		}

	}

	void Inorder()
	{
		_Inorder(_root);
	}


private:

	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;

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

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

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

		Node* p_par = par->_parent;
		subR->_left = par;
		par->_parent = subR;

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

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

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

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

		Node* p_par = par->_parent;
		subL->_right = par;
		par->_parent = subL;

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

		par->_bf = 0;
		subL->_bf = 0;

	}


private:
	Node* _root = nullptr;
};