AVLTree

AVL树又称为高度平衡的二叉搜索树，是1962年有俄罗斯的数学家G.M.Adel'son-Vel'skii和E.M.Landis提出来的。它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度。

AVL树的性质：
1. 左子树和右子树的高度之差的绝对值不超过1。
2. 树中的每个左子树和右子树都是AVL树。
3. 每个节点都有一个平衡因子(balance factor--bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子树的高度 )

AVL树增删查的效率都是O(Lg(N))

代码实现：

#include <iostream>
using namespace std;

template <class K, class V>
struct AVLTreeNode      //AVLTree的节点
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;

	K _key;
	V _value;
	int _bf;    //平衡因子

	AVLTreeNode(const K& key, const V& value)   //构造
		:_left(NULL)
		, _right(NULL)
		, _parent(NULL)
		, _key(key)
		, _value(value)
		, _bf(0)   //新创节点的平衡因子为0(叶子节点)   bf取值：1/0/-1
	{}
};

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

public:
	AVLTree()         //构造
		:_root(NULL)
	{}

	~AVLTree()     //析构
	{}

	bool Insert(const K& key, const V& value)    //插入
	{
		if (_root == NULL)
		{
			_root = new Node(key, value);
			return true;
		}

		Node* cur = _root;
		Node* parent = NULL;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;       //先将cur保存起来
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;   //有相同的key
			}
		}

		cur = new Node(key, value);
		//找到了空位置，判断插入在parent的左边还是右边
		if (parent->_key < key)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else if (parent->_key > key)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		//更新平衡因子
		while (parent)    //当前节点的parent不为空时
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else if (cur == parent->_right)
			{
				parent->_bf++;
			}

			//检查bf是否正确，是否需要调整
			if (parent->_bf == 0)        //插入完成，bf更新之后为0时，说明此时高度未发生变化，不需要调整
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)  //此时说明高度发生变化，往上检查，看是否存在不正确的bf
			{
				cur = parent;
				parent = cur->_parent;
			}
			else    //bf为2/-2，需要旋转
			{
				if (parent->_bf == 2)    //右边高
				{
					Node* subR = parent->_right;
					
					if (subR->_bf == 1)
					{
						RotateL(parent);   //左单旋
					}
					else if (subR->_bf == -1)
					{
						RotateRL(parent);     //右左双旋
					}
				}

				else if (parent->_bf == -2)   //左边高
				{
					Node* subL = parent->_left;
					if (subL->_bf == -1)
					{
						RotateR(parent);   //右单旋
					}

					else if (subL->_bf == 1)
					{
						RotateLR(parent);     //左右双旋
					}
				}
				break;
			}
		}
		return true;
	}

	void RotateL(Node* parent)    //左单旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL != NULL)
		{
			subRL->_parent = parent;
		}
		subR->_left = parent;
		Node* pparent = parent->_parent;
		parent->_parent = subR;
		if (pparent == NULL)    //说明最开始的parent为根节点
		{
			_root = subR;
			subR->_parent = NULL;
		}
		else   //pparent不为空
		{
			if (parent == pparent->_left)
			{
				pparent->_left = subR;
				subR->_parent = pparent;
			}
			else if (parent == pparent->_right)
			{
				pparent->_right = subR;
				subR->_parent = pparent;
			}
		}
		parent->_bf = subR->_bf = 0;
	}


	void RotateR(Node* parent)   //右单旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR != NULL)
		{
			subLR->_parent = parent;
		}
		subL->_right = parent;
		Node* pparent = parent->_parent;
		parent->_parent = subL;

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

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


	void RotateLR(Node* parent)   //左右双旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		RotateL(subL);     //以subL为轴节点左旋
		RotateR(parent);    //以parent为轴节点右旋
		int bf = subLR->_bf;

		if (bf == 0)
		{
			subLR->_bf = parent->_bf = subL->_bf = 0;
		}

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

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

	void RotateRL(Node* parent)   //右左双旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		RotateR(subR);     //以subR为轴节点右旋
		RotateL(parent);     //以parent为轴节点左旋

		int bf = subRL->_bf;    //subRL为调整后的parent节点

		if (bf == 0)
		{
			//parent为subRL的左节点，subR为subRL的右节点
			subRL->_bf = parent->_bf = subR->_bf = 0;   //此时为完全平衡
		}

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

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

	void Inorder()     //中序遍历
	{
		_Inorder(_root);
		cout << endl;
	}

	bool IsBalance()    //判断是否平衡
	{
		int height = 0;
		return _IsBalance(_root, height);
	}

	size_t _Height(Node* root)    //高度
	{
		if (root == NULL)
		{
			return 0;
		}
		int l = _Height(root->_left);
		int r = _Height(root->_right);

		return l > r ? l + 1 : r + 1;
	}

protected:
	void _Inorder(Node* root)     //中序
	{
		if (root == NULL)
		{
			return;
		}

		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}

	bool _IsBalance(Node* root, int& height)
	{
		if (root == NULL)
		{
			height = 0;
			return true;
		}

		int left, right;
		if (_IsBalance(root->_left, left) && _IsBalance(root->_right, right)
			&& abs(right - left) < 2)
		{
			height = left > right ? left + 1 : right + 1;

			if (root->_bf != right - left)
			{
				cout << "平衡因子异常：" << root->_key << endl;
				return false;
			}

			return true;
		}
		else
		{
			return false;
		}
	}


protected:
	Node* _root;
};

#include "AVLTree.h"
void TestAVLtree()
{
	AVLTree<int, int> p;
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };

	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
		p.Insert(a[i], i);    //第一个为key,第二个为value
	}
	p.Inorder();
	cout << "IsBalance?" << p.IsBalance() << endl;
}
int main()
{
	TestAVLtree();
	return 0;
}