C++ : AVL树的旋转图解及简单实现（插入、旋转、检测）

AVL树的旋转图解及简单实现

AVL树是带有平衡条件的查找二叉树。这个平衡条件要容易保持，而且他要保证树的深度为O(logN)
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此为解决上述问题有一种新的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

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

AVL树的插入

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

• 先按照二叉搜索树的方式插入新节点
• 再调整节点的平衡因子

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

	bool Insert(const std::pair<K, V>& kv)
	{
     // 1. 先按照二叉搜索树的规则将节点插入到AVL树中
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_bf = 0;
			return true;
		}
        
 // 按照二叉搜索树的性质找cur在AVL中的插入位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				cur = parent;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				cur = parent;
				cur = cur->_left;
			}
			else
			{
				return false; // 该节点在二叉搜索树中已存在
			}
		}

 // 插入新节点：新节点一定插入在pParent的左侧或者右侧
		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent; // 更新pCur的双亲节点
		}
//********************************************************************************************
 // 2. 新节点插入后，AVL树的平衡性可能会破坏，此时就需要更新平衡因子，并检测是否破坏了AVL树的平衡性
        //更新平衡因子
		while (parent)
		{
         // 更新双亲的平衡因子
			if (cur == parent->_left)
				parent->_bf--;
			else
				parent->_bf++;

			//1.高度不变，更新结束（更新后检测双亲的平衡因子）
			if (parent->_bf == 0)
			{
				break;
			}
			else if (abs(parent->_bf) == 1)
			{
             //插入前双亲的平衡因子是0，插入后双亲的平衡因为为1 或者 -1 ，说明以双亲为根的二叉树的高度增加了一层，因此需要继续向上调整
             
				//2.高度变了，继续更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf) == 2)
			{
             //双亲的平衡因子为正负2，违反了AVL树的平衡性，需要对以pParent为根的树进行旋转处理
				//3.不平衡旋转(旋转的本质是在降高度)
				if (parent->_bf == 2)
				{
					if (cur->_bf == 1)
					{
						RotateL(parent);
					}
					else if (cur->_bf == -1)
					{
						RotateRL(parent);
					}
				}
				else if (parent->_bf == -2)
				{
					if (cur->_bf == -1)
					{
						RotateR(parent);
					}
					else if (cur->_bf == 1)
					{
						RotateLR(parent);
					}
				}

				break;
			} 
		}
		return true;
	}

AVL树的旋转

在每一次插入数值之后，树的平衡性都可能被破坏，这时可以通过旋转矫正平衡。旋转可以降低高度，通过降低整棵树的高度维持平衡。哪边的树高，就把那边的树向上旋转。达到降低高度的目的：

• 常说的左旋和右旋都是以子树为原点的：如b是a的子树，则围绕b进行旋转
• 如果b是a的左子树，则围绕b将a向右旋转，类似于a掉下来，成为b的右子树
• 如果b是a的右子树，则围绕b将a向左旋转，类似于a掉下来，成为b的左子树

插入节点时共分为四种情况，每种情况对应的旋转方法也是不同的。如对于被破坏平衡的节点 a 来说｡◕ᴗ◕｡：

插入方式	描述	旋转方式
LL	在a的左子树根节点的左子树上插入节点而破坏平衡	右旋转
RR	在a的右子树根节点的右子树上插入节点而破坏平衡	左旋转
LR	在a的左子树根节点的右子树上插入节点而破坏平衡	先左旋后右旋
RL	在a的右子树根节点的左子树上插入节点而破坏平衡	先右旋后左旋

插入新节点的时候，如果新节点大，往右边插，如果新节点小，往左边插

左单旋

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

		parent->_right = subRL;
		if(subRL)   //判断subRL是否为空
			subRL->_parent = parent;

		subR->_left = parent;
		Node* ppnode = parent->_parent;  ///先保存一下原来的parent
		parent->_parent = subR;

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

		subR->_bf = parent->_bf = 0;
	}

右单旋

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

		parent->_left = subLR;
		if (subLR)      //subL与parent不可能为空，其他节点可能为空
			subLR->_parent = parent;

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

		if (parent = _root)
		{
			_root = subL;
		}
		else
		{
			if (ppnode->_left = parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
		}

		subL->_parent = ppnode;
	}

左右双旋

//左右双璇 —— 根据subR平衡因子更新之后考虑旋转
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;  //平衡因子

		subLR->_bf = 0;   //一定是
		if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 0)
		{
			subL->_bf = parent->_bf = 0;
		}
	}

右左双旋

//右左双璇
	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;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = subR->_bf = 0;
		}
	}

AVL树的验证

AVL树的验证分两步：

• 先验证为二叉搜索树： 如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
• 再验证为平衡树： 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子）、 节点的平衡因子是否计算正确（ 通过节点的子树高度差来与当前节点的平衡因子比较）

void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}

	void _Inorder(Node* root)    //中序
	{
		if (root == nullptr)
			return;

		_Inorder(root->_left);
		cout << root->_kv.first << " ";
		_Inorder(root->_right);
	}

	//判平衡
	bool IsBalance()
	{
		return _IsBalance(_root);
	}

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

      // 计算root左右子树的高度
		int letfHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		//分制 : 返回左右子树中较高的子树高度+1
		return letfHeight > rightHeight ? letfHeight + 1 : rightHeight + 1;
	}

	bool _IsBalance(Node* root)
	{
       // 空树也是AVL树
		if (root == nullptr)
			return true;
            
      // 计算root节点的平衡因子：即root左右子树的高度差
		int letfHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
       int diff = rightHeight - leftHeight;

        // 如果计算出的平衡因子与root的平衡因子不相等，或者root平衡因子的绝对值超过1，则一定不是AVL树
		////检查异常时
		if (diff != root->_bf)
		{
			cout << "平衡因子异常" << endl;
			return false;
		}

       // root的左和右如果都是AVL树，则该树一定是AVL树
		return abs(rightHeight - letfHeight) < 2   //仅判断了当前树
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

private:
	Node* _root;
};

void TestAVLTree()
{
	AVLTree<int, int> t;
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	for (auto e : a)
	{
		t.Insert(std::make_pair(e, e));
	}

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