AVL树四种旋转详解

平衡二叉树

平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

平衡因子

某结点的左子树与右子树的高度(深度)差即为该结点的平衡因子（Balance Factor）。平衡二叉树上所有结点的平衡因子只可能是 -1，0 或 1。

四种旋转情况

往平衡二叉树中添加节点很可能会导致二叉树失去平衡，所以我们需要在每次插入节点后进行平衡的维护操作。

1.新节点插入较高左子树的左侧——左左：右单旋

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

		subL->_right = parent;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			Node* pparent = parent->_parent;
			if (pparent->_left == parent)
				pparent->_left = subL;
			else
				pparent->_right = subL;

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

2.新节点插入较高右子树的右侧——右右：左单旋

void RoateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		subR->_left = parent;
		parent->_right = subRL;

		if (subRL)
			subRL->_parent = parent;
		if (parent == _root)
		{
			_root == subR;
			subR->_parent = nullptr;
		}
		else
		{
			Node* pparent = parent->_parent;
			if (pparent->_left == parent)
				pparent->_left = subR;
			else
				pparent->_right = subR;
			subR->_parent = pparent;

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

	}

3.新节点插入较高左子树的右侧——左右：先左单旋再右单旋

//保存subLR的bf
Node* subLR = cur->_left;
int bf = subLR->_bf;
RoateL(cur);
RoateR(parent);
//修正平衡因子
if (bf == 1)
{
	cur->_bf = -1;
	parent->_bf = 0;
}
else if (bf == -1)
{
	cur->_bf = 0;
	parent->_bf = 1;
}

4.新节点插入较高右子树的左侧——右左：先右单旋再左单旋

//保存subRL的bf
Node* subRL = cur->_left;
int bf = subRL->_bf;
RoateR(cur);
RoateL(parent);
//修正平衡因子
if (bf == 1)
{
	cur->_bf = 0;
	parent->_bf = -1;
}
else if (bf == -1)
{
	cur->_bf = 1;
	parent->_bf = 0;
}

AVL树完整代码

#include <iostream>
using namespace std;
template<class T>
struct AVLNode
{
	AVLNode<T*> _parent;
	AVLNode<T*> _left;
	AVLNode<T*> _right;
	T _val;
	int _bf;

	AVLNode(const T& val = T())
		:_parent(nullptr)
		, _left(nullptr)
		, _right(nullptr)
		, _val(val)
		, _bf(0)
	{}

};

template <class T>
class AVLTree
{
public:
	typedef AVLNode<T> Node;

	bool insert(const T& val)
	{
		if (_root = nullptr)
		{
			_root = new Node(val);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (cur->_val == val)
			{
				return false;
			}
			else if (cur->_val > val)
			{
				cur = cur->_left;
			}
			else
			{
				cur = cur->_right
			}
		}
		cur = new Node(val);
		if (parent->_val > val)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		//从parent开始调整
		while (parent)
		{
			if (parent->_left == cur)
				--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 (abs(parent->_bf == 2))
			{
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RoateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					RoateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					//保存subLR的bf
					Node* subLR = cur->_left;
					int bf = subLR->_bf;
					RoateL(cur);
					RoateR(parent);
					//修正平衡因子
					if (bf == 1)
					{
						cur->_bf = -1;
						parent->_bf = 0;
					}
					else if (bf == -1)
					{
						cur->_bf = 0;
						parent->_bf = 1;
					}
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					//保存subRL的bf
					Node* subRL = cur->_left;
					int bf = subRL->_bf;
					RoateR(cur);
					RoateL(parent);
					//修正平衡因子
					if (bf == 1)
					{
						cur->_bf = 0;
						parent->_bf = -1;
					}
					else if (bf == -1)
					{
						cur->_bf = 1;
						parent->_bf = 0;
					}
				}
				break;
			}

		}
		return true;
	}
	//          parent
	//    subL
	//       subLR
	void RoateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		subL->_right = parent;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			Node* pparent = parent->_parent;
			if (pparent->_left == parent)
				pparent->_left = subL;
			else
				pparent->_right = subL;

			subL->_parent = pparent;
		}
		parent->_parent = subL;
		subL->_bf = parent->_bf = 0;
	}
	//     parent
	//                  subR
	//            subRL
	void RoateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		subR->_left = parent;
		parent->_right = subRL;

		if (subRL)
			subRL->_parent = parent;
		if (parent == _root)
		{
			_root == subR;
			subR->_parent = nullptr;
		}
		else
		{
			Node* pparent = parent->_parent;
			if (pparent->_left == parent)
				pparent->_left = subR;
			else
				pparent->_right = subR;
			subR->_parent = pparent;

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

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

	}
	bool isBlance(Node* root)
	{
		if (root == nullptr)
			return true;
		int left = Height(root->_left);
		int right = Height(root->_right);
		if (right - left != root->_bf)
		{
			cout << "Node:" << root->_val << "bf:" << root->_bf << "height gap" << right - left << endl;
			return false;
		}
		return abs(root->_bf) < 2 && isBlance(root->_left) && isBlance(root->_right);
	}
private:
	Node* _root = nullptr;
};