AVL树(C++实现)

AVL树

概念

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

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

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

AVL树不一定需要平衡因子来控制高度差，只不过使用平衡因子是比较方便的一种控制方法
平衡因子=右子树高度-左子树高度

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在O(log${}_2$N) ，搜索时间复杂度O(log${}_2$N)

AVLTree的插入

平衡控制：cur新增，只会影响cur的祖先节点的平衡因子

1. 更新平衡因子——新增节点到根节点的祖先路径
2. 出现异常的平衡因子——那么需要旋转处理平衡

更新平衡因子(5种情况)：
①cur== parent->left {parent->bf --}

②cur== parent->right {parent->bf++}

③更新以后，parent->bf == 0，更新结束。此时说明更新前parent->bf 是1或者-1，现在变成成0，说明填上矮的那边，parent所在的子树高度不变

④更新以后，parent->bf = = 1/ -1，继续往上更新。说明更新前parent->bf是0，现在变成1或者-1,我有一边子树变高了，parent所在子树高度变了.

⑤更新以后，parent->bf = = 2 / -2，parent所在子树已经不平衡，需要旋转处理。

代码框架如下：

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 (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}

		else
		{
			return false;
		}
	}

	// 此处走到nullptr，可以插入了
	// 要跟父亲链接起来，我们需要比较一下，链接在左边还是右边
	cur = new Node(kv);
	if (kv.first>parent->_kv.first)
	{
		// 三叉链需要链接起来
		parent->_right = cur;
		cur->_parent = parent;
	}
	else
	{
		parent->_left = cur;
		cur->_parent = parent;
	}

	// 控制平衡
	while (parent)
	{
		if (cur == parent->_left) 
			parent->_bf++;
		else 
			parent->_bf--;


		if (parent->_bf == 0)
		{
			break;
		}
		else if (parent->_bf == 1 || parent->_bf == -1)
		{
			//需要继续往上更新
			//倒着晚上走
			cur = parent;
			parent = parent->_parent;
		}
		else if(parent->_bf == 2 || parent->_bf == -2)
		{
			 //旋转处理
		}
		else 
		{
			//说明插入更新平衡因子之前就有问题了
			assert(false);
		}
	}
	return true;
}

AVLTree的旋转

旋转过程要满足：

• 保持结构任然是搜索树
• 控制平衡因子

根据节点插入位置的不同，AVL树的旋转分为四种：

抽象图：

具象图：

以此类推。。。

右单旋

1. 新节点插入较高左子树的左侧——左左：右单旋
   
   a中插入值，a的高度变化，变为h+1，那么就会引发60的平衡因子变为-2，触发旋转

旋转的动作：
①b变成60的左边
②60变成30的右边

旋转的意义：
①这棵树平衡了
②整棵树高度降低了1

在旋转过程中，有以下几种情况需要考虑：
①30节点的右孩子可能存在，也可能不存在

②60可能是根节点，也可能是子树：
 如果是根节点，旋转完成后，要更新根节点
 如果是子树，可能是某个节点的左子树，也可能是右子树

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

	parent->_left = subLR;
	if (subLR)
		subLR->_parent = parent;
	

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

	if (parent == _root)
	{
		_root = subL;
		_root->_parent = nullptr;
	}
	else
	{
		if (parentParent->_left == parent)
		{
			parentParent->_left = subL;
		}
		else
		{
			parentParent->_right = subL;
		}
		subL->_parent = parentParent;
	}
	parent->_bf = subL->_bf = 0;
}

左单旋

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

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

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

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

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

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

左右双旋

3. 新节点插入较高左子树的右侧——左右：先左单旋再右单旋
   
   当h= =0的场景：
   
   当h= =1的场景：
   
   ①以30节点为轴点，插入后进行左单旋
   ②以90节点为轴点，进行右单旋

//左右双旋
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf; 

	//1、以subL为旋转点进行左单旋
	RotateL(subL);

	//2、以parent为旋转点进行右单旋
	RotateR(parent);

	//3、更新平衡因子
	if (bf == 1)
	{
		subLR->_bf = 0;
		subL->_bf = -1;
		parent->_bf = 0;
	}
	else if (bf == -1)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 1;
	}
	else if (bf == 0)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 0;
	}
	else
	{
		assert(false); //在旋转前树的平衡因子就有问题
	}
}

右左双旋

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

//右左双旋
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;

	//1、以subR为轴进行右单旋
	RotateR(subR);

	//2、以parent为轴进行左单旋
	RotateL(parent);

	//3、更新平衡因子
	if (bf == 1)
	{
		subRL->_bf = 0;
		parent->_bf = -1;
		subR->_bf = 0;
	}
	else if (bf == -1)
	{
		subRL->_bf = 0;
		parent->_bf = 0;
		subR->_bf = 1;
	}
	else if (bf == 0)
	{
		subRL->_bf = 0;
		parent->_bf = 0;
		subR->_bf = 0;
	}
	else
	{
		assert(false); //在旋转前树的平衡因子就有问题
	}
}

AVL树的验证

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

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

void _InOrder(Node* root)
{
	if (root == nullptr)
		return;
	_InOrder(root->_left);
	cout << root->_kv.first << ":" << root->_kv.second << endl;
	_InOrder(root->_right);
}
void InOrder()
{
	_InOrder(_root);
}

2. 第二步：验证其为平衡树
   中序有序只能证明是二叉搜索树，要证明二叉树是AVL树还需验证二叉树的平衡性，在该过程中我们顺便检查每个结点当中平衡因子是否正确即可。

• 每个节点子树高度差的绝对值不超过1(注意节点中没有平衡因子)
• 节点的平衡因子是否正确

int Height(Node* root)
{
	if (root == nullptr)
		return 0;
	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
bool IsBalance()
{
	return _IsBalance(_root);
}

bool _IsBalance(Node* root)
{
	if (root == nullptr)
		return true;

	// 对当前树进行检查
	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);

	if (rightHeight - leftHeight != root->_bf)
	{
		cout << root->_kv.first << "这个节点现在是:" << root->_bf << endl;
		cout << root->_kv.first << "这个节点应该是:" << rightHeight - leftHeight << endl;
		return false;
	}

	// 递归去左右子树计算
	return abs(rightHeight - leftHeight) < 2 && _IsBalance(root->_left) && _IsBalance(root->_right);
}

AVL树的删除

删除不是考察的重点，比插入的细节更加多一点。
因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不过与删除不同的是，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

AVL树的性能

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