AVL树原理 部分模拟实现

1.AVL树的概念

---

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

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

---

2.AVL树节点的定义

AVL树的节点定义需要有左右孩子，及父亲节点，平衡因子方便后边旋转操作，具体实现如下：

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

3.AVL树的插入操作

1.首先插入操作先按照二叉搜索树的规则进行插入，插入完成之后需要维护我们的平衡因子（与搜索二叉树的不同点）。我们约定插入在其父亲的左边平衡因子-- 插入在其父亲的右边平衡因子++。

2.插入我们首先可以按平衡因子来分成三种情况：

  2.1 插入之后父节点平衡因子刚好为0，此时从父节点开始开始的这颗子树高度没有发生变化所以不用修改其祖先节点的平衡因子。

  2.2 插入之后父节点平衡因子等于1或-1，很明显此时的这颗字树高度发生了变化，那么我们不仅要改变父节点的平衡因子还要改变其祖先的平衡因子

  2.3 插入之后父节点的平衡因子等于2或-2，此时需要旋转操作，后边祥讲。

搜索二叉树插入逻辑：

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 (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new node(kv);
		if (cur->_kv.first > parent->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

维护平衡因子逻辑：

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

	if (parent->_bf == 0)
	{
		break; //直到父节点平衡因子为0 break跳出循环（旋转之后也会结束函数）
	}
	else if (parent->_bf == 1 || parent->_bf == -1)
	{
		cur = 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)
		{
			RotateLR(parent);//左右双旋
		}
		else
		{
			RotateRL(parent);//右左双旋
		}
		break;
	}
	else
	{
		cerr << "Insert logic error" << endl;
		assert(false);
	}
}

右上边代码可以看出旋转分为四种情况下边来一一讲解：

1.当parent->_bf == 2 && cur->_bf == 1时，如图：

此时需要进行左单旋，旋转之后：

具体代码实现：

void RotateL(node* parent)
{
	node* subr = parent->_right;
	node* subrl = subr->_left;
	node* ppnode = parent->_parent;

	parent->_right = subrl;
	parent->_parent = subr;
	subr->_left = parent;
	if (subrl)
		subrl->_parent = parent;

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

2.当parent->_bf == -2 && cur->_bf == -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* 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;
	}

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

3.当parent->_bf == -2 && cur->_bf == 1时：

具体代码实现：

void RotateLR(node* parent)
{
	node* subl = parent->_left;
	node* sublr = subl->_right;

	int bf = sublr->_bf;

	RotateL(subl);
	RotateR(parent);
	sublr->_bf = 0; //平衡因子的维护需要结合图片进行理解
	if (bf == 0)    //sublr节点平衡因子的不同是不同的改变
	{
		subl->_bf = 0;
		parent->_bf = 0;
	}
	else if (bf == 1)
	{
		parent->_bf = 0;
		subl->_bf = -1;
	}
	else if (bf == -1)
	{
		parent->_bf = 1;
		subl->_bf = 0;
	}
	else
	{
		cerr << "Inser logic error" << endl;
		assert(false);
	}
}

4.当parent->_bf == 2 && cur->_bf == -1时：

具体代码实现：

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 == 0)
	{
		subr->_bf = 0;
		parent->_bf = 0;
	}
	else if (bf == 1)
	{
		parent->_bf = -1;
		subr->_bf = 0;
	}
	else if (bf == -1)
	{
		parent->_bf = 0;
		subr->_bf = 1;
	}
	else
	{
		cerr << "Inser logic error" << endl;
		assert(false);
	}
}

旋转完成后，原Parent为根的子树个高度降低，已经平衡，不需要再向上更新

4.AVL树的遍历

通过遍历AVL树以及调试代码可以简单验证自己的代码是否正确。

private:
	void _InOrder(node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second<<endl;
		_InOrder(root->_right);
	}
public:
	void InOrder()
	{
		_InOrder(_root);
	}

5.源码

#pragma once
#include <iostream>
#include <cassert>
using namespace std;
template <typename K, typename V>
struct AVL_Node
{
	AVL_Node<K, V>* _left; 
	AVL_Node<K, V>* _right;
	AVL_Node<K, V>* _parent;
	int _bf; //平衡因子
	pair<K, V> _kv;
	AVL_Node(const pair<K,V>& kv) :
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_bf(0),
		_kv(kv)
	{}
};

template <typename K, typename V>
class AVL_Tree
{
	typedef AVL_Node<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 (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new node(kv);
		if (cur->_kv.first > parent->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

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

			if (parent->_bf == 0)
			{
				break; //直到父节点平衡因子为0 break跳出循环（旋转之后也会结束函数）
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = 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)
				{
					RotateLR(parent);//左右双旋
				}
				else
				{
					RotateRL(parent);//右左双旋
				}
				break;
			}
			else
			{
				cerr << "Inser logic error" << endl;
				assert(false);
			}
		}
		return true;
	}

	void RotateL(node* parent)
	{
		node* subr = parent->_right;
		node* subrl = subr->_left;
		node* ppnode = parent->_parent;

		parent->_right = subrl;
		parent->_parent = subr;
		subr->_left = parent;
		if (subrl)
			subrl->_parent = parent;

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

	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;
		}

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

	void RotateLR(node* parent)
	{
		node* subl = parent->_left;
		node* sublr = subl->_right;

		int bf = sublr->_bf;

		RotateL(subl);
		RotateR(parent);
		sublr->_bf = 0;
		if (bf == 0)
		{
			subl->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			subl->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subl->_bf = 0;
		}
		else
		{
			cerr<< "Inser logic error" << endl;
			assert(false);
		}
	}
	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 == 0)
		{
			subr->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subr->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subr->_bf = 1;
		}
		else
		{
			cerr << "Inser logic error" << endl;
			assert(false);
		}
	}
private:
	void _InOrder(node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second<<endl;
		_InOrder(root->_right);
	}
public:
	void InOrder()
	{
		_InOrder(_root);
	}
private:
	node* _root = nullptr;
};