C++:模拟实现AVL树

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

1. 它的左右子树都输AVL树
2. 左右子树的高度之差（简称平衡因子）的绝对值不超过1（-1/0/1）

平衡因子 = 右减左
如果一颗二叉搜索树是高度平衡的，它就是AVL树，如果它有n个节点，其高度可以保持在O(logN)
搜索时间复杂度O(log2n)

二、AVL树的模拟实现
1 AVL树的节点定义

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;

	std::pair<K, V> _kv;
	int _bf;
};

2 AVL树的插入
2.1 按照二叉搜索树的方式插入新的节点

bool Insert(const std::pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_bf = 0;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur != nullptr)
		{
			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;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		//更新后，可能破坏了AVL树的平衡性，所以需要更新平衡因子，并检测是否破坏了AVL树的平衡性。

2.2 更新平衡因子

2.3 AVL树旋转

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

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

		上图在插入前，AVL树是平衡的，新节点插入到30的左子树(这不是左孩子)中，30左子树增加了一层，导致以60为根的二叉树不平衡，要让60平衡，只能把60的左子树高度减少一层，右子树增加一层。
		也就是把左子树往上提，这样60转下来，因为60比30大，只能将其放在30的右子树，而如果30有右子树，右子树根的值一定大于30，小于60，只能将其放在60的左子树，旋转完成后，更新节点的平衡因子就好了。
在旋转时，有以下几种情况要考虑：
	1、30节点的右孩子可能存在，也可能不存在
	2、60可能是根节点，也可能是子树
		如果是根节点，旋转完成后，要更新根节点
		如果是子树，可能是某个节点的左子树，也可能是右子树

void RotateRight(Node* parent)//parent->_bf == -2 && cur->_bf == -1
	{
		Node* cur = parent->_left;
		Node* right = cur->_right;//把cur的right给parent的左
		if (right != nullptr)
		{
			parent->_left = right;
			right->_parent = parent;
		}
		Node* node = parent->_parent;//先记录一下parent原来的父节点
		cur->_right = parent;//把parent给cur的右
		parent->_parent = cur;//更新parent的父节点

		//把cur与parent之前的父节点链接
		if (parent == _root)//如果之前parent就是根，直接把根变成cur
		{
			_root = cur;
			_root->_parent = nullptr;
		}
		else//如果之前的parent有父节点，那么就要链接
		{
			if (node->_left == parent)
				node->_left = cur;
			else
				node->_right = cur;
			cur->_parent = node;
			//node->_bf = 0;
			//cur->_bf = 0;
		}
	}

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

void RotateLeft(Node* parent)//parent->_bf == 2 && parent->_bf ==1
	{
		Node* cur = parent->_right;
		Node* left = cur->_left;//把cur的left给parent的右

		if (left != nullptr)
		{
			parent->_right = left;
			left->_parent = parent;
		}
		Node* node = parent->_parent;//先记录一下parent原来的父节点
		cur->_left = parent;//把parent给cur的左
		parent->_parent = cur;//更新parent的父节点
		//把cur与parent之前的父节点链接
		if (parent == _root)//如果parent就是之前的根，直接把根变成cur，并且把cur的_parent置空
		{
			_root = cur;
			_root->_parent = nullptr;
		}
		else//如果之前的parent右父节点，就要链接
		{
			if (node->_left == parent)
				node->_left = cur;
			else
				node->_right = cur;
			cur->_parent = node;
		}
	}

2.3.3 新节点插入较高左子树的右侧–左右：先左单旋在右单旋

把双旋变成单旋在旋转，即:先对30进行左单旋，然后在对90进行右单旋，旋转完成后在考虑平衡因子的更新

void RotateLR(Node* parent)//parent->_bf == -2 && cur->_bf == 1
	{
		RotateLeft(parent->_left);
		RotateRight(parent);
	}

2.3.4 新节点插入较高右子树的左侧–右左：先右单旋在左单旋

void RoataeRL(Node* parent)//parent->_bf == 2 && cur->_bf == -1
	{
		RotateRight(parent->_right);
		RotateLeft(parent);
	}

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

• 每个节点的子树高度差的绝对值不超过1
• 节点的平衡因子是否计算正确

int _Height(Node* pRoot)
	 {
		 if (nullptr == pRoot)
		 return 0;
		 // 计算pRoot左右子树的高度
		 int leftHeight = _Height(pRoot->_pLeft);
		 int rightHeight = _Height(pRoot->_pRight);
		 // 返回左右子树中较高的子树高度+1
		 return (leftHeight > rightHeight) ? (leftHeight + 1) : (rightHeight + 1);
	 }

	int Height()
	{
		_Height(_root);
	}

	bool _IsBalanceTree(Node* pRoot)
	{
		 // 空树也是AVL树
		 if (nullptr == pRoot)
		 return true;
		 // 计算pRoot节点的平衡因子：即pRoot左右子树的高度差
		 int leftHeight = _Height(pRoot->_pLeft);
		 int rightHeight = _Height(pRoot->_pRight);
		 int diff = rightHeight - leftHeight;
		 // 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
		 // pRoot平衡因子的绝对值超过1，则一定不是AVL树
		 if (diff != pRoot->_bf || (diff > 1 || diff < -1))
		 return false;
		 // pRoot的左和右如果都是AVL树，则该树一定是AVL树
		 return _IsBalanceTree(pRoot->_pLeft) && _IsBalanceTree(pRoot->_pRight);
	}
	
	bool IsBalanceTree(Node* root)
	{
		 _IsBalanceTree(_root);
	}

验证用例：{16, 3, 7, 11, 9, 26, 18, 14, 15}

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