数据结构进阶——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 981
文章目录C++进阶——AVL树AVL树的概念AVL树的实现AVL树节点的定义AVL树的四个默认成员函数构造函数拷贝构造析构函数赋值运算符重载AVL树的插入插入的步骤平衡因子的调节旋转处理（父节点的平衡因子违法平衡树的性质）代码实现[]运算符的重载AVL树的查找AVL树的打印验证是否为AVL树AVL树代码实现 C++进阶——AVL树 AVL树的概念 在前面的文章中我们学习了二叉搜索树，但是二叉搜索树虽然可以缩短查找的效率，但是 如果数据有序或者接近有序的情况下二叉搜索树会退化成单支树，查找元素相当于在顺序表中
1.3.C语言基础进阶——AVL树的原理及实现
u012675188的博客
07-08 233
1.3.C语言基础进阶——AVL树的原理及实现 今天的内容比昨天跟的要好，但是代码实践部分速度对于我来说太快了，这个部分没有跟上，课下补的 二叉排序树 数据结构 = 结构定义 + 结构操作，结构操作维护结构定义 又叫做二叉搜索树 性质： 左子树 < 根节点，右子树 > 根节点 基本操作 插入：每次插入会插入到叶子节点 删除 删除叶子节点：最简单，直接删除即可 删除出度为1的节点：删除节点后，将其父节点与其子结点相连 删除出度为2的节点 首先找到该节点的前驱节点，即其左子树中最右节点 将
C++进阶 —— AVL树
NapoleonCoder的博客
12-11 789
AVL树！
C++进阶——AVL树的构建
weixin_43635473的博客
05-15 611
AVLTreeNode(const pair < k , v > & kv) //节点构造函数 : _left(nullptr) , _right(nullptr) , _parent(nullptr) , _kv(kv) , _be(0) {int _be;
【进阶数据结构】平衡搜索二叉树 —— AVL树
East-sunrise的博客
03-21 1093
平衡的AVL树真的很美
MySQL进阶——B+树索引结构
发现问题，面对问题，分析问题，解决问题，总结问题
11-14 2781
索引是提升查询速度的一种数据结构。 索引之所以能提升查询速度，在于它在插入时对数据进行了排序（显而易见，它的缺点是影响插入或者更新的性能）。 所以，索引是一门排序的艺术，有效地设计并创建索引，会提升数据库系统的整体性能。在目前的 MySQL 8.0 版本中，InnoDB 存储引擎支持的索引有 B+ 树索引、全文索引、R 树索引。...
1.4.C语言基础进阶——红黑树
u012675188的博客
07-09 264
C语言基础进阶——红黑树 红黑树是一类平衡二叉排序树 基本介绍 五个条件 每个节点非黑即红 根节点是黑色 叶节点（NIL）是黑色 NIL即NULL is legal 是一个结点，访问是合法的 在图中一般不会画出来 如果一个节点是红色，则它的两个子结点都是黑色的 辅助控制红黑树的次要条件 从根节点出发到所有叶节点路径上，黑色节点数量相同 控制红黑树的关键条件 最长路径最多为最短路径的两倍 对于红黑树的某高度下最少结点数目low(H) = low(H - 1) + low(H / 2) + 1
【C++进阶学习】第七弹——AVL树——树形结构存储数据的经典模块
2301_80220607的博客
07-15 2780
【STL深度挖掘】——AVL树的原理和实现，适合初学者仔细阅读观看！！！
数据结构与算法——树的进阶
三横同学的博客
05-02 572
树的进阶 二叉排序树 二叉排序树介绍 二叉排序树:BST: (Binary Sort(Search) Tree),对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 特别说明:如果有相同的值，可以将该节点放在左子节点或右子节点比如针对前面的数据(7,3,10,12,5,1,9)，对应的二叉排序树为: 二叉排序树创建和遍历 一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序树，比如:数组为Array(7,3,10,12,5,1,9),心创建成对应的二叉排
数据结构课程设计——基于Avl树的用户登陆系统.zip
09-29
2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。...
算法和数据结构——左程云.zip
06-16
这份名为"算法和数据结构——左程云.zip"的压缩包文件，很可能是他分享的一套全面的数据结构学习资源，特别适合大学生作为学习数据结构的参考资料。 数据结构是组织和存储数据的方式，它决定了数据的访问和操作效率...
数据结构——严蔚敏
09-12
课后习题是学习过程中的重要组成部分，严蔚敏老师的《数据结构》一书的习题覆盖了各个知识点，从基础到进阶，旨在巩固理论知识并训练实际应用能力。答案的提供则帮助学习者检验自己的理解，及时查漏补缺，确保学习...
计算机+数据结构与算法+学习路线+蓝桥杯
05-10
### 计算机数据结构与算法学习路线——聚焦蓝桥杯 #### 一、基础知识准备 **1.1 线性数据结构** 线性数据结构是计算机科学中最基础的数据组织方式之一，主要包括数组、链表、栈和队列等。 - **数组**：是一种...
【归并排序/快排/堆排序】912. 排序数组
m0_63530048的博客
08-07 320
维护大顶堆：从下往上，第一个有孩子节点的节点开始，取根节点、左孩子、右孩子之间的最大值 换到根节点处
数据结构之八大排序（下）
我要学编程的博客
08-03 1492
快速排序及其优化 归并排序 计数排序
数据结构--第六天
xujiashuo1的博客
08-08 1240
树是由。
【深度学习】P1 深度学习数据结构
weixin_43098506的博客
08-07 749
深度学习的数据结构——张量的概念与其基本操作
数据结构 JAVADS ——部分栈题目分享 (持续更新版)
最新发布
cjejwe的博客
08-09 760
让我们看看这个代码(C++ 版本)
红黑树：优化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、付费专栏及课程。

余额充值