【C++】图解AVL树

一、概念

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

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

• 它的左右子树都是AVL树
• 左右子树高度之差（简称平衡因子）的绝对值不超过1
  
  这里我们要回顾一下二叉树节点的高度和深度，很多初学者会混淆两个概念。简单来说，高度是从下往上数，深度是从上往下数，二者是相反的表示。
  
  关于根节点的深度究竟是1 还是 0，不同的地方有不一样的标准，这里我们不做探讨。

二、模拟实现

2.1 AVL树节点的定义

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(const pair<K, V>& kv)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)
	{}

	AVLTreeNode<K, V>* _left;   // 该节点的左孩子
	AVLTreeNode<K, V>* _right;  // 该节点的右孩子
	AVLTreeNode<K, V>* _parent; // 该节点的双亲
	pair<K, V> _kv;
	int _bf;                    // 该节点的平衡因子
};

2.2 AVL树的定义

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
		: _root(nullptr)
	{}
	
private:
	Node* _root;
	long long prev = LONG_MIN;
};

2.3 AVL树的插入

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

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

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->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	
	// 按照二叉搜索树的规则将节点插入到AVL树中
	cur = new Node(kv);
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	// 新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子
	while (parent)
	{
		// cur插入后，parent的平衡因子一定需要调整子
		if (parent->_left == cur) // cur插入到parent的左侧，只需给parent的平衡因子-1即可
			parent->_bf--;
		else                      // cur插入到parent的右侧，只需给parent的平衡因子+1即可
			parent->_bf++;
		
		// 此时：parent的平衡因子可能有三种情况：0，±1，±2
		if (parent->_bf == 0)
		{
			// parent的平衡因子为0，说明插入之前parent的平衡因子为±1，此时满足AVL树的性质，插入成功
			break;
		}
		else if (parent->_bf == 1 || parent->_bf == -1)
		{
			// parent的平衡因子为±1，说明插入前parent的平衡因子一定为0，此时以parent为根的树的高度增加，需要继续向上更新
			cur = parent;
			parent = parent->_parent;
		}
		else if (parent->_bf == 2 || parent->_bf == -2)
		{
			// parent的平衡因子为±2，则parent的平衡因子违反平衡树的性质，需要对其进行旋转处理
			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;
}

2.4 AVL树的旋转

  在上述插入的几种情况中，parent的平衡因子变为±2是我们比较难处理的，它违反了平衡树的性质，需要进行旋转。但是不用着急，我们先来简单认识一下四种类型，它们是根据插入节点位置的不同来划分的：

2.4.1 新节点插入较高左子树的左侧—左左：右单旋

  插入前，以60为根的二叉树是平衡的，平衡因子为-1；插入新节点后，60的平衡因子变成了-2，而它的左子树的平衡因子变成了-1，说明60左子树的高度更高，需要将60顺时针旋转才能保持平衡。

  旋转遵循二叉搜索树的原则，30<b<60，将b作为60的左子树，60作为30的右子树，旋转完成后，更新节点的平衡因子即可。
  在旋转过程中，有以下几种情况需要考虑：
1. 30节点的右孩子可能存在，也可能不存在.
2. 60可能是根节点，也可能是子树。如果是根节点，旋转完成后，要更新根节点；如果是子树，可能是某个节点的左子树，也可能是右子树。

void RotateR(Node* parent)
{
	// subL: parent的左孩子
    // subLR: parent左孩子的右孩子，注意：subLR可能不存在
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	
	// 旋转完成之后，30 的右孩子作为 60 的左孩子
	parent->_left = subLR;
	if (subLR)
		subLR->_parent = parent;
	
	// 因为 60 可能是棵子树，因此在更新其双亲前必须先保存 60 的双亲
	Node* grandfather = parent->_parent;
	
	// 60 作为 30 的右孩子
	subL->_right = parent;
	
	// 更新 60 的双亲
	parent->_parent = subL;

	// 如果 60 是根节点，更新根节点
	if (parent == _root)
	{
		_root = subL;
		_root->_parent = nullptr;
	}
	else
	{
		 // 如果 60 是子树，可能是其双亲的左子树，也可能是右子树
		if (grandfather->_left == parent)
		{
			grandfather->_left = subL;
		}
		else
		{
			grandfather->_right = subL;
		}
		
		// 更新30的双亲
		subL->_parent = grandfather;
	}

	// 根据调整后的结构更新部分节点的平衡因子
	parent->_bf = subL->_bf = 0;
}

右单旋后的结果为：

2.4.2 新节点插入较高右子树的右侧—右右：左单旋

  左单旋与右单旋完全相反，我们直接上图：

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

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

	Node* grandfather = parent->_parent;
	subR->_left = parent;
	parent->_parent = subR;

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

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

2.4.3 新节点插入较高左子树的右侧—左右：先左单旋再右单旋

  这种情况对应2.4里的第二幅图——LR型，C是待插入节点或者待插入的子树，我们先来看插入前子树的图片：

看图分析一下：90是A，30是B，60是C，当h等于1时，60就是新插入节点。这里我们分析h>=1的情况，继续上图：

值得注意的是，旋转之前，60的平衡因子可能是-1/0/1三种情况（上图实线和虚线分别代表的是-1和1），所以在旋转之前要对60的平衡因子做记录。

根据二叉搜素树的规则，30<b<60<c<90，让b去作30的右子树，30作为60的左子树；然后再让c去作90的左子树，90作为60的右子树。整个思路就是将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。

void RotateLR(Node* parent)
{
	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 = 1;
	}
	else if (bf == 1)
	{
		subL->_bf = -1;
	}
}

2.4.4 新节点插入较高右子树的左侧—右左：先右单旋再左单旋

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 = 1;
	else if (bf == 1)
		parent->_bf = -1;
}

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

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

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

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

• 当psubL的平衡因子为-1是，执行右单旋
• 当psubL的平衡因子为1时，执行左右双旋

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

2.5 AVL树的验证

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

1. 验证其为二叉搜索树
   如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

bool IsBSTree()
{
	return _IsBSTree(_root);
}

bool _IsBSTree(Node* root)
{
	if (root == nullptr) return true;
	bool left = _IsBSTree(root->_left);
	if (root->_kv.first <= prev)
		return false;
	prev = root->_kv.first;
	bool right = _IsBSTree(root->_right);
	return left && right;
}

prev是我们定义的一个类成员变量，默认大小是LONG_MIN，属于类的实例化对象，在程序中可以看成是一个全局变量，维护中序遍历的最大值。通过比较prev与当前节点的值来验证是否是二叉搜索树。

2. 验证其为平衡树

bool isBalanced()
{
	return _isBalanced(_root);
}

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

bool _isBalanced(Node* root)
{
	return Height(root) >= 0;
}

上面的写法采用的是后序遍历的方式。前序遍历对于同一个节点会多次求它的高度，而后序遍历对每一个节点返回它的高度(非负数)；如果以这个节点为根的子树不是平衡树，返回-1。

三、AVL树的性能

  AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即$lo{g}_2(N)$。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。