C++AVL树 - 技术栈

文章目录

一、关联式容器的底层结构
二、AVL树
- [2.1 AVL树的概念](#2.1 AVL树的概念)
- [2.2 AVL树的旋转](#2.2 AVL树的旋转)
- - [2.2.1 左单旋](#2.2.1 左单旋)
  - [2.2.2 右单旋](#2.2.2 右单旋)
  - [2.2.3 先右单旋再左单旋(双旋)](#2.2.3 先右单旋再左单旋(双旋))
  - [2.2.4 先左单旋再右单旋(双旋)](#2.2.4 先左单旋再右单旋(双旋))
- [2.3 AVL树节点的定义](#2.3 AVL树节点的定义)
- [2.4 AVL树的插入](#2.4 AVL树的插入)
- [2.5 AVL树的验证](#2.5 AVL树的验证)
- [2.6 AVL树的删除(了解)](#2.6 AVL树的删除(了解))
[三、 AVL树的性能](#三、 AVL树的性能)

一、关联式容器的底层结构

🍇上一篇文章对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点就是: 其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素是有序或者接近有序，那二叉搜索树就会退化成单支树，时间复杂度会退化成O(N) ，因此map、set等关联式容器的底层结构对二叉树进行了平衡处理，即采用平衡树来实现。

二、AVL树

2.1 AVL树的概念

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

💡一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
(1) 它的左右子树都是AVL树
(2) 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

图中每个节点旁的数字其实就是其左右子树的高度差，这里规定是右树的高度减左树的高度。

如果一棵二叉搜索树是高度平衡的(严格平衡)，它就是AVL树。如果它有n个结点，其高度可保持在 O ( l o g 2 n ) O(log_2n) O(log2n)，搜索时间复杂度 O ( l o g 2 n O(log_2 n O(log2n)。

2.2 AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构使之平衡化。注意：新增节点只会影响自己的祖先，并不会影响旁枝。

在插入新节点后，平衡因子bf要怎样更新呢？
①若新增节点在左子树，则父亲bf- -
②若新增节点在右子树，父亲bf++
🍑更新后：🍑
1、若父亲bf==0，则父亲所在子树的高度不变，不用再继续往上更新，即插入结束了。
(ps: 在插入节点前，若父亲bf==1 或 -1，则他是一边高，一边低，新插入的节点正好填上了低的那边)
2、若父亲bf==1 或 -1，则父亲所在的子树高度变了，必须继续往上(祖先路径)更新。
(ps: 在插入节点前，若父亲bf==0，则两边一样高，是因为插入导致了高度变化，需要调整处理)
3、若父亲bf==2 或 -2，则父亲所在的子树违反规则(异常)。

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

2.2.1 左单旋

如果新插入的节点在右子树的右侧(即在c上插入)------右右: 左单旋

🍉下图的长方形是在抽象的表达高度为h的子树；h的值不同，就有不同的情况。不过只要是在右树的右侧(即在c上)插入节点的情况，只要平衡因子出现绝对值大于1的情况，都可以概括为用左单旋的方法进行AVL树平衡。

我们可以列举高度为h的子树的一些简单情况：

列举到h等于2的情况就有36种情况，那h大于2的情况就更多了。只要是在右子树的右侧进行插入，导致平衡因子在往上更新的过程中出现绝对值大于1情况，都是概括为用左单旋的方法进行平衡搜索二叉树。算法实现如下：

cpp 复制代码

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

	parent->_right = subRL;
	subR->_left = parent;

	Node* parentParent = parent->_parent;

	parent->_parent = subR;
	if (subRL != nullptr)
		subRL->_parent = parent;

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

2.2.2 右单旋

如果新插入的节点在左子树的左侧(即在a上插入)------左左: 右单旋

🍇下图的长方形是在抽象的表达(概括各种情况)高度为h的子树；h的具体情况分析与上面的左单旋是类似的(对称的)，这里不再画图说明。

只要是在左树的左侧(即在a上)插入节点，导致祖先的平衡因子出现绝对值大于1的情况，都可以概括为用右单旋的方法进行二叉树平衡。算法实现如下：

cpp 复制代码

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

	parent->_left = subLR;
	subL->_right = parent;

	Node* parentParent = parent->_parent;

	parent->_parent = subL;
	if (subLR != nullptr)
		subLR->_parent = parent;

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

2.2.3 先右单旋再左单旋(双旋)

我们先来看如下这种情况：如果是在b上插入一个新节点，则进行左单旋以后发现并不能平衡二叉搜索树。

即：如果在右子树的左侧插入新节点，导致平衡因子的绝对值大于1，则单纯的左单旋，并不能平衡二叉树，需要通过双旋才能实现平衡。

我们将上图左边的AVL树中的60节点改为90，再把90的左子树再具体延伸一下，让60变为90的左子树，则原AVL树就变成了如下的形式：

如上图左边的二叉树，在b的位置上插入节点就相当于是在右边二叉树的b或c上插入；因为单纯的左单旋不能平衡二叉搜索树，那就要进行双旋才能平衡二叉树：

如果新插入的节点在右子树的左侧(即在b或c上)------右左：先右单旋再左单旋

🐟下图的长方形是对各种子树情况的一种高度抽象概括，即: 先对90进行右单旋，然后再对30进行左单旋，旋转完成后再考虑平衡因子的更新。

通过双旋即可让二叉搜索树达到平衡，我们通过几个简单的情况进行讲解分析：

算法实现如下：

cpp 复制代码

void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	//提前记录下parent右子树的左孩子节点的平衡因子
	int bf = subRL->_bf;

	RotateR(subR);
	RotateL(parent);

	if (bf == 0)
	{
		//subRL自己就是新增节点
		parent->_bf = subR->_bf = subRL->_bf = 0;
	}
	else if (bf == -1)
	{
		//subRL的左子树上新增了节点
		parent->_bf = subRL->_bf = 0;
		subR->_bf = 1;
	}
	else if (bf == 1)
	{
		//subRL的右子树上新增了节点
		subR->_bf = subRL->_bf = 0;
		parent->_bf = -1;
	}
	else
	{
		assert(false);
	}
}

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

parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR:
▲当subR的平衡因子为1时，执行左单旋
▲当subR的平衡因子为-1时，执行右左双旋
parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL
▲当subL的平衡因子为-1是，执行右单旋
▲当subL的平衡因子为1时，执行左右双旋

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

2.2.4 先左单旋再右单旋(双旋)

如果新插入的节点在左子树的右侧(即在b或c上)------左右：先左单旋再右单旋

🍊下图的长方形是对各种子树情况的一种抽象概括，即: 先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。

不管h是多少！只要符合上面的形式，都是采用先左单旋再右单旋的方法进行平衡二叉搜索树。具体情况分析可以参考上面的右左双旋的例子(对称的)。算法实现如下：

cpp 复制代码

void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	//提前记录下parent左子树的右孩子节点的平衡因子
	int bf = subLR->_bf;

	RotateL(subL);
	RotateR(parent);

	if (bf == 0)
	{
		//subLR自己就是新增节点
		parent->_bf = subL->_bf = subLR->_bf = 0;
	}
	else if (bf == -1)
	{
		//subLR的左子树上新增了节点
		subL->_bf = subLR->_bf = 0;
		parent->_bf = 1;
	}
	else if (bf == 1)
	{
		//subLR的右子树上新增了节点
		parent->_bf = subLR->_bf = 0;
		subL->_bf = -1;
	}
	else
	{
		assert(false);
	}
}

注意：左右双旋(或右左双旋)在旋转完成后，要更新平衡因子；那如何知道旋转后的平衡因子要如何更新呢？其实有一个节点的平衡因子可以帮助我们知道新增节点的情况：那就是subLR(或subRL)的平衡因子，因为左右双旋的情况概括起来无非就是以下三种：

所以上面的代码中条件分支语句有三个判断(还有一个分支是用来判平衡因子异常的)，就是通过记录旋转前subLR的平衡因子来进行旋转后parent、subL、subLR平衡因子的更新的！右左双旋跟这里是类似的(对称的)。

🔥思考 🔥：
如果要旋转的就是整棵二叉搜索树，则旋转以后这棵树就变成了一个高度平衡的AVL树(根节点的左右子树高度之差的绝对值小于等于1)；如果旋转的部分是整棵树的一棵子树(即局部的子树)时，则旋转平衡了该子树部分后，还要继续往上更新该子树祖先的平衡因子吗？答案是不需要了！因为旋转本质上也降低了高度：

2.3 AVL树节点的定义

这里开始引入学习三叉链，即每个节点除了有左右孩子指针外，还有父指针。这样能方便我们通过父指针去调节父节点的平衡因子。

cpp 复制代码

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left; //该节点的左孩子
	AVLTreeNode<K, V>* _right; //该节点的右孩子
	AVLTreeNode<K, V>* _parent; //该节点的父节点
	pair<K, V> _kv;
	int _bf; //balance factor(平衡因子)

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

每插入一个新节点后，该新节点的平衡因子为0(因为一开始新节点并没有左右孩子)。

2.4 AVL树的插入

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

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

cpp 复制代码

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

	Node* parent = nullptr;
	Node* cur = _root;
	while (cur != nullptr)
	{
	    //先找到要插入的位置
		if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	
	//申请新节点并链接起来
	cur = new Node(kv);
	if (kv.first < parent->_kv.first)
	{
		parent->_left = cur;
		cur->_parent = parent;
	}
	else
	{
		parent->_right = cur;
		cur->_parent = parent;
	}
    
    //更新平衡因子，并根据平衡因子的值决定是否要调整(旋转)子树
	while (parent != nullptr)
	{
		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)
		{
			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);
			}

			//1.旋转让这棵树(或子树)平衡了
			/*
			2.旋转降低了这棵树的高度，恢复到跟插入前一样的高度
			所以对上一层没有影响，不用再继续往上更新平衡因子了
			*/
			break;
		}
		else
		{
			assert(false);
		}
	}

	return true;
}

2.5 AVL树的验证

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

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

cpp 复制代码

//检查是否是AVL树(是否是平衡二叉搜索树)
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 << ":" << "平衡因子异常" << endl;
		return false;
	}

	return abs(leftHeight - rightHeight) < 2 &&
		_IsBalance(root->_left) && _IsBalance(root->_right);
}

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;
}

2.6 AVL树的删除(了解)

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不过与二叉搜索树删除稍有不同的是，AVL树中删除节点后平衡因子要更新，最差情况下一直要调整到根节点的位置(更新过程中还要根据平衡因子的值看是否还要旋转)。所以删除的逻辑是比较麻烦的，大家了解即可。

具体实现大家可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

三、 AVL树的性能

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

由于AVL树是严格平衡 的：即对于树中任意一个节点来说：它的左右子树高度差的绝对值是不超过1的。也就是在插入节点时，为维护其性能可能要经历很多次的旋转(代价高)，那这种数据结构的性能就比较差了。所以又出现了一种新的数据结构：红黑树 ，它不要求树的结构是严格平衡的，而是近似平衡 (弱平衡): 最长路径不超过最短路径的二倍。后面就会学习到。

代码仓库：AVLTree