一个简易AVL树的实现

        简易的代码实现，包括节点模板和树模板，节点多包含一个节点指针parent，所以树是一个三叉链。

template<class K, class V>
struct AVTreeNode
{
	AVTreeNode(const pair<K, V>& kv)
		:left(nullptr), right(nullptr), parent(nullptr), _bf(0), _kv(kv)
	{}
	AVTreeNode<K, V>* left;
	AVTreeNode<K, V>* right;
	AVTreeNode<K, V>* parent;
	int _bf;//平衡因子
	pair<K, V> _kv;
};

template<class K, class V>
class AVLTree
{
	typedef AVTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		//按搜索树的规则进行插入。
		Node* prt = nullptr;
		Node* cur = _root;
		if (cur == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				prt = cur;
				cur = cur->right;
			}
			else if (cur->_kv.first > kv.first)
			{
				prt = cur;
				cur = cur->left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (prt->_kv.first < kv.first)
		{
			prt->right = cur;
			cur->parent = prt;
		}
		else
		{
			prt->left = cur;
			cur->parent = prt;
		}
		//更新平衡因子。
		while (prt)//只对父节点这条链路的平衡因子有影响。
		{
			if (cur == prt->left)//左树的平衡因子变了，prt节点的平衡因子--。
			{
				prt->_bf--;
			}
			else//右树的平衡因子变了，prt节点的平衡因子++。
			{
				prt->_bf++;
			}

			if (prt->_bf == 0)//更新完之后平衡因子为0，说明这棵树的高度不变。不会对上产生影响
			{
				break;
			}//平衡因子变为1或-1，说明高度发生变化，继续沿夫节点向上检查。
			else if (prt->_bf == 1 || prt->_bf == -1)
			{
				cur = prt;
				prt = prt->parent;
			}//平衡因子变为2或-2，不合法了，需要旋转。
			else if(prt->_bf == 2 || prt->_bf == -2)
			{
				if (prt->_bf == 2)
				{
					if (cur->_bf == 1)
					{
						RotateL(prt);//左单旋
					}						
					else if(cur->_bf == -1)
					{
                        RotateRL(prt);
					}
				}
				else if (prt->_bf == -2)
				{
					if (cur->_bf == -1)
					{
						RotateR(prt);//右单旋
					}
					else if(cur->_bf == 1)
					{
                        RotateLR(prt);
					}
				}
				//旋转处理完成后，prt所在子树的高度与插入前不变,直接跳出。
				break;
			}
		}
		return true;
	}
	void RotateL(Node* parent)//左单旋
	{
		Node* subR = parent->right;
		Node* subRL = subR->left;
		parent->right = subRL;
		if (subRL)
			subRL->parent = parent;
		subR->left = parent;
		Node* ppNode = parent->parent;
		parent->parent = subR;
		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 = 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;
		if (parent == _root)
		{
			_root = subL;
			subL->parent = nullptr;
		}
		else
		{
			if (parent == ppNode->left)
				ppNode->left = subL;
			else
				ppNode->right = subL;
			subL->parent = ppNode;
		}
		parent->_bf = subL->_bf = 0;
	}

	void RotateRL(Node* parent)//右左双旋
	{
		Node* subR = parent->right;
		Node* subRL = subR->left;
		int bf = subRL->_bf;
		RotateR(subR);
		RotateL(parent);
		if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
	}

	void RotateLR(Node* parent)//左右双旋
	{
		Node* subL = parent->left;
		Node* subLR = subL->right;
		int bf = subLR->_bf;
		RotateL(subL);
		RotateR(parent);
		if (bf == -1)
		{
			subL->_bf = 0;
			parent->_bf = 1;
			subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0)
		{
			subL->_bf = 0;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
	}
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_Inorder(root->right);
	}
	void Inorder()
	{
		_Inorder(_root);
	}
private:
	Node* _root = nullptr;
};

        Insert分为两步，第一步，插入节点，具体操作和普通的搜索树类似，第二步，对插入之后的树进行调整。要知道，插入节点只会对由parent进行回溯的那一条链路产生影响，因此调整时，顺着parent的链路迭代调整。

        引入平衡因子，每个节点的平衡因子等于右树高度减左树高度，每个节点的平衡因子绝对值不能大于1。对叶子节点而言，右节点插入，则平衡因子加1， 左节点插入，则平衡因子减1。插入完成后，如果父节点的平衡因子为1或-1，需要一直往上调整，直到父节点平衡因子为0（停止更新）或者为2或-2（旋转操作）。

        旋转操作根据节点平衡因子的情况可以分为四种，左单旋，右单旋，右左双旋，左右双旋。

右左双旋是先对右边子树右单旋，再对parent左单旋，再更新平衡因子（注意平衡因子也要考虑三种情况，具体看代码）。

左右双旋是先对左边子树左单旋，再对parent右单旋，再更新平衡因子（注意平衡因子也要考虑三种情况）。

红黑树

        另一种进阶版的树形结构，本质也是搜索树，也有自己独特的调节平衡的方式。在节点中除了保存key和value值之外，还保存了一个用于调节树平衡的颜色。

        红黑树的一些规则：（1）节点必有颜色，非黑即红。（2）根节点颜色为黑。（3）红节点的子节点必为黑。（4）由根节点到任何一个子节点的链路上黑色节点的数量相同。

        实现的功能：由根节点开始，最长链路的长度不会超过最短链路的两倍。最短链路必为纯黑链路，最长链路长度最大为最短链路加上相同数量的红节点。

调节规则（插入节点为红色）

        （1）第一种情况（cur的父亲为红，叔叔存在且为红）

        cur有可能是新增，也可能是上一个子树的祖父，由相同的操作变色处理而来的，不论是哪种情况，都是parent和uncle变黑再将grandfather变红，如果grandfather是根节点，就再将其变为黑色。注意这种情况下，不用考虑cur和p和u的相对位置，即cur和p为父节点的左或右都一样。

        （2）第二种情况（cur的父亲为红，叔叔不存在或者叔叔为黑）

        这种情况要进行旋转操作，根据cur和p和g三者的相对位置是否为折线，选择进行单旋还是双旋，旋转操作完之后的父亲节点设置为黑色，两个子节点设置为红色，满足红黑树的基本规则。