【C++】详解AVL树的旋转及其插入操作

一AVL树的概念

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

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

• 它的左右子树都是AVL树
• 左右子树高度之差（简称平衡因子）的绝对值不超过1（-1、0、1）
• 如果一颗二叉搜索树是高度平衡的，它就是AVL树，如果他有N个节点，其高度可保持在$O(lo{g}_{2}n)$，其搜索时间复杂度也是$O(lo{g}_{2}n)$
  

二、AVL树的实现

1、AVL树的节点的定义

AVL树节点的定义，如下：

template<class K,class V>
class AVLTreeNode
{
	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)
	{}
};

2、AVL树的节点的插入

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

1. 按照二叉搜索树的方式插入新节点
2. 调整节点的平衡因子

那么要如何调整节点的平衡因子呢？
新节点插入后，其 parent 的平衡因子一定需要调整，在插入之前，parent 的平衡因子有三种情况：-1、0、1，分以下两种情况：

1. 如果新节点插入到 parent 的左侧，只需要给 parent 的平衡因子-1即可
2. 如果新节点插入到 parent 的右侧，只需要给 parent 的平衡因子+1即可

此时，parent 的平衡因子可能有三种情况：0、±1、±2

1. 如果 parent 的平衡因子为0，则说明插入之前parent 的平衡因子为±1，插入后被调整成0，此时满足AVL树的性质，插入成功。
2. 如果 parent 的平衡因子为±1，则说明插入之前parent 的平衡因子为0，插入后被调整成±1，此时以 parent 为根的树的高度增加，需要继续向上更新。
3. 如果 parent 的平衡因子为±2，则parent 的平衡因子违反了平衡树的性质，需要对其进行旋转处理。

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		return true;//插入成功
	}
	Node* parent = nullptr;
	Node* cur = _root;
	//按照二叉搜索树的规则将节点插入到AVL树中
	while (cur)
	{
		if (cur->_kv.first < kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;//已经有了这个值，就不再向下走
		}
	}
	cur = new Node(kv);
	if (parent->_kv.first > kv.first)
	{
		parent->_lefe = cur;
	}
	else
	{
		parent->_right = cur;
	}

	//链接父指针，根不用连接父亲，其他节点都有父亲
	//父亲连接后，子要反向过来连接父亲
	cur->_parent = parent;

	//上面是搜索树的功能，接下来就是AVL树的要求
	//更新平衡因子
	while (parent)
	{
		//更新双亲的平衡因子
		if (cur == parent->_right)
		{
			parent->_bf++;
		}
		else
		{
			parent->_bf--;
		}
		
		//更新后检测双亲的平衡因子
		if (parent->_bf == 1 || parent->_bf == -1)
		{
			//继续更新
			parent = parent->_parent;
			cur = cur->_parent;
		}
		else if (parent->_bf == 0)
		{
			break;
		}
		else if (parent->_bf == 2 || parent->_bf == -2)
		{
			//需要旋转处理
		}
		else
		{
			assert(false);//能帮助我们及时发现问题,插入之前就发现问题
		}
	}
	return true;
}

3、AVL树的旋转

如果在一颗原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之能够平衡，根据节点的插入位置不同，AVL树的旋转分为四种：

1. 新节点插入较高左子树的左侧左左：右单旋
   
   上图在插入之前，AVL树是平衡的，新节点插入到30的左子树（注意：此处不是左孩子）中，30左子树增加了一层，导致以60为根的二叉树不平衡，要让60平衡，只能将60左子树的高度减少一层，右子树增加一层，即将左子树往上提，这要60转下来，因为60比30大，只能将其放在30的右子树，而如果30有右子树，右子树根的值一定大于30，小于60，只能将其放在60的左子树，旋转完成后，更新节点的平衡因子即可。在旋转过程中，有以下几种情况需要考虑：
   1、30节点的右孩子可能存在，也可能不存在
   2、60节点可能是根节点，也开始是子树，如果是根节点，旋转完成后，要更新根节点，如果是子树，可能是某个节点的左子树，也可能是右子树
   代码实现：

void RotateR(Node* parent)
{
	//subL：parent 的左孩子
	//subLR：parent 的左孩子的右孩子
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	
	//30的右孩子作为双亲的左孩子
	parent->_left = subLR;
	//如果30的左孩子的右孩子存在，更新新双亲
	if (subLR)
		subLR->_parent = parent;
	
	// 因为60可能是棵子树，因此在更新其双亲前必须先保存60的双亲
	Node* ppnode = parent->_parent;
	// 60变成30的右边
	subL->_right = parent;
	// 更新60的双亲
	parent->_parent = subL;
	
	// 如果60是根节点，根新指向根节点的指针
	if (parent == _root)
	{
		_root = subL;
		_root->_parent = nullptr;
	}
	else
	{
		// 如果60是子树，可能是其双亲的左子树，也可能是右子树
		if (ppnode->_left == parent)
		{
			ppnode->_left = subL;
		}
		else
		{
			ppnode->_right = subL;
		}
		subL->_parent = ppnode;
	}
	// 根据调整后的结构更新部分节点的平衡因子
	subL->_bf = parent->_bf = 0;
}

2. 新节点插入较高右子树的右侧–右右：左单旋
   
   代码实现：

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

	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;

	Node* ppnode = parent->_parent;

	subR->_left = parent;
	parent->_parent = subR;

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

		subR->_parent = ppnode;
	}

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

3. 新节点插入较高左子树的右侧–左右：先左单旋再右单旋
   
   parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL
       当subL的平衡因子为-1是，执行右单旋
       当subL的平衡因子为1时，执行左右双旋
   旋转完成后，原parent为根的子树个高度降低，已经平衡，不需要再向上更新。
   将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。
   代码实现：

void RotateLR(Node* parent)
{
	// 旋转之前，60的平衡因子可能是-1、0、1，旋转完成之后，根据情况对其他节点的平衡因子进行调整
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	// 旋转之前，保存subLR的平衡因子，旋转完成之后，需要根据该平衡因子来调整其他节点的平衡因子
	int bf = subLR->_bf;

	// 先对30进行左单旋
	RotateL(parent->_left);
	// 再对90进行右单旋
	RotateR(parent);

	if (bf == 1)
	{
		parent->_bf = 0;
		subLR->_bf = 0;
		subL->_bf = -1;
	}
	else if (bf == -1)
	{
		parent->_bf = 1;
		subLR->_bf = 0;
		subL->_bf = 0;
	}
	else if (bf == 0)
	{
		parent->_bf = 0;
		subLR->_bf = 0;
		subL->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

4. 新节点插入较高右子树的左侧–右左：先右单旋再左单旋
   
   parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR
       当subR的平衡因子为1时，执行左单旋
       当subR的平衡因子为-1时，执行右左双旋
   代码实现：

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

	RotateR(parent->_right);
	RotateL(parent);

	if (bf == 1)
	{
		subR->_bf = 0;
		parent->_bf = -1;
		subRL->_bf = 0;
	}
	else if (bf == -1)
	{
		subR->_bf = 1;
		parent->_bf = 0;
		subRL->_bf = 0;
	}
	else if (bf == 0)
	{
		subR->_bf = 0;
		parent->_bf = 0;
		subRL->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

4、AVL树的验证

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

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

int _Height(Node* root)
{
	if (root == NULL)
		return 0;

	int leftH = _Height(root->_left);
	int rightH = _Height(root->_right);

	return leftH > rightH ? leftH + 1 : rightH + 1;
}

bool _IsBalance(Node* root)
{
	// 空树也是AVL树
	if (root == NULL)
	{
		return true;
	}

	// 计算root节点的平衡因子：即root左右子树的高度差
	int leftH = _Height(root->_left);
	int rightH = _Height(root->_right);

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

	// root的左和右如果都是AVL树，则该树一定是AVL树
	return abs(leftH - rightH) < 2
		&& _IsBalance(root->_left)
		&& _IsBalance(root->_right);
}