AVLTree

目录

AVL树的概念

AVL树的定义 

AVL树的插入

AVL树的旋转

---

AVL树的概念

  二叉搜索树虽可以缩短查找的效率，但 如果数据有序或接近有序二叉搜索树将退化为单支树，查

找元素相当于在顺序表中搜索元素，效率低下 。因此，两位俄罗斯的数学家 G.M.Adelson-Velskii

和 E.M.Landis 在 1962 年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过 1( 需要对树中的结点进行调整 ) ，即可降低树的高度，从而减少平均搜索长度。

从上面我们可以了解到如果没有进行调整的搜索树有时候会出现多么糟糕的结果。因此AVL树在查找上面就比普通搜索树更有优势。

AVL树的定义 

 

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

1.它的左右子树都是 AVL 树

2.左右子树高度之差 ( 简称平衡因子 ) 的绝对值不超过 1(-1/0/1)

这样就保证了如果它有 n 个结点，其高度可保持在Log_2_N,进而搜索时间复杂度控制在O(LogN)。

节点的定义：

struct AVL_TreeNode
{
	AVL_TreeNode(const pair<K,V> KV)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0) 
		,_date(KV)
	{}
	AVL_TreeNode* _left;
	AVL_TreeNode* _right;
	AVL_TreeNode* _parent;
	int _bf;// 平衡因子
	pair<K, V> _date;
};

AVL树的插入

AVL 树就是在二叉搜索树的基础上引入了平衡因子，因此 AVL 树也可以看成是二叉搜索树。那么

AVL 树的插入过程可以分为两步：

1. 按照二叉搜索树的方式插入新节点

2. 调整节点的平衡因子

  AVL树的插入相比于普通搜索树更复杂一些，和搜索树一样的，插入节点的key值比比较节点大就向右子树找，反之去左子树找。在插入后我们需要更新平衡因子，插入的新节点平衡因子是0，如果是它父亲的左孩子，父亲的平衡因子--，反之++，如此反复，当父节点平衡因子更新为0时（这时候父亲节点肯定从+-1更新来的 说明父亲这棵树的高度是没有变化的）可以停止再向上更新。如果更新后的平衡因子为+-1说明他是从0变化来的表明这棵树肯定高度变化了，所以要继续向上更新。如此当遇到了平衡因子为 +-2时说明这棵树的左右高度差超过1需要进行旋转，如果再遇到平衡因子的绝对值大于2说明之前的旋转或者平衡因子的更新出了问题，正常是不会出现的，可以断死。

AVL树的旋转

  旋转是AVL树的精华所在，下面分析旋转场景。

1.严格右边高--左单旋

 

什么叫严格右边高呢，就是parent的平衡因子为2，subR为1 ，为正数说明右边高，parent的右边高，subR也是右边高，所以就是严格右边高。 

2.严格左边高--右单旋

参考左单旋。

3.不严格有右边高--右左双旋

 4.不严格左边高--左右双旋

参考右左双旋

再旋转完要更新平衡因子，如上图所示

总结：

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

1. pParent 的平衡因子为 2 ，说明 pParent 的右子树高，设 pParent 的右子树的根为 pSubR

当 pSubR 的平衡因子为 1 时，执行左单旋

当 pSubR 的平衡因子为 -1 时，执行右左双旋

2. pParent 的平衡因子为 -2 ，说明 pParent 的左子树高，设 pParent 的左子树的根为 pSubL

当 pSubL 的平衡因子为 -1 是，执行右单旋

当 pSubL 的平衡因子为 1 时，执行左右双旋

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

#pragma once
#include<iostream>
#include<vector>
#include<cassert>
#include<algorithm>
using namespace std;
template<class K, class V>
struct AVL_TreeNode
{
	AVL_TreeNode(const pair<K,V> KV)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
		,_date(KV)
	{}
	AVL_TreeNode* _left;
	AVL_TreeNode* _right;
	AVL_TreeNode* _parent;
	int _bf;// 平衡因子
	pair<K, V> _date;
};

template<class K, class V>
class AVL_Tree
{
public:
	typedef AVL_TreeNode<K,V> Node;

	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->_date.first > KV.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_date.first < KV.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(KV);
		if (parent->_date.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 (abs(parent->_bf) == 1)
			{
				// 之前为0，更新后的bf的绝对值为1
				// 说明parent的子树高度发生变化的，因此要继续向上调整
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 0)
			{
				// 说明之前绝对值为1，bf变为0说明parent子树的高度没变，不用继续更新bf
				break;
			}
			else if (abs(parent->_bf) == 2)
			{
				//旋转
				if (parent->_bf == -2 && parent->_left->_bf == -1)
				{
					// 左左右单旋
					RotateR(parent);
					break;
				}
				else if (parent->_bf == 2 && parent->_right->_bf == 1)
				{
					// 右右左单旋
					RotateL(parent);
					break;

				}
				else if (parent->_bf == -2 && parent->_left->_bf == 1)
				{
					
					//左右双旋
					RotateLR(parent);
					break;

				}
				else if (parent->_bf == 2 && parent->_right->_bf == -1)
				{

					// 右左双旋
					RotateRL(parent);
					break;

				}
				else
				{
					assert(false);
				}
				
			}
		}
		return true;
	}
	void RotateR(Node* parent) // 右单旋
	{
		Node* SubL = parent->_left;
		Node* SubLR = SubL->_right;
		Node* ppNode = parent->_parent;
		parent->_left = SubLR;

		if (SubLR)
		{
			SubLR->_parent = parent;
		}
		SubL->_right = parent;
		parent->_parent = SubL;

		if (parent == _root) // 如果是根
		{
			_root = SubL;
			SubL->_parent = nullptr;

		}
		else // 如果是子树的根
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = SubL;
				SubL->_parent = ppNode;
			}
			else
			{
				ppNode->_right = SubL;
				SubL->_parent = ppNode;
			}
		}
		parent->_bf = SubL->_bf = 0;
	}
	void RotateL(Node* parent) // 左单旋
	{
		Node* SubR = parent->_right;
		Node* SubRL = SubR->_left;
		Node* ppNode = parent->_parent;
		parent->_right = SubRL;

		if (SubRL) 
		{
			SubRL->_parent = parent;
		}
		
		parent->_right = SubRL;
		SubR->_left = parent;
		parent->_parent = SubR;
		
		if (parent == _root)
		{
			_root = SubR;
			SubR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = SubR;
				SubR->_parent = ppNode;
			}
			else
			{
				ppNode->_right = SubR;
				SubR->_parent = ppNode;
			}
		}
		SubR->_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) // 当新节点插入在subLR的左侧
		{
			subLR->_bf = 0;
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1) // 当新节点插入在subLR的右侧
		{
			subLR->_bf = 0;
			subL->_bf = -1;
			parent->_bf = 0;
		}
		else if (bf == 0) // 当subLR就是新节点
		{
			subLR->_bf = 0;
			subL->_bf = 0;
			parent->_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)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
			subRL = 0;
		}
		else if(bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL = 0;
		}
		else
		{
			assert(false);
		}

	}

	void Inorder()
	{
		_Inorder(_root);
	}
	void _Inorder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_date.first << ":" << root->_date.second << " ";
		_Inorder(root->_right);
	}

	int Hight(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int left = Hight(root->_left);
		int right = Hight(root->_right);
		return max(left, right) + 1;
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int left = Hight(root->_left);
		int right = Hight(root->_right);
		int dig = abs(left - right);
		return dig < 2 && _IsBalance(root->_left) && _IsBalance(root->_right);
	}
public:
	AVL_TreeNode<K, V>* _root = nullptr;
};