【数据结构】AVL详解+模拟

一.AVL树的概念

AVL树本质上还是二叉搜索树，但是我们都知道，当插入的数据有序或者接近有序的时候二叉搜索就会退化，时间复杂度会降为O(N)。AVL就是为了解决这种问题而出现的，而后来的红黑树也以avl树为基础实现的。avl树会在当左右子树高度差大于1的时候进行旋转，从而让树的高度下降并保持在logn

二.AVL树的插入

AVL树的节点是由三叉链组成的。外加平衡因子，平衡因子就是用来控制旋转的。在我们插入一个数据的时候，前期和正常的二叉搜索树的插入一样，先通过比较找到插入的位置，再用插入的数据生成新的节点并插入。唯一的区别是要多保存一个指针指向它的父节点。插入新数据后需要更新平衡因子。如果新增在根节点的右子树的话则parent的平衡因子自增，若新增在左子树则平衡因子自减。更新后如果平衡因子变成1或者-1则需要将平衡因子的改变向上传递。若平衡因子变成2或者-2则说明当前树已经不平衡了，需要跳出进行旋转。若平衡因子变成0说明当前左右子树已经平衡，此时不需要继续向上更新。因为平衡因子更新是从下向上进行的。当前子树及以下已经平衡，即使往上更新也不会有任何变化，因为上面也是平衡的。理论上更新后是不会存在大于2和小于-2的值的。（插入过程中平衡因子的更新是重点）

三.AVL树的旋转

AVL树的旋转一共有四种情况：右单旋，左单旋，左右双旋，右左双旋。每次旋转都有六组指针需要处理

右单旋：新节点插入较高子树的左侧时候进行右单旋。这里举个例子。

 

新增是d，插入d后30的平衡因子变为-1，60的平衡因子变为-2，此时开始进行旋转。 首先我们把60的左指针指向b，如果b不为空的话再把b的父指针指向60.这是两组指针

 再把30的右指针指向60，再把60的父指针指向30，这里有一点需要注意，需要提前保存60 的父节点，因为60不一定是根节点。这里也处理了两组指针。

 

 接下来又分为两种情况，若原来60为根节点的时候。我们需要让现在的30变成根节点，并让30的父节点置成空(如果是这种情况的话实际是处理了五组指针，最后一组指针因为是空不能解引用所以少一组。)另一种情况是60之上还有节点，此时我们需要判断原来的parent是他上级节点的右子树还是左子树。并和30连接起来。并让30指向他。到此一共处理了六组指针。

 目前为止我们实现了插入功能，但我们还有平衡因子没有处理，从图上可以看到原来的根节点的平衡因子应该置为0，同时新的根节点平衡因子也应该设置成0。

左单旋：新增节点在较高右子树的右侧

左旋和右旋的逻辑是完全一样的不过是反方向旋转。这里就不详细说明了，通过画图来演示。新增为d。

 

 第一二组指针在b和60之间

 第三四组指针在30和60之间

 

 第五六组指针处理根节点和上层节点的关系

左右双旋：新增在较高左子树的右侧，也就是b的下边或者c的下边。这种情况我们需要先对30为根节点的这棵树进行左旋

 

 左旋后变成这个样子，让较高的部分变成整棵树的左子树，这时候再对整棵树进行右旋

 右旋后整棵树就平衡了。

 双旋本质上就是对单旋的复用。双旋的难点不在于旋转的过程，而是在于平衡因子的处理。一共有三种情况，因为e可能新增在b或者c也有可能a,b,c,d都是空新增就是60，这会导致每种情况60这个位置的平衡因子都会不同。

 首先说新增在b时的情况：这时60的平衡因子会变成-1，我们可以通过这个平衡因子来判断属于哪种情况。旋转后由上图可知，新的根节点平衡因子为0，原根节点平衡因子为1，原来的左子树平衡因子为0

新增在c的时候：会变成下图的形式，通过观察可发现后来的根节点平衡因子一直为0 ，两种情况的不同之处在于旋转后新增的节点可能会在左子树的右边，或者在右子树的左边，导致左子树可能为0或-1，右子树可能为1或0

 当60就是新增时，最后会旋转成如图，都为0，这种情况算是特殊情况。

右左双旋：新增节点在较高右子树的左侧，这种情况进行右左双选，先把60为根节点的树进行右旋

 

 再对整棵树进行左旋

同样右左双旋也面临着平衡因子的三种情况。 当新增在e的时候，原来根节点变为0，根节点的右节点变为1，新的根节点变为0.当新增在c时，原来根节点变为-1，根节点的右节点变为0，新的根节点变为0。当60就是新增时，和左右双旋一样都为0.

 四.代码模拟实现

template <class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& data = T())
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _bf(0)
	{
	}

	AVLTreeNode<T>* _pLeft;
	AVLTreeNode<T>* _pParent;
	AVLTreeNode<T>* _pRight;
	T _data;
	int _bf;  //节点的平衡因子
};
template <class T>
class AVLTree
{
	typedef AVLTreeNode <T> Node;
public:

	AVLTree()
		:_root(nullptr)
	{}

	bool IsAVLTree()
	{
		return _IsAVLTree(_root);
	}

	bool Insert(const T& data)
	{
		if (_root == nullptr)  //处理当树为空时
		{
			_root = new Node(data);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		                        //寻找插入位置
		while (cur)   
		{
			if (cur->_data < data)
			{
				parent = cur;
				cur = cur->_pRight;
			}
			else if (cur->_data > data)
			{
				parent = cur;
				cur = cur->_pLeft;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(data);  //找到位置插入节点

		cur->_pParent = parent;  //调整新插入节点的两个指针指向。
		if (parent->_data < data)
		{
			parent->_pRight = cur;
		}
		else if (parent->_data > data)
		{
			parent->_pLeft = cur;
		}
		 //处理平衡因子
		while (parent)    //从当前节点依次向上传导
		{
			if (cur == parent->_pRight)    //当前子树处于右子树，负载因子自增
			{
				parent->_bf++;
			}
			else if (cur == parent->_pLeft)  //当前子树位于左子树，负载因子自减
			{
				parent->_bf--;
			}
			if (parent->_bf == 0)    //当前负载因子为0.不需要继续向上传递了。
			{
				break;
			}
			else if (abs(parent->_bf) == 1)  //若负载因子变成1则需要传递到上一层
			{
				parent = parent->_pParent;
				cur = cur->_pParent;
			}
			else if (abs(parent->_bf) == 2)   //已经不平衡了不需要再传递了，需要进行旋转处理
			{
				if ((parent->_bf == 2) && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if ((parent->_bf == -2) && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if ((parent->_bf == 2) && cur->_bf == -1)
				{
					
					RotateRL(parent);
				}
				else if ((parent->_bf == -2) && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:
	// 根据AVL树的概念验证pRoot是否为有效的AVL树
	bool _IsAVLTree(Node* pRoot)
	{
		if (pRoot == nullptr)
		{
			return true;
		}
		int leftHT = _Height(pRoot->_pLeft);    //手动计算左右子树高度差并和平衡因子比较
		int rightHT = _Height(pRoot->_pRight);
		int  dif = rightHT - leftHT;
		if (dif != pRoot->_bf)
		{
			cout << "平衡因子异常" << endl;
			return false;
		}
		return abs(dif) < 2 && _IsAVLTree(pRoot->_pLeft) && _IsAVLTree(pRoot->_pRight);
	}
	size_t _Height(Node* pRoot)
	{
		if (pRoot == nullptr)
		{
			return 0;
		}
		return max(_Height(pRoot->_pLeft), _Height(pRoot->_pRight)) + 1;
	}
	// 右单旋
	void RotateR(Node* Parent)   //一共有六组指针需要处理
	{
		Node* subl = Parent->_pLeft;
		Node* sublr = subl->_pRight;

		Parent->_pLeft = sublr;    //sublr和subl之间的两个指针
		if (sublr)
		{
			sublr->_pParent = Parent;
		}
		Node* pparent = Parent->_pParent;

		subl->_pRight = Parent;     //subl和parent之间的两个指针
		Parent->_pParent = subl;
									//处理成为新的parent节点和其上级之间的两个指针
		if (_root == Parent)		//当原节点是根节点的时候特殊处理
		{
			_root = subl;
			subl->_pParent = nullptr;
		}
		else                    //当原parent之上有节点的时候，需要判断原parent是上级的左子树还是右子树。
		{
			if (pparent->_pLeft == Parent)
			{
				pparent->_pLeft = subl;
			}
			else if (pparent->_pRight == Parent)
			{
				pparent -> _pRight = subl;
			}
			subl -> _pParent = pparent;
		}					//修改平衡节点
		subl->_bf = 0;
		Parent->_bf = 0;
	}
	// 左单旋
	void RotateL(Node* Parent)
	{
		Node* subr = Parent->_pRight;
		Node* subrl = subr->_pLeft;

		Parent->_pRight = subrl;
		if (subrl)
		{
			subrl->_pParent = Parent;
		}
		Node* pparent = Parent->_pParent;

		subr->_pLeft = Parent;    
		Parent->_pParent = subr;
		
		if (_root == Parent)		
		{
			_root = subr;
			subr->_pParent = nullptr;
		}
		else                   
		{
			if (pparent->_pLeft == Parent)
			{
				pparent->_pLeft = subr;
			}
			else if (pparent->_pRight == Parent)
			{
				pparent->_pRight = subr;
			}
			subr->_pParent = pparent;
		}					
		subr->_bf = 0;
		Parent->_bf = 0;
	}
	// 右左双旋
	void RotateRL(Node* Parent)
	{
		Node* subr = Parent->_pRight;
		Node* subrl = subr->_pLeft;

		int bf = subrl->_bf;    //需要保存右左子树的平衡因子，因为需要通过这个值来更新平衡因子

		RotateR(Parent->_pRight);   //对右子树右旋再对整棵树左旋
		RotateL(Parent);

		subrl->_bf = 0;  //新的根节点的平衡因子更新为0
						//平衡因子的更新有三种情况
		if (bf == 0)    //右左子树一开始为空
		{
			Parent->_bf = 0;
			subr->_bf = 0;
		}
		else if (bf==1)  //新增节点在右左子树的右侧
		{
			Parent->_bf = -1;
			subr->_bf = 0;
		}
		else if (bf == -1)//新增节点在右左子树的左侧
		{
			Parent->_bf = 0;
			subr->_bf = 1;
		}
		else
		{
			assert(false);
		}

	}
	// 左右双旋
	void RotateLR(Node* Parent)
	{
		Node* subl = Parent->_pLeft ;
		Node* sublr = subl->_pRight;

		int bf = sublr->_bf;

		RotateL(Parent->_pLeft);
		RotateR(Parent);

		sublr->_bf = 0;
		if (bf == 0)
		{
			Parent->_bf = 0;
			subl->_bf = 0;
		}
		else if (bf == 1)
		{
			Parent->_bf = 0;
			subl->_bf = -1;
		}
		else if (bf == -1)
		{
			Parent->_bf = 1;
			subl->_bf = 0;
		}
		else
		{
			assert(false);
		}

	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_pLeft);
		cout << root->_data<<":" << root->_bf << endl;
		_InOrder(root->_pRight);
	}
	
private:
	Node* _root;
};