平衡搜索树AVL 插入操作及旋转分析

最新推荐文章于 2024-08-16 11:43:21 发布
最新推荐文章于 2024-08-16 11:43:21 发布
阅读量484 收藏 3
点赞数 3
分类专栏： 数据结构 c++ 文章标签： 数据结构 算法 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44785014/article/details/107039353
版权

文章目录

AVL树的概念

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

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

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

在这里插入图片描述
平衡因子 = 右子树高度 - 左子树高度
上图树中的所有节点的平衡因子: 1/ -1/ 0，即满足左右子树高度差绝对值不超过1，即称该树是平衡的。

AVL树的性质：
如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在logn，搜索时间复杂度O(logN )。

AVL树节点的定义

为了方便实现，每个节点引入bf平衡因子 =右子树高度 - 左子树的高度
父节点指针用来判断插入之后是否旋转及旋转之后维护平衡因子的。


template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//平衡因子
	pair<int, int> _kv;//键值对 类型的元素

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

AVL树的插入

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

  1. 先按照二叉搜索树的规则将节点插入到AVL树中
  2. 新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否破坏了AVL树的平衡性
//1.按照排序树的规则，找到插入位置
		if (_root == nullptr)//一开始为空时
		{
			_root = new Node(kv);
			_root->_bf = 0;
			return true;
		}
		
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false; //之前有过，要是不允许重复，则插入失败
			}
		}
		//2.找到插入位置后，进行插入
		cur = new Node(kv);
		if (parent->_kv.first < kv.first) //挂载到右子树上
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else //挂载到左子树
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

注意：每个节点插入之前，当前树必定是平衡树，即：其父亲节点的平衡因子分为三种情况：-1，0, 1，而再根据插入的位置，更新其平衡因子，也分以下两种情况：

  1. 如果插入到父节点的左侧，只需给父节点的平衡因子-1即可；
  2. 如果插入到父节点的右侧，只需给父节点的平衡因子+1即可；
//更新父节点平衡因子
			if (cur == parent->_left)//挂到其左边的，因子减一
				parent->_bf--;
			else  if(cur == parent->_right)   //挂到右边，因子加一
				parent->_bf++;

如何根据平衡因子维护平衡

新插入的节点，影响的是新插入节点的祖先的平衡因子（即需要自下而上更新）。此时：其父节点的平衡因子可能有三种情况：0，正负1， 正负2

  • a.如果父节点的平衡因子为0，说明插入之前父节点的平衡因子为正负1，插入后被调整成0，对上一层没有影响，此时满足AVL树的性质，插入成功；
  • b.如果父节点的平衡因子为正负1，说明插入父节点的平衡因子一定为0，插入后被更新成正负1，此时以此父节点为根的树的高度增加，需要继续向上更新
  • c.如果父节点的平衡因子更新完成后变成正负2，则说明以此父节点为根的树已经不平衡，那么需要旋转处理让他平衡。
while (parent)
		{
			//更新平衡因子
			if (cur == parent->_left)//挂到其左边的，因子减一
				parent->_bf--;
			else  if(cur == parent->_right)   //挂到右边，因子加一
				parent->_bf++;
			//判断是否需要需要旋转 对应三种情况
			if (parent->_bf == 0)//上层已经是平衡了的
				break;
			else if (abs(parent->_bf)==1)
			{
				cur = parent;
				parent = parent->_parent;//继续向上更新
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 说明parent子树已经不平衡，需要旋转处理，让其平衡
				if (parent->_bf == 2)
				{
					if (cur->_bf == 1)//此情况需进行左单旋
						RotateL(parent);
					else if (cur->_bf == -1)//先右旋再左旋
						RotateRL(parent);
				}
				else if (parent->_bf == -2)
				{
					if (cur->_bf == -1)
					{
						RotateR(parent);//右单旋
					}
					else if (cur->_bf == 1)
					{
						RotateLR(parent);//先左旋再右旋
					}
				}
				//处理完毕后 break;
				break;
			}

AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。
旋转规则:
1、让这颗不平衡的树恢复平衡。
2、使这棵树高度降1，恢复到插入之前时的高度。不会对上层造成影响，停止更新。
3、且保持住搜索树的规则。

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

右单旋

新节点插入到较高左子树的左侧（即本身此树（60为根）的左子树高度便高于右子树，再在其左子树的左侧插入新节点）--------》左左：使用右单旋，维持平衡。如：
在这里插入图片描述
上图在插入前，AVL树是平衡的，新节点插入到30的左子树(注意：此处不是左孩子（抽象图里的左子树）)中，30左子树增加了一层，导致以60为根的二叉树不平衡，要让60平衡，只能将60左子树的高度减少一层，右子树增加一层，
即将左子树往上提，这样60转下来，因为60比30大，只能将其放在30的右子树，而如果30有右子树，右子树根的值一定大于30，小于60，只能将其放在60的左子树，旋转完成后，更新节点的平衡因子即可。在旋转过程中，有以下几种细节情况需要考虑：
–30节点的右孩子可能存在，也可能不存在
–60可能是根节点，也可能是子树
如果是根节点，旋转完成后，要更新根节点
如果是子树，可能是某个节点的左子树，也可能是右子树（需要链接起来）

在这里插入图片描述
最后平衡因子的更新：subL->_bf = parent->_bf = 0;

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

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

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

左单旋

新节点插入到较高右子树的右侧（即本身此树（60为根）的右子树高度便高于左子树，再在其右子树的右侧插入新节点）--------》右右：使用左单旋，维持平衡。如：
在这里插入图片描述
与右单旋的旋转处理都是一样的，主要是将其高度降一，在考虑节点间的链接情况：

在这里插入图片描述
最后平衡因子的更新：subL->_bf = parent->_bf = 0;

void RotateL(Node* parent) //左单旋
	{
		Node* subR = parent->_right;  //旋转需要的子树节点
		Node* subRL = subR->_left;

		//旋转 及 链接旋转之后节点之间的关系
		parent->_right = subRL;
		if (subRL) //可能为空的
			subRL->_parent = parent;
		subR->_left = parent;
		Node* pparent = parent->_parent;//这棵树也可能是其他树的子树，保存其祖先，准备判断
		parent->_parent = subR;

		if (parent == _root) //不是子树,本身就是根,则更新为新的根节点
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else          //是其他树的子树，则链接上
		{
			if (pparent->_left == parent)
				pparent->_left = subR;
			else if (pparent->_right == parent)
				pparent->_right = subR;
			subR->_parent = pparent;
		}
		//更新平衡因子
		subR->_bf = parent->_bf = 0;
	}

双旋：先左单旋再右单旋

新节点插入较高左子树的右侧（以90为根的左子树本身就高于其右子树，再在其左子树的右侧插入节点（不论右侧的左还是右），则需将其左子树先左单旋，再将其右单旋）
-------》左右：先左单旋再右单旋
在这里插入图片描述
将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。

void RotateLR(Node* parent)//左右双旋，先对其左子树左旋，再对其右旋   ,但是要注意平衡因子的调整
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;  //根据插入节点的父节点的平衡因子来判断
        //旋转之前，60的平衡因子可能是-1/0/1，旋转完成之后，根据情况对其他节点的平衡因子进行调整
        
		RotateL(subL);
		RotateR(parent);
		//旋转后调节平衡因子
		if (bf == 1)  //选择在其右边插入
		{
			parent->_bf = 0;
			subL->_bf = - 1;
			subLR->_bf = 0;
		}
		else if (bf == -1)//选择在其左边插入  对应上图例子
		{
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0) //选择插入到高度低的那一边后，自己是平衡的，则双旋后，都是平衡的了
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
	}

双旋之先右单旋再左单旋

新节点插入较高右子树的左侧（以30为根的右子树本身就高于其左子树子树，再在其右子树的左侧插入节点（不论左侧的左还是右），则需将其右子树先右单旋，再将其左单旋）
-------》右左：先右单旋再左单旋

在这里插入图片描述
将双旋变成单旋后再旋转，即：先对90进行右单旋，然后再对30进行左单旋，旋转完成后再考虑平衡因子的更新。

void RotateRL(Node* parent)//右左双旋，先对其右子树右旋，在对其左旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(subR);
		RotateL(parent);
		
		if (bf == 1)  //对应上图例子
		{
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
	}

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

  1. Parent的平衡因子为2，说明Parent的右子树高，设Parent的右子树的根为SubR
    当SubR的平衡因子为1时，执行左单旋
    当SubR的平衡因子为-1时，执行右左双旋
  2. Parent的平衡因子为-2，说明Parent的左子树高，设Parent的左子树的根为SubL
    当SubL的平衡因子为-1是，执行右单旋
    当SubL的平衡因子为1时，执行左右双旋

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

else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 说明parent子树已经不平衡，需要旋转处理，让其平衡
				if (parent->_bf == 2)
				{
					if (cur->_bf == 1)//此情况需进行左单旋
						RotateL(parent);
					else if (cur->_bf == -1)//先右旋再左旋
						RotateRL(parent);
				}
				else if (parent->_bf == -2)
				{
					if (cur->_bf == -1)
					{
						RotateR(parent);//右单旋
					}
					else if (cur->_bf == 1)
					{
						RotateLR(parent);//先左旋再右旋
					}
				}
				//处理完毕后 break;
				break;

AVL树的验证

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

  1. 验证其为二叉搜索树
    如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
  2. 验证其为平衡树
    每个节点子树高度差的绝对值不超过1(有些AVL树的结构节点中并没有引入平衡因子，所以使用递归求高度来验证)，进而来判断节点的平衡因子是否计算正确。
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);
	}

	int Height(Node* root)//求最大子树高度
	{
		if (root == nullptr)
			return 0;

		int lefeHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return lefeHeight > rightHeight ? lefeHeight + 1 : rightHeight + 1;
	}

	bool _IsBalance(Node* root)//判断是否平衡，即左右子树高度差不超过1，及其左右子树也满足，即为平衡
	{
		if (root == nullptr)
			return true;

		int lefeHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		int diff = lefeHeight - rightHeight;//当前树的平衡因子

		// 如果计算出的平衡因子与root的平衡因子不相等，或者
		// root平衡因子的绝对值超过1，则一定不是AVL树
		if (diff != root->_bf || (diff > 1 || diff < -1))
		{
			cout << "平衡因子不匹配！" << endl;
			return false;
		}	 
		return  _IsBalance(root->_left) && _IsBalance(root->_right);
	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}

AVL树的性能

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

完整代码

#pragma once
#include<assert.h>


template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//平衡因子
	pair<int, int> _kv;//键值对 类型的元素

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

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<const K,V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		//1.按照排序树的规则，找到插入位置
		if (_root == nullptr)//一开始为空时
		{
			_root = new Node(kv);
			_root->_bf = 0;
			return true;
		}
		
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false; //之前有过
			}
		}
		//2.找到插入位置后，进行插入
		cur = new Node(kv);
		if (parent->_kv.first < kv.first) //挂载到右子树上
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else //挂载到左子树
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		//3.为了保持平衡，根据平衡因子判断是否需要旋转，且更新平衡因子  平衡因子= 右子树高度-左子树高度
		///新插入的节点，影响的是新插入节点的祖先的平衡因子
			/a.右子树的高度变化，则父亲的平衡因子 + 1, 左子树的高度变化，则父亲的平衡因子 - 1
			/b.父亲的平衡囚子电新完成后变成1/ -l，则说明父亲所在的子树的高度变了，则继续往上更新。
			c.父亲的平衡因子更新完成后变成2 / 2, 则说明父亲所在的子树已经不平衡，那么需要旋转处理让他平衡。
			d.父亲的平衡因子更新完成后变成0,则说明父亲所在的子树的高度没变，对上一层没有影响，则更新完成。

		while (parent)
		{
			//更新平衡因子
			if (cur == parent->_left)//挂到其左边的，因子减一
				parent->_bf--;
			else  if(cur == parent->_right)   //挂到右边，因子加一
				parent->_bf++;
			//判断是否需要需要旋转 对应三种情况
			if (parent->_bf == 0)//上层已经是平衡了的
				break;
			else if (abs(parent->_bf)==1)
			{
				cur = parent;
				parent = parent->_parent;//继续向上更新
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 说明parent子树已经不平衡，需要旋转处理，让其平衡
				if (parent->_bf == 2)
				{
					if (cur->_bf == 1)//此情况需进行左单旋
						RotateL(parent);
					else if (cur->_bf == -1)//先右旋再左旋
						RotateRL(parent);
				}
				else if (parent->_bf == -2)
				{
					if (cur->_bf == -1)
					{
						RotateR(parent);//右单旋
					}
					else if (cur->_bf == 1)
					{
						RotateLR(parent);//先左旋再右旋
					}
				}
				//处理完毕后 break;
				break;
			}
		}
		return true;
	}
	void RotateL(Node* parent) //左旋
	{
		Node* subR = parent->_right;  //旋转需要的子树
		Node* subRL = subR->_left;

		//旋转 及 链接旋转之后节点之间的关系
		parent->_right = subRL;
		if (subRL) //可能为空的
			subRL->_parent = parent;
		subR->_left = parent;
		Node* pparent = parent->_parent;//这棵树也可能是其他树的子树，保存其祖先，准备判断
		parent->_parent = subR;

		if (parent == _root) //不是子树,本身就是根,则更新为新的根节点
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else          //是其他树的子树，则链接上
		{
			if (pparent->_left == parent)
				pparent->_left = subR;
			else if (pparent->_right == parent)
				pparent->_right = subR;
			subR->_parent = pparent;
		}
		//更新平衡因子
		subR->_bf = parent->_bf = 0;
	}
	void RotateR(Node* parent) //右单旋 
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

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

		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (pparent->_left == parent)
				pparent->_left = subL;
			else
				pparent->_right = subL;
			subL->_parent = pparent;
		}
		subL->_bf = parent->_bf = 0;
	}
	void RotateLR(Node* parent)//左右双旋，先对其左子树左旋，再对其右旋   ,但是要注意平衡因子的调整
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;  //根据插入节点的父节点的平衡因子来判断

		RotateL(subL);
		RotateR(parent);
		//旋转后调节平衡因子
		if (bf == 1)  //本来是平衡的，来插入到右边
		{
			parent->_bf = 0;
			subL->_bf = - 1;
			subLR->_bf = 0;
		}
		else if (bf == -1)//本来是平衡的，来插入到左边
		{
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0)//插入到高度低的那一边后，自己是平衡的，则双旋后，都是平衡的了
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
	}
	void RotateRL(Node* parent)//右左双旋，先对其右子树右旋，在对其左旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(subR);
		RotateL(parent);
		
		if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
	}

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

	int Height(Node* root)//求最大子树高度
	{
		if (root == nullptr)
			return 0;

		int lefeHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return lefeHeight > rightHeight ? lefeHeight + 1 : rightHeight + 1;
	}

	bool _IsBalance(Node* root)//判断是否平衡，即左右子树高度差不超过1，及其左右子树也满足，即为平衡
	{
		if (root == nullptr)
			return true;

		int lefeHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		int diff = lefeHeight - rightHeight;//当前树的平衡因子

		// 如果计算出的平衡因子与root的平衡因子不相等，或者
		// root平衡因子的绝对值超过1，则一定不是AVL树
		if (diff != root->_bf || (diff > 1 || diff < -1))
		{
			cout << "平衡因子不匹配！" << endl;
			return false;
		}	 
		return  _IsBalance(root->_left) && _IsBalance(root->_right);
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	Node* _root = nullptr;
};

测试


#include<iostream>
#include<vector>
#include<time.h>
using namespace std;

#include "AVLTree.h"


void TestAVLTree1()
{
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
		//cout << t.IsBalance() << endl;
	}
	t.InOrder();
	cout << t.IsBalance() << endl;
}
void TestAVLTree2()
{
	AVLTree<int, int> avl;
	vector<int> v;
	int n = 100000;
	srand(time(0));
	for (int i = 0; i < n; i++)
	{
		v.push_back(rand());
	}
	for (auto e : v)
	{
		avl.Insert({ e, e });
	}
	//avl.InOrder();
	cout << avl.IsBalance() << endl;
}
int main()
{
	TestAVLTree2();
	return 0;
}
e我所欲也
关注
专栏目录
【AVL树】AVL树的插入操作以及旋转
菜鸟成长记
04-17 2540
在讲解AVL树之前必须了解二叉搜索树， 可以看我之前的博客：二叉搜索树AVL树是在二叉搜索树的基础上，在向二叉树排序树中插入新的结点，如果保证每个结点的左右子树的高度差的绝对值不超过1，即需要在插入的时候判断是否满足条件，然后对树进行旋转，从而可减低树的高度，减少平均搜索长度。AVL树：(1)它的左右子树都是AVL树 (2)右子树和左子树的高度差(平衡因子)的绝对值不能
AVL树的插入操作
Rinki123456的博客
08-08 2744
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：它的左右子树都是AVL树。......
AVL树
晴天的专栏
03-19 802
1. 概述 AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下都是O（log n），增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。本文介绍了AVL树的设计思想和基本操作。 2. 基本术语 有四
数据结构——AVL树
最新发布
2401_86777036的博客
08-16 749
新节点插入后，假设以parent为根的子树不平衡：parent与其较高子树节点的平衡因子时同号时单旋转，异号时双旋转。旋转完成后，原parent为根的子树个高度降低，已经平衡，不需要再向上更新。
AVL树的旋转
热门推荐
Worm Hole
04-09 2万+
AVL树的旋转
手写AVL树(详解插入时的4种旋转)
qq_45928272的博客
06-03 642
二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接 近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)。 所以科学家对二叉搜索树采取平衡处理，实现出AVL树。 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 当这棵树是AVL树的时候，它的左右子树都是AVL树 且左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1) 如果一棵二叉搜索树的高度是平衡的，它就是AVL树。如果它有n
详细图解----AVL树的插入和旋转
昂的博客
04-22 631
文章目录AVL树的插入和旋转AVLTree是什么？AVLTree构造AVLTreeInsertAVL旋转左旋右旋双旋维护平衡因子 AVL树的插入和旋转 AVLTree是什么？ AVLTree叫平衡二叉搜索树，不同于普通的二叉搜索树，重点在于平衡， 它具有：他是一棵空树或该树非叶子节点的节点的左右子树的高度差的绝对值不超过1，所以会有个平衡因子进行维护，平衡因子的范围是(-1、0、1)。 这里有二叉搜索树的基础会明白的更好，没有了解的建议先去了解。 AVLTree 构造AVLTree public class
AVL平衡树及插入操作的C语言实现
06-21
- **插入操作**：插入新节点时，先进行常规的二叉搜索树插入，然后检查新插入节点的祖先节点的平衡因子，若超限则执行旋转。 - **旋转操作**： - **左旋**：当一个节点的右子树过高时，可能需要对其左旋。右子...
avl.rar_AVL树_avl 旋转_树 旋转
09-24
AVL树是一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，故以其首字母命名。AVL树的特点是任何节点的两个子树的高度差不超过1，这使得AVL树在插入和删除操作后能够快速恢复平衡，从而保证...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2711
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
用python实现AVL树、B树、红黑树的插入、查找和删除操作
10-16
插入操作会涉及旋转操作，包括左旋、右旋、双旋等，以保持树的平衡。 接下来是B树，B树是一种多路搜索树，适用于大型数据库和文件系统。B树的每个节点可以有多个子节点，且包含部分关键字和对应的指针。插入、查找...
AVL树的旋转和插入
DragonBark的博客
01-16 367
包含了AVL树的单旋转和双旋转的算法，以及AVL树的递归插入和非递归插入算法。单旋转也叫“一”字形旋转，又可分为左-左型旋转和右-右型旋转；双旋转也叫“之”字形旋转，又可分为左-右型旋转和右-左型旋转。 #includeiostream> #includestack> using namespace std; class AVLNode{ public: int element;
平衡二叉树（AVL）插入以及相关旋转大法
qq_63786973的博客
06-03 582
例如下图思考： 我们知道一般树的相关操作通常 为 O(logn)，AVL 也一样，不同的是 AVL 的 插入 操作有些奇特： 插入一个节点可能破坏其特性，那么我们如何来完成对特性的修复呢？方法：旋转大法​ 我们把必须重新平衡的节点称之为 α 。对于任意二叉树的节点来说，每个节点至多有两个孩子，故当插入一个新的节点，高度不平衡的情形为 左右子树高度差 为 2，容易看出分为以下四种情形：可以看出，上述情形 两两呈镜面对称。​ 如图，插入节点后， 节点 k2 的 左子树的深度 比 右子树的深度 多 2 层，为
avl树
牛逼！
12-30 206
简述 二叉搜索树的最坏情况下搜索的时间复杂度可能达到O(n)，avl树在普通的二叉搜索树的基础上加入了自动平衡的特性，其左子树与右子树的高度差的绝对值不大于2，且左子树与右子树也是一棵avl树 旋转 avl树进行插入或者删除后，通过旋转来满足平衡性质 总共有4种情况需要旋转 LL: 左孩子的左子树进行了插入导致了不平衡，此时需要右旋 RR:右孩子的右子树进行了插入导致了不平衡，此时需要左旋 LR:左孩子的右子树进行了插入，此时需要先左旋再右旋 RL:右孩子的左子树进行了插入，此时需要先右旋再左旋 代码实
C语言实现平衡二叉搜索树：AVL树旋转操作
这些旋转操作是平衡二叉树（如AVL树）的关键，它们确保了在插入或删除操作后，树仍然保持平衡。 虽然这里没有给出完整的代码，但可以看出，这些函数是构建AVL树平衡调整算法的基础。在实际的AVL树实现中，还需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值