AVL树的模拟实现

#pragma once
#include<assert.h>

namespace lhw
{
	
	template <class T1, class T2>
	struct pair
	{
		typedef T1 first_type;
		typedef T2 second_type;
		T1 first;
		T2 second;
		pair() : first(T1()), second(T2())
		{}
		pair(const T1& a, const T2& b) : first(a), second(b)
		{}
	};


	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:
		void insert(const pair<K, V>& kv)
		{
			if (_root == nullptr)
			{
				_root = new node(kv);
				return true;
			}

			node* cur = _root;
			node* parent = nullptr;
			while (cur)
			{
				if (cur->_kv.first > kv.first)      //左子树搜索
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_kv.first < kv.first)   //右子树搜索
				{
					parent = cur;
					cur = cur->_right;
				}
				else                            //插入失败
				{
					return false;
				}
			}

			cur = new node(kv);
			if (parent->_kv.first > kv.first)
			{
				parent->_left = cur;
			}
			else
			{
				parent->_right = cur;
			}
			cur->_parent = parent;


			//更新平衡因子
			while (parent)
			{
				if (cur == parent->_left)
				{
					parent->_bf++;
				}
				else
				{
					parent->_bf--;
				}
				if (parent->_bf == 1 || parent->_bf == -1)
				{
					parent = parent->_parent;
					cur = cur->_parent;
				}
				else if (parent->_bf == 0)
				{
					break;
				}
				else if (parent->_bf == 0)
				{
					break;
				}
				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)     //右左双旋
					{
						RotateRL(parent);
					}
					else if (parent->_bf == -2 && cur->_bf == 1)     //左右双旋
					{
						RotateLR(parent);
					}
					else
					{
						assert(false);
					}

					break;
				}
				else
				{
					assert(false);
				}
			}
			return true;
		}
	private:

		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 (ppnode == nullptr)
			{
				_root == subR;
				_root->_parent = nullptr;
			}
			else
			{
				if (ppnode->_left == parent)
				{
					ppnode->_left = subR;
				}
				else
				{
					ppnode->_right == subR;
				}
				subR->_parent = ppnode;
			}
			parent->_bf = subR->_bf = 0;

		}

		void RotateR(node* parent)
		{
			node* subL = parent->_left;
			node* subLR = subL->_right;

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

			node* ppnode = parent->_parent;
			subL->_right = parent;
			parent->_parent = subL;

			if (parent == _root)
			{
				_root = nullptr;
				_root->_parent = nullptr;
			}
			else
			{
				if (ppnode->_left == parent)
				{
					ppnode->_left = subL;
				}
				else
				{
					ppnode->_right = subL;
				}
			}
			subL->_bf = parent->_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)
			{
				parent->_bf = 0;
				subLR->_bf = 0;
				subL->_bf = -1;
			}
			else if (bf == -1)
			{
				parent->_bf = 1;
				subLR->_bf = 0;
				subL->_bf = 0;
			}
			else if (bf == 0)
			{
				parent->_bf = 0;
				subLR->_bf = 0;
				subL->_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 = 0;
				parent->_bf = -1;
				subRL->_bf = 0;
			}
			else if (bf == -1)
			{
				subR->_bf = 1;
				parent->_bf = 0;
				subRL->_bf = 0;
			}
			else if (bf == 0)
			{
				subR->_bf = 0;
				parent->_bf = 0;
				subRL->_bf = 0;
			}
			else
			{
				assert(false);
			}
		
		}

		node* _root = nullptr;
	};

}