AVL树全解析

AVL树是计算机科学中一种自平衡的二叉搜索树,旨在保持树的高度尽可能低,以提高查找、插入和删除操作的效率。它是由苏联数学家 Adelson-VelskyLandis 于1962年发明的,因此得名为 AVL 树。

1. AVL树的定义与概念

1.1 定义

AVL树是一种满足以下条件的二叉搜索树:

  1. 二叉搜索树的性质:对每个节点,其左子树中的所有节点值小于该节点值,右子树中的所有节点值大于该节点值。
  2. 平衡因子:对每个节点,左右子树的高度差(称为平衡因子)最多为 1,即 平衡因子=左子树高度−右子树高度
  3. 自平衡性:在每次插入或删除节点后,AVL树会通过旋转操作重新平衡,以确保树的平衡因子始终在 [−1,1][-1, 1][−1,1] 之间。

1.2 关键性质

  1. 高度受限:在有 n 个节点的情况下,AVL树的高度始终保持在 log⁡2 n 的量级,因此查找、插入和删除操作的时间复杂度是 O(log⁡ n)。
  2. 旋转操作:在插入或删除导致平衡因子超出范围时,通过旋转操作恢复平衡:
    • 单旋转:左旋或右旋
    • 双旋转:先左后右旋,或先右后左旋

2. AVL树的结构

template<class T, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;

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

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

private:
    Node* _root = nullptr;
};

3. AVL树的插入

3.1 节点插入

1. 插入一个值的第一步是按照二叉搜索树的规则进行插入。新的节点被添加到树中作为叶子节点。

2.插入新节点后,树的高度可能会发生变化,但这种变化只会影响插入节点的祖先节点的高度。因此,需要从新增节点沿路径向根节点更新每个祖先节点的平衡因子。最坏情况下需要更新到根节点,有时在中间某个节点即可停止更新,具体情况取决于树的结构和平衡因子的变化。

3.1 如果在更新平衡因子的过程中未发现任何节点的平衡因子超出范围(即不超过1或-1),说明树仍然平衡,插入操作结束。

3.2 如果在更新平衡因子的过程中发现某个节点的平衡因子不在范围内(即等于2或-2),说明该节点所在的子树失衡。通过旋转操作调整子树恢复平衡,同时降低子树的高度,使其不再影响上一层。旋转后,插入操作结束。

3.2 平衡因子的更新

更新原则

  1. 平衡因子的定义:平衡因子 = 右子树高度 - 左子树高度
  2. 更新条件:只有子树高度发生变化时,当前节点的平衡因子才会受到影响。
  3. 节点插入对平衡因子的影响
    • 如果新节点插入到父节点的右子树中,父节点的平衡因子增加1。
    • 如果新节点插入到父节点的左子树中,父节点的平衡因子减少1。
  4. 更新路径:父节点所在子树的高度变化将决定是否需要继续向上更新。

更新停止条件

  1. 平衡因子更新后等于0
    当父节点的平衡因子从 -1 变为 0 或从 1 变为 0 时,表示插入的节点被添加到了较低的子树,使两边高度相等,父节点所在子树的高度未发生变化,因此可以停止更新。
  2. 平衡因子更新后等于1或-1
    当父节点的平衡因子从 0 变为 1 或从 0 变为 -1 时,表示插入的节点导致父节点所在子树一边高、一边低。虽然父节点的子树高度增加了,但仍满足平衡条件,因此需要继续向上更新。
  3. 平衡因子更新后等于2或-2
    当父节点的平衡因子从 1 变为 2 或从 -1 变为 -2 时,表示插入的节点使父节点所在子树失衡,需要通过旋转操作恢复平衡。旋转的目标是:
    • 使子树恢复平衡。
    • 降低子树的高度,使其恢复到插入节点之前的高度,从而无需继续向上更新。

3.3 代码实现

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
		}
		//找到预插入节点
		Node* parent = nullptr;
		Node* cur = _root;
		//找到预插入节点位置时循环停止
		while (cur)
		{
			//插入节点小于当前节点则向左走
			if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			////插入节点大于当前节点则向右走
			else if (cur->kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right
			}
			else {
				return false;
			}
		}
		//插入节点
		cur = new Node(kv);
        //插入节点小于当前节点则插入左子树
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
        //插入节点大于当前节点则插入右子树
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//更新平衡因子
		while (cur)
		{
            //插入左子树平衡因子减一
			if (cur->_kv.first < parent->_kv.first)
			{
				parent->_bf--;
			}
			else if (cur->_kv.first > parent->_kv.first)
			{
				parent->_bf++;
			}
			//平衡因子为0时停止更新
			if (parent->_bf == 0) break;
			//为1时继续向上更新
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = cur->_parent;
			}
			//为-2时需要旋转
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

4. AVL树的旋转

4.1 AVL树旋转的原则

1. 旋转的目标

  • 恢复平衡:将失衡节点及其子树调整为平衡状态,使所有节点的平衡因子重新满足 -1、0 或 1。
  • 高度优化:旋转后,受影响子树的高度恢复到操作前的高度,以避免继续向上影响祖先节点。
  • 保持二叉搜索树性质:调整后,树仍然是二叉搜索树,左子树的值小于根节点,右子树的值大于根节点。

2. 失衡类型

失衡的节点根据其平衡因子的变化,可以分为以下四种情况:

  1. 左子树过高(LL型)
    插入点位于失衡节点的左子树的左子树上。
    解决方法:右旋(Single Right Rotation)。
  2. 右子树过高(RR型)
    插入点位于失衡节点的右子树的右子树上。
    解决方法:左旋(Single Left Rotation)。
  3. 左右失衡(LR型)
    插入点位于失衡节点的左子树的右子树上。
    解决方法:先左旋后右旋(Double Rotation: Left-Right)。
  4. 右左失衡(RL型)
    插入点位于失衡节点的右子树的左子树上。
    解决方法:先右旋后左旋(Double Rotation: Right-Left)。

3. 旋转操作的具体原则

  1. 右旋(Single Right Rotation)

    • 适用于 LL型 失衡。
    • 原理:将失衡节点的左子节点提升为新的根节点,同时将原根节点作为左子节点的右子树。
    • 高度变化:子树高度减少1。
  2. 左旋(Single Left Rotation)

    • 适用于 RR型 失衡。
    • 原理:将失衡节点的右子节点提升为新的根节点,同时将原根节点作为右子节点的左子树。
    • 高度变化:子树高度减少1。
  3. 左右旋(Left-Right Rotation)

    • 适用于 LR型 失衡。
    • 原理:对失衡节点的左子节点先进行一次左旋,变成 LL型 后,再对失衡节点进行右旋。
    • 高度变化:子树高度减少1。
  4. 右左旋(Right-Left Rotation)

    • 适用于 RL型 失衡。
    • 原理:对失衡节点的右子节点先进行一次右旋,变成 RR型 后,再对失衡节点进行左旋。
    • 高度变化:子树高度减少1。

4.2 代码实现

(1)右单旋

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

		//改变指向
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;
		parent->_parent = subL;

		//如果parent是整棵树的根
		if (parent->_parent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == parent->_parent->_left)
			{
				parent->_parent->_left = subL;
			}
			else if (parent == parent->_parent->_right)
			{
				parent->_parent->_right = subL;
			}
			subL->_parent = parent->_parent;
		}
		parent->_bf = subL->_bf = 0;
	}

(2)左单旋

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

		//改变指向
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;

		//如果parent是整棵树的根
		if (parent->_parent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == parent->_parent->_left)
			{
				parent->_parent->_left = subR;
			}
			else if (parent == parent->_parent->_right)
			{
				parent->_parent->_right = subR;
			}
			subR->_parent = parent->_parent;
		}
		parent->_bf = subR->_bf = 0;
	}

 (3)左右双旋

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

		//左旋
		RotateL(subL);
		//右旋
		RotateR(parent);

		if (bf == 0)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			subLR->_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;
		RotateR(parent->_right);
		RotateL(parent);
		if (bf == 0)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

5. AVL树的查找

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

6. 完整代码

template<class T, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;

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

template<class T, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
		}
		//找到预插入节点
		Node* parent = nullptr;
		Node* cur = _root;
		//找到预插入节点位置时循环停止
		while (cur)
		{
			//插入节点小于当前节点则向左走
			if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			////插入节点大于当前节点则向右走
			else if (cur->kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right
			}
			else {
				return false;
			}
		}
		//插入节点
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//更新平衡因子
		while (cur)
		{
			if (cur->_kv.first < parent->_kv.first)
			{
				parent->_bf--;
			}
			else if (cur->_kv.first > parent->_kv.first)
			{
				parent->_bf++;
			}
			//平衡因子为0时停止更新
			if (parent->_bf == 0) break;
			//为1时继续向上更新
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = cur->_parent;
			}
			//为-2时需要旋转
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}
	//右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		//改变指向
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;
		parent->_parent = subL;

		//如果parent是整棵树的根
		if (parent->_parent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == parent->_parent->_left)
			{
				parent->_parent->_left = subL;
			}
			else if (parent == parent->_parent->_right)
			{
				parent->_parent->_right = subL;
			}
			subL->_parent = parent->_parent;
		}
		parent->_bf = subL->_bf = 0;
	}
	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subL->_right;

		//改变指向
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;

		//如果parent是整棵树的根
		if (parent->_parent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == parent->_parent->_left)
			{
				parent->_parent->_left = subR;
			}
			else if (parent == parent->_parent->_right)
			{
				parent->_parent->_right = subR;
			}
			subR->_parent = parent->_parent;
		}
		parent->_bf = subR->_bf = 0;
	}
	//左右双旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		//左旋
		RotateL(subL);
		//右旋
		RotateR(parent);

		if (bf == 0)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}

	}
	//右左双旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;
		RotateR(parent->_right);
		RotateL(parent);
		if (bf == 0)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	//查找
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_bf.first > key)
			{
				cur = cur->_left;
			}
			else if (cur->_bf.first < key)
			{
				cur = cur->_right
			}
			else {
				return cur;
			}
		}
		return nullptr;
	}
private:
	Node* _root = nullptr;
};

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值