数据结构---AVL树

1. AVL树的概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

• 它的左右子树都是AVL树
• 左右子树（所有的）高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

2. AVL树节点的定义

template<class K,class V>
struct AVLTreeNode
{
	//使用三叉连,这样也比较便于找到parent节点
	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) //刚创建出来的节点左右子树都是空，所以平衡因子给0
	{}
};

3. AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

新增节点可能会影响它到根结点这条路径上的祖先。

3.1 AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：但是这里首先分析一下所给的树，为什么给的是抽象模型。

3.1.1 右单旋

新结点插入较高左子树的左侧：

为了能够更好的理解这段代码，需要在借助下面的这个图。

1. b去做60的左子树
2. 60做30的右子树
3. 30结点成了这棵树新的根

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

		parent->_left = subLR;
		//但是subLR有可能是空的，那么下面这个代码就会崩
		if (subLR)
			subLR->_parent = parent;//此树为一个三叉链，所以一定要注意更新父节点的指针

		//如果这个右旋只是一颗树的一部分，那么后面会改变最开始的父指针，所以要预先保留下来
		Node* parentParent = parent->_parent;

		subL->_right = parent;  
		parent->_parent = subL;


		//此时还需要最后一步，把根结点换掉
		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			//此时你需要把30这个结点连接住，但是应该连接在哪一边还需要进行判断
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}

		//还有平衡因子的更新
		subL->_bf = parent->_bf = 0;
	}

3.1.2 左单旋

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

1. b去做了30的右子树
2. 30做了60的左子树
3. 60结点成了这棵树新的根结点

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

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
		
		Node* parentParent = parent->_parent;//先保存下来，因为后面会改变这个，就找不到最开始的父节点了
		
		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			//作为子树的一部分
			if (parentParent->_left == parent)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}
			subR->_parent = parentParent;	
		}
		//平衡因子
		subR->_bf = parent->_bf = 0;
	}

3.1.3 先左单旋再右单旋

新节点插入较高左子树的右侧

将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。看是看上图也可以发现，在b插入一个新节点和在c插入一个新节点的最终结果是不一样的，所以还需要分类讨论。

为了能够更好的理解这段代码，需要在借助下面的这个图。

1. 先把30结点作为parent结点，进行一个左单旋操作
2. 再把90作为parent结点，进行一个右单旋
3. 其实大致的思想和单旋基本一致

void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = parent->_left->_right;
		int bf = subLR->_bf;

		RotateL(subL);//这里的左旋和右旋操作会最终改变平衡因子，所以前面进行保存，以便讨论
		RotateR(parent);

		//如果在b或者c插入节点，导致b或者c的高度增加了1，就会引起双旋并且要分开讨论，b插入或者c插入，树的平衡因子更新是要分开看待的
		if (bf == 1) // 说明subLR是右树插入（看图解释就是c处）
		{
			subLR->_bf = 0;//(类比于图中，60这个结点平衡因子肯定是0)
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)   // 说明subLR是左树插入（看图解释就是b处）
		{
			subLR->_bf = 0;
			parent->_bf = 1;
			subL->_bf = 0;
		}
		else if(bf == 0)//bf == 0说明subLR是新增结点
		{
			subL->_bf = subLR->_bf = parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

3.1.4 先右单旋再左单旋

新节点插入较高右子树的左侧


将双旋变成单旋后再旋转，即：先对30进行右单旋，然后再对90进行左单旋，旋转完成后再考虑平衡因子的更新。看是看上图也可以发现，在b插入一个新节点和在c插入一个新节点的最终结果是不一样的，所以还需要分类讨论。

为了能够更好的理解这段代码，需要在借助下面的这个图。

1. 先把30结点作为parent结点，进行一个右单旋操作
2. 再把90作为parent结点，进行一个左单旋
3. 其实大致的思想和单旋基本一致

	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);//这里的左旋和右旋操作会最终改变平衡因子，所以前面进行保存，以便讨论
		RotateL(parent);

		if (bf == 1)   // 说明subRL是右树插入（看图解释就是c处）
		{
			subRL->_bf = 0;
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)  // 说明subRL是左树插入（看图解释就是b处）
		{
			subRL->_bf = 0;
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if(bf == 0)  //bf == 0说明subLR是新增结点
		{
			subRL->_bf = subR->_bf = parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

3.1.5 完整的AVL树插入代码

pair<Node*, bool> Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return make_pair(_root, true);
		}
		Node* parent = nullptr;
		Node* cur = _root;
		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 make_pair(cur, false);
			}
		}

		cur = new Node(kv);
		//此时说明已经找到了位置，还需要进行插入
		if (parent->_kv.first < kv.first)
		{
			//说明此时应该链接在父节点的右边
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}


		Node* newnode = cur;
		//在这里插入成功了，但是他会影响祖先的平衡因子，所以这里也是和二叉搜索树的不同和关键所在
		//1.更新平衡因子
		while (parent)
		{
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}

			if (parent->_bf == 0)
			{
				break;//说明parent所在子树的高度不变（没有更新前，parent->_bf是1或者-1，又一遍高，现在变成了0，说明把矮的
				//那边给填上了），不会再对上层路径上的结点构成影响，所以更新结束。
			}
			else if (abs(parent->_bf) == 1)
			{
				//说明parent所在的子树的高度改变了，对上一层是有影响的，需要继续向上更新
				cur = parent;
				parent = parent->_parent;//往上跳一层
			}
			else if (abs(parent->_bf) == 2)
			{
				//说明parent所在的子树已经不再平衡了，需要旋转处理
				//此时就是旋转的问题
				//1.右单旋
				//2.左单旋
				//3.先左单旋再右单旋
				//4.先右单旋再左单旋
				if (parent->_bf == -2)
				{
					if (cur->_bf == -1)
					{
						RotateR(parent);
					}
					else //cur->_bf == 1
					{
						RotateLR(parent);
					}
				}
				else
				{
					if (cur->_bf == 1)
					{
						RotateL(parent);
					}
					else //cur->_bf == -1
					{
						RotateRL(parent);
					}
				}
				break;//旋转完成之后，就已经恢复了原来的平衡二叉树特性
			}
			else
			{
				//就不可能走到这里，如果走到了，说明在平衡因子为2的时候，就没有正确的处理
				assert(false);
			}
		}

		//这里的cur可能会改变，因为会向上进行更新,所以可以早早的保存下来
		make_pair(newnode, true);
	}

总结：
假如以parentParent为根的子树不平衡，即parentParent的平衡因子为2或者-2，分以下情况考虑

1. parentParent的平衡因子为2，说明parent的右子树高，设parentParent的右子树的根为SubR
   - 当subR的平衡因子为1时，执行左单旋
   - 当subR的平衡因子为-1时，执行右左双旋

2. parentParent的平衡因子为-2，说明parentParent的左子树高，设parentParent的左子树的根为subL
   - 当subL的平衡因子为-1是，执行右单旋
   - 当subL的平衡因子为1时，执行左右双旋

旋转完成后，原parentParent为根的子树个高度降低，已经平衡，不需要再向上更新。

4. AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的，因此要验证AVL树，可以分两步：

1. 验证其为二叉搜索树
   如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
2. 验证其为平衡树
   • 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
   • 节点的平衡因子是否计算正确

	int Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		//这里可以使用一个max函数，来求二者之间的较大值
		return Height(root->_left) > Height(root->_right) ? Height(root->_left) + 1 : Height(root->_right) + 1;
	}

	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}

		int leftHeight = Height(root->_left); 
		int rightHeight = Height(root->_right);

		if (rightHeight - leftHeight != root->_bf)
		{
			cout << "平衡因子异常：" << endl;
		}
		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
		//第一个是当前树的，但是他满足还不足以，还需要他们的子树也都满足平衡二叉树的特性才可以

	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}


	void _Inorder(Node*& root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_kv.first << " ";
		_Inorder(root->_right);
	}

	void Inorder()
	{
		_Inorder(_root);
	}

#include"AVLTree.h"

int main()
{
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	AVLTree<int, int> t;

	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}

	t.Inorder();
	cout << endl;
	cout<<t.IsBalance()<<endl;
}

5. AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即log(N)(以2为底) 。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。