数据结构进阶——AVL树

已于 2024-06-10 21:36:39 修改
阅读量1.1k 收藏 24
点赞数 19
分类专栏： 数据结构 文章标签： 数据结构 c++
于 2024-06-09 23:23:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73870552/article/details/139427338
版权

数据结构进阶——AVL树

0. 前言

学习本章，需要大家先掌握搜索二叉树，了解键值对pair。

1. AVL树的概念

1. 搜索二叉树的弊端：

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

2. AVL树的性质：

在这里插入图片描述

  • 左右子树都是AVL树；
  • 左右子树高度之差（简称平衡因子）的绝对值不超过1；
  • 空树是AVL树。

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

2. AVL树节点，和树的定义

1. 节点：

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)
	{}
};
  • 该节点的定义是一个三叉链，_left和_right分别指向左右子树，_parent指向父节点；
  • 节点中存储的有效数据为pair<K, V>，类型的键值对；
  • _bf为平衡因子，在此我们定义为右树高度减去左树高度，用来控制左右子树的高度（注意：平衡因子只是其中一种控制平衡的手段，并不是唯一的）；
  • 定义了一个模版构造函数，以便后续使用。

2. 树：

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	...

private:
	Node* _root = nullptr;
	size_t _size = 0;
};
  • _size记录树中一共有多少数据（多少节点）。

3. AVL树的插入

1. 思路：

  • AVL树就是在搜索二叉树的基础上引入了平衡因子，因此AVL树也可以看成是搜索二叉树。那么AVL树的插入过程可以分为两步：
    • 按照二叉搜索树的方式插入新节点；
    • 调整节点的平衡因子。
  • 调整平衡因子的过程，又可以细分为两部分：
    • 平衡因子的更新；
    • 节点的调整（旋转）+ 平衡因子的更新。

1. 模拟插入过程（红色节点表示新插入节点）：

在这里插入图片描述

  • 插入新节点后，第一件事，是更新该新节点的父亲的平衡因子：
    • 新增节点在左，父亲bf--；
    • 新增节点在右，父亲bf++。
  • 更新完该新节点的父亲后，还要判断是否需要往上更新（新增节点可能会影响祖先，但是一定不会影响兄弟）：
    • 更新后，父亲bf == 0，父亲所在的子树高度不变，不用再继续往上更新了，插入结束。 （ps：在插入节点前，父亲bf == 1 or -1，子树一边高，一边低，新插入节点填补低的那边）
    • 更新后，父亲bf == 1 or -1，父亲所在的子树高度变了，需要继续往上更新。（ps：在插入节点前，父亲bf == 0，两边一样高，插入新节点导致高度变化）
    • 更新后，父亲bf == 2 or -2，父亲所在的子树不平衡，需要旋转调整。
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		// 插入，类比搜索二叉树插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_size++;
			return true;
		}

		// 通过parent向上找父节点
		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;
			}
		}

		cur = new Node(kv);
		if (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		_size++;
		
		// 调整，AVL树的核心部分

		while (parent)
		{
			// 平衡因子的更新
			if (cur == parent->_left)
			{
				// 插入在左节点，_bf--
				parent->_bf--;
			}
			else
			{
				// 插入在右节点，_bf++
				parent->_bf++;
			}
			
			// 判断是否要继续向上更新，和是否旋转调整
			if (parent->_bf == 0)
			{
				// 更新后 _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
			{
				// 平衡因子绝对值大于2，直接报错
				assert(false);
			}
		}

		return true;
	}

	...

private:
	Node* _root = nullptr;
	size_t _size = 0;
};

4. AVL树的旋转

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

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

  • 先考虑一种最简单的场景（场景1）：

    • 直接将8节点链接到9节点的左边即可。
      在这里插入图片描述

  • 再看一种更复杂的场景（场景2）：

    • 需要将13节点链接到9节点的右子树，将9节点链接到15节点的左子树。
      在这里插入图片描述

  • 还有更加复杂的情况，但是我们可以对所有的情况进行一个归类，画出抽象图：

    • a，b，c 都是高度为h的AVL平衡树；
    • 只需要将b框中的节点（subRL），链接到30节点（parent）的右子树（将60节点的左子树链接到30节点的右边）；再将30节点（parent），连接到60节点（subR）的左子树即可。（别忘了是三叉链，要同步更新父节点）
    • 旋转完后别忘了更新平衡因子，左单旋后，parent和subR节点的_bf都为0，其余节点的平衡因子均不会受到印象。
    • h = 0时，就对应场景1的情况；h = 1时，就对应场景2的情况。

在这里插入图片描述

  • 代码实现：
    • 注意，在更新subRL节点的父节点时，需要先判断subRL是否为空（h=0的情况），如果为空，就不要访问subRL了；
    • 还需要记录parent的父节点，方便旋转后将subR链接给parent->_parent，和整棵树链接起来；
    • 当parent就是根节点时，需要特殊处理，要更新根节点为subR。
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	// 左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		// 更新左右节点
		parent->_right = subRL;
		subR->_left = parent;

		// 提前记录parent的parent
		Node* parentParent = parent->_parent;

		// 更新_parent
		parent->_parent = subR;
		if (subRL)	// 判断为不为空，subRL是唯一一个可能为空的节点
		{
			subRL->_parent = parent;
		}

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

		// 更新平衡因子
		parent->_bf = subR->_bf = 0;
	}

	...

private:
	Node* _root = nullptr;
	size_t _size = 0;
};

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

  • 这里不带着大家一步一步分析了，直接上抽象图：
    • a，b，c 均为高度为h的AVL平衡树；
    • 只需要将subLR给parent的左，再将parent给subL的右即可；
    • 随后更新平衡因子，subL和parent的_bf都更新为0。

在这里插入图片描述

  • 类比左单旋，直接上代码：
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	// 右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		// 更新左右节点
		subL->_right = parent;
		parent->_left = subLR;

		Node* parentParent = parent->_parent;

		// 更新_parent
		parent->_parent = subL;
		if (subLR)
		{
			subLR->_parent = parent;
		}

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

	...

private:
	Node* _root = nullptr;
	size_t _size = 0;
};

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

  • 注意：该抽象图只是左右双旋中的一种情况，为在60的左子树新增。还有两种情况没有画出来，分别是（1）60作为新增节点的情况；（2）在60的右子树新增的情况。不同的情况，旋转后得到的平衡因子有差别。
    在这里插入图片描述

  • h = 0 的情况：60就是新插入节点。此时b，c子树不存在，注意是不存在，连空都不是。此时，parent，subL，subLR的平衡因子均为0。
    在这里插入图片描述

  • h = 1的情况（该情况又分两种）：

    • 在60的左子树新增：注意此时subL和subLR的平衡因子均为0，只有parent的平衡因子为1，和h = 0的情况不一样。
      在这里插入图片描述
    • 在60的右子树新增：这种情况最后的到的子树，和上图只有一处区别，就是b变成了NULL，c变成了50，故此时subL的平衡因子为-1，parent，subLR的平衡因子均为0。和在60左子树新增的情况，平衡因子又不一样。

  • 代码实现：

    • 我们可以根据新节点插入后，subLR的平衡因子来确定到底是上述哪种情况。（1）subLR->_bf == 0，说明subLR就是新增节点；（2）subLR->_bf == -1，说明是在subLR的左子树新增；（3）subLR->_bf == 1，说明是在subLR的右子树新增。
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	// 左右双旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		int bf = subLR->_bf;	// 提前记录subLR的平衡因子，避免单旋操作后，值丢失

		// 先左旋再右旋
		RotateL(parent->_left);
		RotateR(parent);

		// 更新平衡因子

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

	...

private:
	Node* _root = nullptr;
	size_t _size = 0;
};

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

  • 注意：该抽象图只是右左双旋中的一种情况，为在60的右子树新增。还有两种情况没有表示出来，分别是（1）60就是新增节点；（2）在60的左子树新增。
    在这里插入图片描述
  • 类比左右双旋，上代码：
    • 还是要注意，可以通过subRL的平衡因子区分上述三种情况。（1）subRL->_bf == 0，说明subRL就是新增节点；（2） subRL->_bf == 1，说明是在subRL的右子树新增，parent->_bf == -1；（3）subRL->_bf == -1，说明是在subRL的左子树新增，subR->_bf == 1。
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	// 右左双旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		int bf = subRL->_bf;	// 提前记录subRL的平衡因子，避免单旋操作后，值丢失

		// 先右旋再左旋
		RotateR(parent->_right);
		RotateL(parent);

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

	...

private:
	Node* _root = nullptr;
	size_t _size = 0;
};

5. 完善插入：

  • 旋转完成后是不需要继续向上更新平衡因子的，因为（1）旋转让这棵树平衡了；（2）旋转降低了这棵子树的高度，恢复到更插入前一样的高度，所以对上一层没有影响，不用更新。
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		// 插入，类比搜索二叉树插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_size++;
			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;
			}
		}

		cur = new Node(kv);
		if (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		_size++;
		
		// 调整，AVL树的核心部分

		while (parent)
		{
			// 平衡因子的更新
			if (cur == parent->_left)
			{
				// 插入在左节点，_bf--
				parent->_bf--;
			}
			else
			{
				// 插入在右节点，_bf++
				parent->_bf++;
			}
			
			// 判断是否要继续向上更新，和是否旋转调整
			if (parent->_bf == 0)
			{
				// 更新后 _bf == 0，说明子树高度不变，不需要往上更新
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				// 更新后子树高度改变，需要往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 平衡因子绝对值等于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);
				}
				else
				{
					assert(false);
				}

				// 完成旋转后，不需要再往上更新平衡因子了，直接break
				//	1、旋转让这棵树平衡了
				//	2、旋转降低了这棵子树的高度，恢复到更插入前一样的高度，所以对上一层没有影响，不用更新
				break;
			}
			else
			{
				// 平衡因子绝对值大于2，直接报错
				assert(false);
			}
		}

		return true;
	}

	...

private:
	Node* _root = nullptr;
	size_t _size = 0;
};

5. AVL树的验证

1. 验证其为二叉搜索树：

  • 如果中序遍历可得到一个有序的序列，就说明为二叉搜索树。

2. 验证其为平衡树：

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

3. 相关函数实现：

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

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

	int Height()
	{
		return _Height(_root);
	}

	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(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}
	
	size_t Size() const 
	{
		return _size;
	}
	
	...

private:
	Node* _root = nullptr;
	size_t _size = 0;
};

4. 测试代码：

void Test()
{
	const int N = 100;
	srand(time(0));
	vector<int> v;

	for (int i = 0; i < N; i++)
	{
		v.push_back(rand());
	}

	AVLTree<int, int> tree;
	for (auto e : v)
	{
		tree.Insert(make_pair(e, e));
	}
	tree.InOrder();		// 检查是否有序
	cout << tree.IsBalance() << endl;	// 检查是否平衡
	cout << tree.Height() << endl;	// 看看高度
	cout << tree.Size() << endl;	// 看看数据量
}

6. AVL树的删除（了解）

1. 思路：

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

2. 例：

在这里插入图片描述

  • 假如我们要删除根节点，可以先在右子树找到替换节点6，进行替换删除，然后更新平衡因子，得到的树如下图所示：

在这里插入图片描述

  • 更新7这个节点的平衡因子，更新为2，不用继续向上更新了，对7节点进行左单旋调整即可。

删除的代码不再写了，面试时也几乎不会考察，最多考察思路。

7. AVL树实现完整代码

#pragma once

#include<iostream>
#include<assert.h>

using namespace std;

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

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		// 插入，类比搜索二叉树插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_size++;
			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;
			}
		}

		cur = new Node(kv);
		if (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		_size++;
		
		// 调整，AVL树的核心部分

		while (parent)
		{
			// 平衡因子的更新
			if (cur == parent->_left)
			{
				// 插入在左节点，_bf--
				parent->_bf--;
			}
			else
			{
				// 插入在右节点，_bf++
				parent->_bf++;
			}
			
			// 判断是否要继续向上更新，和是否旋转调整
			if (parent->_bf == 0)
			{
				// 更新后 _bf == 0，说明子树高度不变，不需要往上更新
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				// 更新后子树高度改变，需要往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 平衡因子绝对值等于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);
				}
				else
				{
					assert(false);
				}

				// 完成旋转后，不需要再往上更新平衡因子了，直接break
				//	1、旋转让这棵树平衡了
				//	2、旋转降低了这棵子树的高度，恢复到更插入前一样的高度，所以对上一层没有影响，不用更新
				break;
			}
			else
			{
				// 平衡因子绝对值大于2，直接报错
				assert(false);
			}
		}

		return true;
	}

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

		// 更新左右节点
		parent->_right = subRL;
		subR->_left = parent;

		// 提前记录parent的parent
		Node* parentParent = parent->_parent;

		// 更新_parent
		parent->_parent = subR;
		if (subRL)	// 判断为不为空，subRL是唯一一个可能为空的节点
		{
			subRL->_parent = parent;
		}

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

		// 更新平衡因子
		parent->_bf = subR->_bf = 0;
	}

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

		// 更新左右节点
		subL->_right = parent;
		parent->_left = subLR;

		Node* parentParent = parent->_parent;

		// 更新_parent
		parent->_parent = subL;
		if (subLR)
		{
			subLR->_parent = parent;
		}

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

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

		int bf = subRL->_bf;	// 提前记录subRL的平衡因子，避免单旋操作后，值丢失

		// 先右旋再左旋
		RotateR(parent->_right);
		RotateL(parent);

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

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

		int bf = subLR->_bf;	// 提前记录subLR的平衡因子，避免单旋操作后，值丢失

		// 先左旋再右旋
		RotateL(parent->_left);
		RotateR(parent);

		// 更新平衡因子

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

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

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

	int Height()
	{
		return _Height(_root);
	}

	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(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

	size_t Size() const 
	{
		return _size;
	}

private:
	Node* _root = nullptr;
	size_t _size = 0;
};

8. AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即 l o g 2 ( N ) log_2 (N) log2​(N)。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：

  • 插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。

因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树。但是一个经常修改的结构，就不太适合用AVL树。

-指短琴长-
关注
  • 19
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C++进阶——AVL树
weixin_51885188的博客
03-08 988
文章目录C++进阶——AVL树AVL树的概念AVL树的实现AVL树节点的定义AVL树的四个默认成员函数构造函数拷贝构造析构函数赋值运算符重载AVL树的插入插入的步骤平衡因子的调节旋转处理（父节点的平衡因子违法平衡树的性质）代码实现[]运算符的重载AVL树的查找AVL树的打印验证是否为AVL树AVL树代码实现 C++进阶——AVL树 AVL树的概念 在前面的文章中我们学习了二叉搜索树，但是二叉搜索树虽然可以缩短查找的效率，但是 如果数据有序或者接近有序的情况下二叉搜索树会退化成单支树，查找元素相当于在顺序表中
数据结构篇——AVL树
SYLTXDY的博客
05-12 988
AVL树 AVL树是一种带有平衡条件的二叉搜索树，它保证每个节点的左子树和右子树高度最多差1。 组成高度为h的AVL树，需要最少的节点数S(h) = S(h-1) + S(h-2) + 1，如下图，这个高度为4的AVL树由三部分组成，左子树，右子树和根节点，左子树是高度为2，右子树高度是3，两棵子树都要求节点树最小，分别是S(2)和S(3)，最后再加上根节点一个节点。所以高度为4的AVL树，需...
C++进阶 —— AVL树
fen_0108的博客
08-14 1362
AVL树的节点内容包括：1、左右节点的地址；2、平衡因子；3、自身存储的数据；4、父节点的地址。int _bf;// 平衡因子:_kv(kv), _bf(0){}private:public://强制让编译器生成构造函数~AVLTree()private:return;
数据结构 - AVL树
TPON的博客
11-10 736
AVL树 - 平衡二叉搜索树
数据结构课程设计——基于Avl树的用户登陆系统.zip
09-29
2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。...
算法和数据结构——左程云.zip
06-16
这份名为"算法和数据结构——左程云.zip"的压缩包文件，很可能是他分享的一套全面的数据结构学习资源，特别适合大学生作为学习数据结构的参考资料。 数据结构是组织和存储数据的方式，它决定了数据的访问和操作效率...
数据结构——严蔚敏
09-12
课后习题是学习过程中的重要组成部分，严蔚敏老师的《数据结构》一书的习题覆盖了各个知识点，从基础到进阶，旨在巩固理论知识并训练实际应用能力。答案的提供则帮助学习者检验自己的理解，及时查漏补缺，确保学习...
计算机+数据结构与算法+学习路线+蓝桥杯
05-10
### 计算机数据结构与算法学习路线——聚焦蓝桥杯 #### 一、基础知识准备 **1.1 线性数据结构** 线性数据结构是计算机科学中最基础的数据组织方式之一，主要包括数组、链表、栈和队列等。 - **数组**：是一种...
数据结构——排序（4）：归并排序+计数排序
2301_81888634的博客
08-16 630
至此我们学习了顺序表、链表、栈、队列、二叉树、排序，初阶数据结构完结~撒花！我们C++见！！
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 601
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
链表 19.删除链表的倒数第N个节点 双指针
qq_64633597的博客
08-14 180
return head 和return dummy.next 的区别，若删除的是头节点，则头节点还需要更新，题目中给的头节点就不能用了。而dummy作为虚拟头节点，永远是头节点的上一位，即使head发生变化，仍然是dummy.next。fast走n+1步，是为了和slow保持n+1个位置，此时fast移动至空节点，slow与fast位置差n+1节点，那slow再往后移动一位，就是需要删除的倒数第n个节点，即目标节点。倒数第几个，翻过来看即正数第几个。
数据结构----链表
新手嵌入式学习的博客
08-16 671
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
【数据结构篇】~顺序表
最新发布
2301_81806517的博客
08-16 350
【数据结构篇】~顺序表
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 213
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
Codeforces Round 965 (Div. 2)
HKUST_ZJH的博客
08-14 1089
Codeforces Round 965 (Div. 2)
数据结构初阶——算法复杂度超详解
fhvyxyci的博客
08-15 1032
1.数据结构前言 1.1 数据结构 1.2 算法 2.算法效率 2.1 复杂度的概念 3. 时间复杂度 3.1 大O的渐进表示法 3.2 时间复杂度计算示例 示例1 示例2 示例3 示例4 示例5 示例6 示例7 4. 空间复杂度 4.1 空间复杂度计算示例 4.1.1 示例1 4.1.2 示例2 5. 常见复杂度对比 6.复杂度算法题——[旋转数组](https://leetcode.cn/problems/rotate-array/description/) 思路1 思路2 思路3
【Java & 数据结构】LinkedList介绍
qq_42150700的博客
08-14 1060
回答这个问题前, 首先我们需要了解一下这个头节点是干什么的. 这个头节点实际上和寻常的节点没有什么两样, 但是它的数据域, 是不存储真正的数据的, 你可以在这个数据域中存储任意的数据, 例如存储链表的长度, 或者根本不使用这个数据域都是可以的. 它的作用就是用于作为链表的头, 便于链表的操作和管理而设计的.首先我们要想这个节点和链表是什么关系?很明显如果要插入一定要前一个位置的引用, 因为要令其 next 指向当前节点, 因此我们需要找到前一个节点. 那么我们如何找到前一个节点呢?
数据结构之红黑树
我要学编程的博客
08-16 566
红黑树的概念、性质、插入、验证； AVL树和红黑树的比较
红黑树：优化AVL树的高效数据结构
相比之下，AVL树虽然保证了单次操作的最坏时间复杂度，即O(logn)，但它的节点结构需要额外的平衡因子标识，删除操作后可能需要进行多达(logn)次旋转，导致树结构频繁变化，不利于稳定性和效率。为了改进这一问题，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-指短琴长-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值