AVL树的理解和实现

AVL树，也叫高度平衡二叉搜索树
左右子树都是AVL树
左右子树高度差（简称平衡因子）的绝对值不超过1（-1/0/1）

平衡因子 = 右子树高度 - 左子树高度
AVL树不一定需要平衡因子
使用平衡因子是一种控制实现方式

三叉链存储，有一对pair和平衡因子

插入
有一个parent,有一个cur
插入的是三叉链，parent也要指

怎么知道平衡不平衡
新插入的 平衡因子一定是0
插入在父节点的右边，父节点的平衡因子+1；插入在左边，父节点平衡因子-1
cur是新增结点，它只会影响cur节点的平衡因子

控制平衡
1.更新平衡因子 – 新增节点到根节点的祖先路径
①cur ==parent->left , parent->left–
②cur ==parent->right,parent->right++
③更新以后，parent->bf == 0，更新结束 —— 说明更新前parent -> bf是1或者-1，现在变成0，说明填上了矮的那边，parent所在子树高度不变
④更新以后，parent->bf == 1 或 -1，继续网上处理 —— 说明更新前parent->bf是0，现在变成1或-1，有一边子树变高了，parent所在子树高度
变了，会继续对上面子树有影响
往上走的过程是三叉链的威力之处
⑤更新以后，parent->bf == 2或-2, parents所在的子树就已经不平衡了，需要旋转处理

最坏的情况，一路更新到根
写的时候添加注意，方便以后查看
不是以上的五种情况直接断言，说明插入之前就有问题了

2.出现异常的平衡因子，旋转处理

简单感受
插入123 213 321
树的结构都是不同的

右单旋
抽象图，代表很多种情况
抽线图 对应的是 具象图
如果a变成h+1,会引发60的bf变成-2，触发旋转
为什么叫右单旋？因为树的左边高，需要往右边去旋转，使得左右平衡
做到两点：
①保持搜索树规则
②控制平衡
对抽象图来说，b变成60的左边，60变成30的右边

旋转的意义：1 .这棵树平衡了 2 .整体高度降了1
条件：cur的bf是-1 ， parent的bf是-2 ，进行旋转
不是简单的将cur的右边（subLR）给给parent的左边这么简单的
因为不只更新平衡因子，还需要更新三叉链
b有可能是空，要避免空指针的问题
最后如果parent不是根结点，还需要把parent跟上面的结点进行链接
时时刻刻要维护好我们的三叉链

降序插入则会一直右单旋，可以调试查看

左单旋
右边高，进行左单旋
和右单旋类似

左右双旋
30轴点是右边高，90轴点是左边高
如果用单旋的方式，结果还有有错误，本来左边高，会变成右边高
左右双旋->30的结点左单旋【右边高】，90的结点右单旋【左边高】（经过左单旋，变成完全左边高，再右单旋，平衡）
步骤：
1 .30为轴点，进行左单旋
2 .90为轴点，进行右单旋

AVL树的三个大规则
1.按搜索树的规则插入
2.更新平衡因子
3.出现不平衡，旋转处理

旋转分为四种
1.左边高，要往右边压，叫做右单旋
2.右边高，要往左边压，叫做左单旋
3.通过单旋无法平衡，用双旋

判断avl树是不是平衡树？
检查平衡因子是不对的，可能会存在问题（万一平衡因子更新错了）
用高度来判断是最好的，递归检查，每一棵子树都要检查一遍
检查左右树差值是否小于2即可
这样做完以后树的形态是对的，单平衡因子不一定对（可能会引发不该旋转的时候旋转）
所以还要对平衡因子进行检查

调试是一种手段，多的是日志

双选不可以简简单单的进行左旋+右旋
期间平衡因子有多种变化，不是直接复用之前的代码可以解决的，还需要重新处理

右左双旋（图）
可以看成60的结点分发给了两边

左右双旋（图）

AVL在实际用途并不多，主要是有了红黑树

AVL树的实现代码：
AVL.h

#pragma once
#include <set>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <queue>
#include <functional>
#include <assert.h>

using namespace std;

template<class K,class V>
struct AVLNode {
    
	//存储三叉链以及平衡因子，还有一对键值对
	struct AVLNode<K, V>* _parent;
	struct AVLNode<K, V>* _left;
	struct AVLNode<K, V>* _right;

	int _bf;
	pair<K, V> _kv;
	AVLNode(const pair<K,V>& kv)
		:_parent(nullptr),
		_left(nullptr),
		_right(nullptr),
		_bf(0),
		_kv(kv)
	{
    }
};

template<class K,class V>
class AVLTree {
    
	typedef AVLNode<K, V> Node;
public:
	AVLTree()
		:_root(nullptr)
	{
    }

	//插入
	bool Insert(const pair<K, V>& kv)
	{
    
		if (_root == nullptr)
		{
    
			_root = new Node(kv);
			return 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 false;
			}
		}

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

		//开始调整平衡因子

		while (parent)
		{
    
			if (cur == parent->_left)
				parent->_bf--;
			else
				parent->_bf++;

			if (parent->_bf == 0)
			{
    
				return true;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
    
				//如果平衡因子是1或-1的话，继续网上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
    
				//如果平衡因子是2的话，就要进行旋转
				//具体旋转根据树的形态来定

				if (cur->_bf == 1 && parent->_bf == 2)//右树（右边高）的情况，进行左旋
				{
    
					RotateL(parent);
				}
				else if (cur->_bf == -1 && parent->_bf == -2)
				{
    
					RotateR(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
    
					RotateLR(parent);
				}
				else if(parent->_bf == 2 && cur->_bf == -1)
				{
    
					RotateRL(parent);
				}
				else
				{
    
					assert(false);//不可能情况断言报错，
				}

				break;
			}
		}

		return true;
	}

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

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

		Node* parentParent = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;

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

			subL->_parent = parentParent;
		}

		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* parentParent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

		if (_root == parent)
		{
    
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
    
			if (parent == parentParent->_left)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;

			subR->_parent = parentParent;
		}

		subR->_bf = 0;
		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;
			subL->_bf = -1;
			subLR = 0;
		}
		else if (bf == -1)
		{
    
			parent->_bf = -1;
			subL->_bf = 0;
			subLR = 0;
		}
		else if (bf == 0)
		{
    
			parent->_bf = 0;
			subL->_bf = 0;
			subLR = 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)
		{
    
			subRL->_bf = 0;
			parent->_bf = -1;
			subR->_bf = 0;
		}
		else if (bf == -1)
		{
    
			subRL->_bf = 0;
			parent->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 0)
		{
    
			subRL->_bf = 0;
			parent->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
    
			assert(false);
		}
	}

	void InOrder()
	{
    
		_InOrder(_root);
	}

	void _InOrder(Node* root)
	{
    
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

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

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

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

		return leftHeight + 1 ?rightHeight + 1 : leftHeight > rightHeight;
	}

	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 << root->_kv.first << "的平衡因子是" << root->_bf << endl;
			cout << root->_kv.first << "的平衡因子应该是" << rightHeight - leftHeight << endl;
			return false;
		}

		return abs(rightHeight - leftHeight)< 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}


private:
	Node* _root;
};

void TestAVLTree()
{
    
	AVLTree<int, int> t;
	//int a[] = { 5,4,3,2,1,0 };
	int a[] = {
     16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : a)
	{
    
		t.Insert(make_pair(e, e));
		cout << "Insert" << e << ":" << t.IsBalance() << endl;
	}
	t.InOrder();
}