• AVL树是最先发明的⾃平衡⼆叉查找树，AVL是⼀颗空树，或者具备下列性质的⼆叉搜索树：它的左右⼦树都是AVL树，且左右⼦树的⾼度差的绝对值不超过1。AVL树是⼀颗⾼度平衡搜索⼆叉树，通过控制⾼度差去控制平衡。AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis是两个前苏联的科学家，他们在1962年的论⽂《An algorithm for the organization of information》中发表了它。
• AVL树实现这⾥我们引⼊⼀个平衡因⼦(balance factor)的概念，每个结点都有⼀个平衡因⼦，该
结点的平衡因⼦等于右⼦树的⾼度减去左⼦树的⾼度，也就是说任何结点的平衡因⼦等于0/1/-1，
AVL树并不是必须要平衡因⼦，但是有了平衡因⼦可以更⽅便我们去进⾏观察和控制树是否平衡，
就像⼀个⻛向标⼀样。
• 思考⼀下为什么AVL树是⾼度平衡搜索⼆叉树，要求⾼度差不超过1，⽽不是⾼度差是0呢？0不是更好的平衡吗？画画图分析我们发现，不是不想这样设计，⽽是有些情况是做不到⾼度差是0的。⽐如⼀棵树是2个结点，4个结点等情况下，⾼度差最好就是1，⽆法做到⾼度差是0
• AVL树整体结点数量和分布和完全⼆叉树类似，⾼度可以控制在 logN ，那么增删查改的效率也可
以控制在 O(logN) ，相⽐⼆叉搜索树有了本质的提升。

熟识pair （在命名空间std中）

STL中的底层结构

用法：pair<string, string> p = { "left","左边" }在这句中相当于left单词和“左边”这个定义绑定在一起，可以通过left找到对应的定义，就像字典一样。

成员变量

有两个成员变量：first，second。first指的是位于pair的第一个值，second指位于pair第二个位置的值。

将数据输入到 `pair` 中的方式：

在这篇文章中常用的：

1.运用是std::make_pair。pair<string,string>p1=make_pair("left","左边");

2.使用列表初始化。pair<string, string> p = { "left","左边" };

AVL树的模拟实现

定义AVL树节点结构

在前面学习的二叉搜索树中，我们了解到二叉搜索树节点的成员有数据和它的左右孩子，但今天我们学习到的AVL树不仅有二叉搜索树的成员，还多了两个成员——parent（节点的父亲）和平衡因子。

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

AVL树的插入

AVL树插入一个值的大概过程

1.插⼊⼀个值按⼆叉搜索树规则进⾏插⼊。
2. 新增结点以后，只会影响祖先结点的⾼度，也就是可能会影响部分祖先结点的平衡因⼦，所以更新从新增结点->根结点路径上的平衡因⼦，实际中最坏情况下要更新到根，有些情况更新到中间就可以停⽌了，具体情况我们下⾯再详细分析。
3. 更新平衡因⼦过程中没有出现问题，则插⼊结束
4. 更新平衡因⼦过程中出现不平衡，对不平衡⼦树旋转，旋转后本质调平衡的同时，本质降低了⼦树的⾼度，不会再影响上⼀层，所以插⼊结束。

平衡因子更新

• 平衡因⼦ = 右⼦树⾼度-左⼦树⾼度
• 只有⼦树⾼度变化才会影响当前结点平衡因⼦。
• 插⼊结点，会增加⾼度，所以新增结点在parent的右⼦树，parent的平衡因⼦++，新增结点在parent的左⼦树，parent平衡因⼦--
• parent所在⼦树的⾼度是否变化决定了是否会继续往上更新

更新停止条件：

• 更新后parent的平衡因⼦等于0，更新中parent的平衡因⼦变化为-1->0 或者 1->0，说明更新前parent⼦树⼀边⾼⼀边低，新增的结点插⼊在低的那边，插⼊后parent所在的⼦树⾼度不变，不会影响parent的⽗亲结点的平衡因⼦，更新结束。
• 更新后parent的平衡因⼦等于1 或 -1，更新前更新中parent的平衡因⼦变化为0->1 或者 0->-1，说明更新前parent⼦树两边⼀样⾼，新增的插⼊结点后，parent所在的⼦树⼀边⾼⼀边低，parent所在的⼦树符合平衡要求，但是⾼度增加了1，会影响parent的⽗亲结点的平衡因⼦，所以要继向上更新。
• 更新后parent的平衡因⼦等于2 或 -2，更新前更新中parent的平衡因⼦变化为1->2 或者 -1->-2，说明更新前parent⼦树⼀边⾼⼀边低，新增的插⼊结点在⾼的那边，parent所在的⼦树⾼的那边更⾼了，破坏了平衡，parent所在的⼦树不符合平衡要求，需要旋转处理，旋转的⽬标有两个：1、把parent⼦树旋转平衡。2、降低parent⼦树的⾼度，恢复到插⼊结点以前的⾼度。所以旋转后也不需要继续往上更新，插⼊结束。
• 不断更新，更新到根，根的平衡因⼦是1或-1也停⽌了。

旋转

旋转的原则

1.保持搜索树的规则
2. 让旋转的树从不满⾜变平衡，其次降低旋转树的⾼度
旋转总共分为四种，左单旋/右单旋/左右双旋/右左双旋。

右单旋

右旋用于处理左偏的情况，即节点的左子树比右子树高2。

右旋代码

void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		
		//处理_parent(subL,subLR,parent)
		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node* parentP = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (parentP == nullptr)
		{
			subL = _root;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == parentP->_left)
			{
				parentP->_left = subL;
			}
			else
			{
				parentP->_right = subL;
			}
			subL->_parent = parentP;
		}
		subL->_bf = parent->_bf = 0;
	}

左单旋

左旋用于处理右偏的情况，即节点的右子树比左子树高2。

左旋代码

需处理的关系如下图

void RotateL(Node* parent)
	{
		Node*subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* parentP = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;
		if (parentP == nullptr)
		{
			subR = _root;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == parentP->_right)
			{
				parentP->_right = subR;
			}
			else
			{
				parentP->_left = subR;
			}
			subR->_parent = parentP;
		}
		subR->_bf = parent->_bf = 0;
	}

左右双旋

左右旋是先对左子树进行左旋，再对当前节点进行右旋。它用于处理左偏且左子树右偏的情况。

就如下面这棵树，对于10节点来说，左子树偏高，对于5节点来说右子树偏高，所以这时候就可以用左右双旋了。先让5节点作为旋转点进行左旋，旋转完后让10作为旋转点进行右旋。

b⼦树中新增结点的位置不同，平衡因⼦更新的细节也不同，通过观察8的平衡因⼦不同，这⾥我们要分三个场景讨论。
• 场景1：h >= 1时，新增结点插⼊在e⼦树，e⼦树⾼度从h-1并为h并不断更新8->5->10平衡因⼦，
引发旋转，其中8的平衡因⼦为-1，旋转后8和5平衡因⼦为0，10平衡因⼦为1。
• 场景2：h >= 1时，新增结点插⼊在f⼦树，f⼦树⾼度从h-1变为h并不断更新8->5->10平衡因⼦，引
发旋转，其中8的平衡因⼦为1，旋转后8和10平衡因⼦为0，5平衡因⼦为-1。
• 场景3：h == 0时，a/b/c都是空树，b⾃⼰就是⼀个新增结点，不断更新5->10平衡因⼦，引发旋
转，其中8的平衡因⼦为0，旋转后8和10和5平衡因⼦均为0。

把上图中的b子树展开成8节点的子树。下面是场景1。

左右双旋代码

void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		//已经插入后的bf
		int bf = subLR->_bf;
		RotateL(parent->_left);
		RotateR(parent);
		
		if (bf == 0)
		{
			subL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

右左双旋

右左旋是先对右子树进行右旋，再对当前节点进行左旋。它用于处理右偏且右子树左偏的情况。

就如下面这棵树，对于10节点来说，右子树偏高，对于5节点来说左子树偏高，所以这时候就可以用右左双旋了。先让5节点作为旋转点进行右旋，旋转完后让10作为旋转点进行左旋。

b⼦树中新增结点的位置不同，平衡因⼦更新的细节也不同，通过观察12的平衡因⼦不同，这⾥我们要分三个场景讨论。
• 场景1：h >= 1时，新增结点插⼊在e⼦树，e⼦树⾼度从h-1变为h并不断更新12->15->10平衡因
⼦，引发旋转，其中12的平衡因⼦为-1，旋转后10和12平衡因⼦为0，15平衡因⼦为1。
• 场景2：h >= 1时，新增结点插⼊在f⼦树，f⼦树⾼度从h-1变为h并不断更新12->15->10平衡因⼦，
引发旋转，其中12的平衡因⼦为1，旋转后15和12平衡因⼦为0，10平衡因⼦为-1。
• 场景3：h == 0时，a/b/c都是空树，b⾃⼰就是⼀个新增结点，不断更新15->10平衡因⼦，引发旋
转，其中12的平衡因⼦为0，旋转后10和12和15平衡因⼦均为0。

右左双旋代码

void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		//已经插入后的bf
		int bf = subRL->_bf;
		RotateR(parent->_right);
		RotateL(parent);

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

插入的完整代码

bool 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 == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				if (parent->_bf == -2 && cur->_bf == -1)//右单旋
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)//左单旋
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)//左右双旋
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)//右左双旋
				{
					RotateRL(parent);
				}
				else
				{
					return false;
				}
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

AVL树的查找

和二叉搜索树一样的查找。

bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if(cur->_kv.first>key)
			{
				cur = cur->_left;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

AVL树的检测

根据AVL树的性质检测：

1.它的左右⼦树都是AVL树，且左右⼦树的⾼度差的绝对值不超过1

2.平衡因⼦等于右⼦树的⾼度减去左⼦树的⾼度

	int _Hight(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftHight = _Hight(root->_left);
		int rightHight = _Hight(root->_right);
		return leftHight > rightHight ? leftHight + 1 : rightHight + 1;
	}
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int leftHight = _Hight(root->_left);
		int rightHight = _Hight(root->_right);
		int diff = rightHight - leftHight;
		if (abs(diff) >= 2 )
		{
			return false;
		}
		if (root->_bf != diff)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
		return _IsBalance(root->_right) && _IsBalance(root->_left);
	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}

完整代码

#include<assert.h>
#include<iostream>
using namespace std;
template<class K,class V>
struct AVLNode
{
	typedef AVLNode<K, V> Node;
	pair<K, V>_kv;
	Node* _right;
	Node* _left;
	Node* _parent;
	int _bf;
	AVLNode(const pair<K, V>& kv)
		:_kv(kv)
		,_right(nullptr)
		,_left(nullptr)
		,_parent(nullptr)
		,_bf(0)
	{}
};
template<class K,class V>
class AVLTree
{
	typedef AVLNode<K, V> Node;
public:
	bool 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 == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if(cur->_kv.first>key)
			{
				cur = cur->_left;
			}
			else
			{
				return true;
			}
		}
		return false;
	}
	int _Hight(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftHight = _Hight(root->_left);
		int rightHight = _Hight(root->_right);
		return leftHight > rightHight ? leftHight + 1 : rightHight + 1;
	}
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int leftHight = _Hight(root->_left);
		int rightHight = _Hight(root->_right);
		int diff = rightHight - leftHight;
		if (abs(diff) >= 2 )
		{
			return false;
		}
		if (root->_bf != diff)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
		return _IsBalance(root->_right) && _IsBalance(root->_left);
	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		
		//处理_parent(subL,subLR,parent)
		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node* parentP = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (parentP==nullptr)
		{
			subL=_root;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == parentP->_left)
			{
				parentP->_left = subL;
			}
			else
			{
				parentP->_right = subL;
			}
			subL->_parent = parentP;
		}
		subL->_bf = parent->_bf = 0;
	}
	void RotateL(Node* parent)
	{
		Node*subR = parent->_right;//
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* parentP = parent->_parent;
		subR->_left = parent;//x
		parent->_parent = subR;
		if (parent == _root)
		{
			 subR =_root ;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == parentP->_right)
			{
				parentP->_right = subR;
			}
			else
			{
				parentP->_left = subR;
			}
			subR->_parent = parentP;
		}
		subR->_bf = parent->_bf = 0;
	}
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		//已经插入后的bf
		int bf = subLR->_bf;
		RotateL(parent->_left);
		RotateR(parent);
		
		if (bf == 0)
		{
			subL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		//已经插入后的bf
		int bf = subRL->_bf;
		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else
		{
			assert(false);
		}
	}
private:
	Node* _root=nullptr;
};