进一步理解平衡二叉树(插入)

最新推荐文章于 2022-06-08 11:16:26 发布
最新推荐文章于 2022-06-08 11:16:26 发布
阅读量3.8k 收藏 23
点赞数 4
分类专栏： C++ 文章标签： 数据结构 平衡二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57023347/article/details/120083222
版权

目录

前言

一.平衡二叉树的概念

 二.平衡二叉树的实现

 2.1 平衡二叉树结点的定义

 2.2 平衡二叉树的插入

        2.2.1按照二叉搜索树的方式插入新结点

                2.2.2 更新平衡因子

                2.2.3 旋转 

 2.3 平衡二叉树的验证

 2.4 总代码

 2.5 平衡二叉树的删除

前言

        前面我们了解了二叉搜索树，也进行了对二叉搜索树的简单实现。但是二叉搜索树存在一个缺陷。

        当要在搜索树里插入或者删除数据时，都需要进行查找。查找体现了搜索树的效率。当插入二叉树搜索树的集合是一个有序序列时，二叉搜索树会形成一个单支树。变成一个链状结构，这样查找的效率大大降低，最坏情况下，查找的效率为O(N)。并没有很好的体现出搜索树的性质。

        而平衡二叉树就很好的体现出了搜索树的性质，查找的效率是树的高度次，最坏的情况下查找的效率是O(logN)。

        下面就来详细介绍是如何实现平衡二叉树的。

一.平衡二叉树的概念

        首先一颗平衡二叉树必须是一颗二叉搜索树。二叉树搜索树的所有性质都符合平衡二叉树。另外平衡二叉树还具有一下性质：

  1. 左右子树的高度差(简称平衡因子)的绝对值不超过1(-1/0/1)。
  2. 左右子树也都是平衡二叉树。

这里引出来一个平衡因子的概念：平衡因子是平衡二叉树的高度差。

        计算公式为：平衡因子 = 右子树子树的高度 - 左子树子树的高度。(注意是子树的高度)

例如：

        根据上面的概念，如果一颗二叉搜索树是高度平衡的，即平衡因子绝对值小于等于1，这棵树就是平衡二叉树。如果右n个结点，搜索时的时间复杂度就是O(logN)。

 二.平衡二叉树的实现

        2.1 平衡二叉树结点的定义

//二叉树应用KV模型
template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(const pair<K, V> kv)
	:_left(nullptr)
	, _right(nullptr)
	, _parent(nullptr)
	,_bf(0)
	, _kv(kv)
	{}

	AVLTreeNode *_left;//该节点的左孩子
	AVLTreeNode *_right;//该节点的右孩子
	AVLTreeNode *_parent;//该节点的父亲
	//平衡因子
	int _bf;
	//保存的是键值对，pair结构体
	pair<K, V> _kv;
};

 实现的这颗平衡二叉树是KV模型的，二叉树是按照键值对<key,value>的键值key来建树的，一个键值key对应一个value。

每个结点了处理右左右结点指针和键值对外，还增加了父指针和平衡因子。父指针是为了更方便更新平衡因子，平衡因子是用来判断该节点是否平衡。

注意平衡因子不是必须的，可以直接求结点左右子树的高度，在求差值。

        2.2 平衡二叉树的插入

         平衡二叉树也是一颗二叉搜索树，插入也要利用二叉搜索树的性质进行插入。只是需要在此基础上还需要更新结点的平衡因子，检测结点的平衡因子，遇到不符合条件的需要旋转处理。

        所以要实现平衡二叉树的插入步骤是：

  1. 按照二叉搜索树的方式插入新节点
  2. 更新结点的平衡因子。更新完该节点的平衡因子后，需要检测该节点的平衡因子。如果平衡因子绝对值小于等于1，再判断是否需要继续往上更新结点平衡因子。如果平衡因子绝对值大于等于2，旋转处理。

        2.2.1按照二叉搜索树的方式插入新结点

        这个只需要按照二叉搜索树的性质，如果插入结点的键值key大于当前结点键值，往右子树走，如果插入结点的键值key小于当前结点的键值，往左子树走。如果插入结点的键值key等于当前结点键值，说明已存在，插入失败。

        注意：插入结点是以叶子结点插入的。还要注意更新父节点。

        //空结点，根节点就是新插入结点
        if (_root == nullptr){
			_root = new Node(kv);
			return true;
		}
		Node *cur = _root;
		Node *parent = nullptr;
		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);
		//要更新父节点
		cur->_parent = parent;
        //判断插入父节点的左边还是右边
		if (parent->_kv.first < kv.first){
			
			parent->_right = cur;
		}
		else{
			
			parent->_left = cur;
		}

  2.2.2 更新平衡因子

        注意：插入一个结点，只会影响当前结点父节点，或者说是祖先结点的平衡因子。但是并不会影响全部的父节点或者祖先结点。所以更新平衡因子从下往上更新。

比如说：

  •  如何更新平衡因子呢？

        在结点更新时，是从插入节点一直向父节点更新的。从下往上更新。

如图：

         由平衡因子的定义，由上图，我们可以得到。

        当cur是parent的左节点时，parent的平衡因子减1，

        当cur是parent的右节点时，parent的平衡因子加1。

  • 检测更新完结点的平衡因子

        更新完的平衡因子会有一下三种情况。

  1. 更新完后，结点(parent结点)的平衡因子等于0。说明结点(parent结点)的高度没有变化，并不会对上面结点的平衡因子产生影响。不需要继续往上更新。
  2. 更新完后，结点(parent结点)的平衡因子等于1或者-1。说明当前结点(parent结点)高度加1了，但是还没有超过平衡的界限，会对上面的结点产生影响。继续往上更新。
  3. 更新完后，结点(parent结点)的平衡因子等于2或者-2。超过了平衡的界限，需要进行旋转处理。

由于旋转后平衡因子会在界限范围内，所以只有上面三种情况。

2.2.3 旋转 

旋转要注意两点，一点是旋转完后仍然是搜索树，二是每个结点都需要平衡。

 平衡二叉树的旋转有四种情况：

  • 右单旋

在什么情况下使用右单旋？

        看平衡破坏结点到插入方向的连续3个结点，如果是一条直线用单旋，如果更新到parent结点的平衡因子等于-2，且cur的平衡因子等于-1时，需要用右单旋。

 怎样实现右单旋？

情况是这样的：所有右单旋情况都适用

        根据上图，我们知道，右单旋是将结点5的左指针指向结点3的右子树，结点3的右指针指向结点5。

为什么将结点5的左指针指向结点3的右子树？

为了保持树是搜索树，结点3的右结点值大于3，小于5，右单旋后，需要结点3的右指针指向结点5，所以需要将结点5的左指针指向结点3的右子树。

但是不仅仅是这么简单，还需要更新父节点和平衡因子。我们发现此时受影响结点的平衡因子都是0。

在旋转过程中还需要几种情况需要考虑：

  1. 结点3的右子树可能是空树，也可能不是空树
  2. 结点5可能是根节点。也可能上面还有父节点，是一颗子树。如果是根节点，要更新根节点。如果是子树，可能是某个节点的左子树或者右子树。

	void SigelRight(Node *parent){
        //先将所有要用到的结点记录
		Node *SubL = parent->_left;
		Node *SubLR = SubL->_right;

		Node *Pparent = parent->_parent;
        //更新SubLR结点
		parent->_left = SubLR;
        //注意可能为空的情况
		if (SubLR){
			SubLR->_parent = parent;
		}
        //更新parent
		SubL->_right = parent;
		parent->_parent = SubL;
        
		if (Pparent == nullptr)//根节点，不是子树
		{
			
			SubL->_parent = nullptr;
            //更新根节点
			_root = SubL;
		}
		else//子树
		{
            //判断插入左边还是右边
			if (Pparent->_kv.first > SubL->_kv.first){
				Pparent->_left = SubL;
			}
			else{
				Pparent->_right = SubL;
			}
			SubL->_parent = Pparent;
		}
        //更新平衡因子
		SubL->_bf = 0;
		parent->_bf = 0;
	}
  • 左单旋

在什么情况下使用左单旋？

        看平衡破坏结点到插入方向的连续3个结点，如果是一条直线用单旋。如果更新到parent结点的平衡因子等于2，且cur的平衡因子等于1时，需要用左单旋。

 怎么实现左单旋？

        左单旋的实现和右单旋转的实现异曲同工，只是方向不同。

情况如下：一般化(适用所有情况)

  根据上图，我们知道，左单旋是将结点5的右指针指向结点6的左子树，结点6的左指针指向结点5。

为什么结点5的右指针指向结点6的左子树？

因为平衡二叉树仍然是一颗搜索树，结点6的左结点值小于6，大于5，左单旋后，需要结点6的左指针指向结点5，所以需要将结点5的右指针指向结点6的左子树。

注意更新父指针和平衡因子。我们发现此时受影响结点的平衡因子都是0。

在旋转过程中还需要几种情况需要考虑：

  1. 结点6的左子树可能是空树，也可能不是空树
  2. 结点5可能是根节点。也可能上面还有父节点，是一颗子树。如果是根节点，要更新根节点。如果是子树，可能是某个节点的左子树或者右子树。

void SigelLeft(Node *parent){
		//保持所有用到的结点
		Node *SubR = parent->_right;
		Node *SubRL = SubR->_left;
		//用来判断当前子树是否是子树
		Node *Pparent = parent->_parent;
		//注意要更新父节点
		parent->_right = SubRL;
		//
		if (SubRL){
			SubRL->_parent = parent;
		}

		SubR->_left = parent;
		parent->_parent = SubR;

		//更新新根节点SubR的父节点
		if (Pparent == nullptr){//当前结点为根节点
			//直接置空
			SubR->_parent = nullptr;
			//注意要更新根节点
			_root = SubR;
		}
		else{//当前树为子树
			//连接到上面结点
			if (Pparent->_kv.first < SubR->_kv.first){
				Pparent->_right = SubR;
				
			}
			else{
				Pparent->_left = SubR;
			}

			//更新父节点
			SubR->_parent = Pparent;
		}
		//更新平衡因子
		SubR->_bf = 0;
		parent->_bf = 0;
	}
  •  右左双旋

什么情况下用右左双旋？

        看平衡破坏结点到插入方向的连续3个结点，如果是一条折线用双旋。更新完后当前结点(parent结点)的平衡因子等于2，右节点(cur结点)等于-1时，用右左双旋。

 怎么实现右左双旋？

这时有两种情况会导致平衡因子的更新不同

情况1：

在SubRL左子树插入结点

        通过上图，先将parent的右结点SubrR先右单旋，再将parent结点左单旋，即可得到平衡的二叉树。

        此时子树b，成为了parent的右子树，子树c成为了SubR的左子树，parent的平衡因子等于0 ，SubR的平衡因子等于1。

情况二：

在SubRL右子树插入结点

         通过上图，先将parent的右结点SubR先右单旋，再将parent结点左单旋，即可得到平衡的二叉树。

        此时子树b，成为了parent的右子树，子树c成为了SubR的左子树，parent的平衡因子等于-1 ，SubR的平衡因子等于0。

总结：

        右左双旋：先将parent的右子树右单旋，再将parent所在子树左单旋。

        当插入结点在SubRL的左子树时SubRL平衡因子为-1时：parent的平衡因子等于0 ，SubR的平衡因子等于1。

        当插入结点在SubRL的右子树SubRL平衡因子为1时：parent的平衡因子等于-1 ，SubR的平衡因子等于0。

void DoubleRightLeft(Node *parent){
		Node *SubR = parent->_right;
		Node *SubRL = SubR->_left;

		//为了后面更新平衡因子，看插入左边还是右边
		int bf = SubRL->_bf;

		SigelRight(SubR);

		SigelLeft(parent);
		//画图理解,更新平衡因子
		if (bf == 1){//插入方向在右边
			SubR->_bf = 0;
			SubRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1){//插入方向在左边
			SubRL ->_bf= 0;
			parent->_bf = 0;
			SubR->_bf = 1;
		}
		else if (bf == 0){//SubRL就是插入结点
			SubR->_bf = 0;
			SubRL->_bf = 0;
			parent->_bf = 0;
		}
	}
  • 左右双旋

什么情况下用左右双旋？

        看平衡破坏结点到插入方向的连续3个结点，如果是一条折线用双旋。更新完后当前结点(parent结点)的平衡因子等于-2，右节点(cur结点)等于1时，用左右双旋。

怎么实现左右双旋？

这时有两种情况会导致平衡因子的更新不同

情况1：

         通过上图，先将parent的左结点SubL先左单旋，再将parent结点右单旋，即可得到平衡的二叉树。

        此时子树b，成为了SubL的右子树，子树c成为了parent的左子树，parent的平衡因子等于1 ，SubL的平衡因子等于0。

情况二：

         通过上图，先将parent的左结点SubL先左单旋，再将parent结点右单旋，即可得到平衡的二叉树。

        此时子树b，成为了SubL的右子树，子树c成为了parent的左子树，parent的平衡因子等于0 ，SubL的平衡因子等于-1。

总结：

        左右单旋：先将parent的左结点所在子树左单旋，在将parent所在子树右单旋。

        当插入结点在SubLR的左子树时SubLR平衡因子为-1时：parent的平衡因子等于1，SubL的平衡因子等于0。

        当插入结点在SubLR的右子树SubLR平衡因子为1时：parent的平衡因子等于0 ，SubR的平衡因子等于-1。

void DoubleLeftRight(Node *parent){
		Node *SubL = parent->_left;
		Node *SubLR = SubL->_right;

		int bf = SubLR->_bf;

		SigelLeft(SubL);

		SigelRight(parent);

		if (bf == 1){
			SubL->_bf = -1;
			parent->_bf = 0;
			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;
		}
	}

 2.3 平衡二叉树的验证

  • 每个结点的高度差(右子树高度-左子树高度)绝对值不超过1。
  • 平衡因子等于高度差值。
    int _Height(Node *root){
		if (root == nullptr){
			return 0;
		}
		int left = _Height(root->_left);
		int right = _Height(root->_right);

		return left > right ? left + 1 : right + 1;
	}
    bool _IsBalanceTree(Node *pRoot)
	{

		// 空树也是AVL树
		if (nullptr == pRoot) 
            return true;

		// 计算pRoot节点的平衡因子：即pRoot左右子树的高度差
		int leftHeight = _Height(pRoot->_left);
		int rightHeight = _Height(pRoot->_right);
		int diff = rightHeight - leftHeight;

		// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
		// pRoot平衡因子的绝对值超过1，则一定不是AVL树
		if (diff != pRoot->_bf || (diff > 1 || diff < -1))
			return false;
		// pRoot的左和右如果都是AVL树，则该树一定是AVL树
		return _IsBalanceTree(pRoot->_left) && _IsBalanceTree(pRoot->_right);
	}

 2.4 总代码

#pragma once
#include<iostream>
using namespace std;

//二叉树应用KV模型
template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(const pair<K, V> kv)
	:_left(nullptr)
	, _right(nullptr)
	, _parent(nullptr)
	,_bf(0)
	, _kv(kv)
	{}

	AVLTreeNode *_left;//该节点的左孩子
	AVLTreeNode *_right;//该节点的右孩子
	AVLTreeNode *_parent;//该节点的父亲
	//平衡因子
	int _bf;
	//保存的是键值对，pair结构体
	pair<K, V> _kv;
};

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);
			return true;
		}
		Node *cur = _root;
		Node *parent = nullptr;
		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);
		//要更新父节点
		cur->_parent = parent;
		if (parent->_kv.first < kv.first){
			
			parent->_right = cur;
		}
		else{
			
			parent->_left = cur;
		}

		//更新平衡因子
		while (parent){
			//如果插入左边平衡因子--
			if (parent->_left == cur){
				parent->_bf--;
			}
			//如果插入右边，平衡因子++
			else{
				parent->_bf++;
			}

			//判断平衡因子
			if (parent->_bf == 0){//如果parent位置平衡因子等于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){
					SigelLeft(parent);//左单旋
				}
				else if (parent->_bf == 2 && cur->_bf == -1){
					DoubleRightLeft(parent);//右左双旋
				}
				else if (parent->_bf == -2 && cur->_bf == 1){
					DoubleLeftRight(parent);//左右双旋
				}
				else if (parent->_bf == -2 && cur->_bf == -1){
					SigelRight(parent);//右单旋
				}
				break;//旋转完不需要更新平衡因子了。

			}
			else{
				
			}
		}
		return true;


	}
	void SigelLeft(Node *parent){
		//保持所有用到的结点
		Node *SubR = parent->_right;
		Node *SubRL = SubR->_left;
		//用来判断当前子树是否是子树
		Node *Pparent = parent->_parent;
		//注意要更新父节点
		parent->_right = SubRL;
		//
		if (SubRL){
			SubRL->_parent = parent;
		}

		SubR->_left = parent;
		parent->_parent = SubR;

		//更新新根节点SubR的父节点
		if (Pparent == nullptr){//当前结点为根节点
			//直接置空
			SubR->_parent = nullptr;
			//注意要更新根节点
			_root = SubR;
		}
		else{//当前树为子树
			//连接到上面结点
			if (Pparent->_kv.first < SubR->_kv.first){
				Pparent->_right = SubR;
				
			}
			else{
				Pparent->_left = SubR;
			}

			//更新父节点
			SubR->_parent = Pparent;
		}
		//更新平衡因子
		SubR->_bf = 0;
		parent->_bf = 0;
	}

	void SigelRight(Node *parent){
		Node *SubL = parent->_left;
		Node *SubLR = SubL->_right;

		Node *Pparent = parent->_parent;

		parent->_left = SubLR;
		if (SubLR){
			SubLR->_parent = parent;
		}

		SubL->_right = parent;
		parent->_parent = SubL;

		if (Pparent == nullptr)//根节点
		{
			
			SubL->_parent = nullptr;
			_root = SubL;
		}
		else//子树
		{
			if (Pparent->_kv.first > SubL->_kv.first){
				Pparent->_left = SubL;
			}
			else{
				Pparent->_right = SubL;
			}
			SubL->_parent = Pparent;
		}

		SubL->_bf = 0;
		parent->_bf = 0;
	}

	void DoubleRightLeft(Node *parent){
		Node *SubR = parent->_right;
		Node *SubRL = SubR->_left;

		//为了后面更新平衡因子，看插入左边还是右边
		int bf = SubRL->_bf;

		SigelRight(SubR);

		SigelLeft(parent);
		//画图理解,更新平衡因子
		if (bf == 1){//插入方向在右边
			SubR->_bf = 0;
			SubRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1){//插入方向在左边
			SubRL ->_bf= 0;
			parent->_bf = 0;
			SubR->_bf = 1;
		}
		else if (bf == 0){//SubRL就是插入结点
			SubR->_bf = 0;
			SubRL->_bf = 0;
			parent->_bf = 0;
		}
	}

	void DoubleLeftRight(Node *parent){
		Node *SubL = parent->_left;
		Node *SubLR = SubL->_right;

		int bf = SubLR->_bf;

		SigelLeft(SubL);

		SigelRight(parent);

		if (bf == 1){
			SubL->_bf = -1;
			parent->_bf = 0;
			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;
		}
	}

	int _Height(Node *root){
		if (root == nullptr){
			return 0;
		}
		int left = _Height(root->_left);
		int right = _Height(root->_right);

		return left > right ? left + 1 : right + 1;
	}


	//int _Height(PNode pRoot);
	bool _IsBalanceTree(Node *pRoot)
	{


		// 空树也是AVL树
		if (nullptr == pRoot) return true;
		// 计算pRoot节点的平衡因子：即pRoot左右子树的高度差
		int leftHeight = _Height(pRoot->_left);
		int rightHeight = _Height(pRoot->_right);
		int diff = rightHeight - leftHeight;
		// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
		// pRoot平衡因子的绝对值超过1，则一定不是AVL树
		if (diff != pRoot->_bf || (diff > 1 || diff < -1))
			return false;
		// pRoot的左和右如果都是AVL树，则该树一定是AVL树
		return _IsBalanceTree(pRoot->_left) && _IsBalanceTree(pRoot->_right);
	}

	bool Isbalance(){
		return _IsBalanceTree(_root);
	}

private:
	Node *_root = nullptr;
};

 2.5 平衡二叉树的删除

        平衡二叉树的删除，和插入如出一辙。

        首先平衡二叉树也是二叉搜索树，也是先按照二叉搜索树的方式进行删除，然后更新平衡因子，判断平衡因子是否符合条件。

  • 按照二叉搜索树的方式进行删除
  • 更新平衡因子，判断平衡因子。如果符合条件，在判断是否继续往上更新，如果不符合，旋转处理。

和插入不同的是，更新平衡因子时，

        parent->_left==cur时，parent->_bf++

        parent->_right==cur时，parent->_bf--

 后面会附上代码：

两片空白
关注
  • 4
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Leetcode]-701. 二叉搜索树中的插入操作(二叉树）
m0_38100278的博客
09-30 298
题目： 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。 思路： 二叉搜索树（BST）定义，判断插入值应在根节点的左树或右树， 不断递归，直到找到符合条件的空节点 解答: /** * Definition for a binary tree node. * public clas
二叉树——二叉搜索树中的插入操作
ljh5930的博客
03-01 917
给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。返回插入后二叉搜索树的根节点。输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。你可以返回 任意有效的结果。
【二叉树】二叉搜索树中的插入操作
豪冷的博客
06-08 706
题目 给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value 将值插入二叉搜索树 返回插入后二叉搜索树的根节点 输入数据保证 新值和原始二叉搜索树中的任意节点值都不同 注意，可能存在多种有效的插入方式 只要树在插入后仍保持为二叉搜索树即可 你可以返回任意有效的结果...
数据结构 —— 图解AVL树(平衡二叉树)插入节点的变化
猎人在吃肉
07-28 2346
文章目录示例1示例2参考文章： 示例1 初始状态如下： 然后我们插入数值： 1、4、5、6、7、10、9、8 1.1、插入 1： 插入1后，节点3失去平衡，是左-左型，需要右旋调整： 1.2、插入4： 1.3、继续插入 5 ： 插入5后，节点2、3失去平衡，是右-右型，左旋转： 1.4、继续插入6 ： 插入5后，节点2、3失去平衡，变成右-右型，需要进行左旋： 1.5、继续插入7...
平衡二叉树详解 通俗易懂
热门推荐
半亩方糖
01-10 12万+
平衡二叉树（AVL） 阅读之前请先了解 二叉搜索树 平衡二叉树定义：任意节点的子树的高度差都小于等于 1 1. 为什么使用「平衡二叉树」 二叉树能提高查询的效率 O(logn)，但是当你插入 {1,2,3,4,5,6} 这种数据的时候，你的二叉树就像一个「链表」一样，搜索效率变为 O(n) 于是在 1962 年，一个姓 AV 的大佬（G. M. Adelson-Velsky） 和一个姓 L 的大佬（ Evgenii Landis）提出「平衡二叉树」（AVL） 。 于是插入 {1,2,3,4,5,6}
二叉树-基于C++实现的平衡二叉树.zip
最新发布
04-26
本压缩包文件“二叉树-基于C++实现的平衡二叉树.zip”包含了一个关于使用C++编程语言实现平衡二叉树的实例，这对于我们理解平衡二叉树的原理和实际操作至关重要。 平衡二叉树（Balanced Binary Tree）是一种特殊的...
平衡二叉树的实现实例
09-04
平衡二叉树是一种特殊的二叉树结构，它的特点是任何节点的两个子树的高度差不超过1，这确保了在平衡二叉树中查找、插入和删除操作的时间复杂度为O(log n)。平衡二叉树的主要类型包括AVL树和红黑树等。 在这个实现...
平衡二叉树数据结构课程设计
12-15
平衡二叉树是一种特殊的二叉树数据结构，它在保持二叉查找树特性的同时，通过...通过这个课程设计，你将不仅掌握平衡二叉树的理论知识，还能具备实际操作和优化的能力，这对于进一步的软件开发和算法研究非常有帮助。
平衡二叉树
01-04
通过对比不同排序方法的时间消耗，可以更好地理解平衡二叉树在数据处理中的优势。 总的来说，平衡二叉树是数据结构中的一个重要概念，它的设计目标是优化查找性能，尽管在某些方面牺牲了存储效率。通过不断调整保持...
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
11-13
平衡二叉树是一种特殊的二叉搜索树，它的左右子树的高度差不超过1，从而保证了树的平衡性，进一步提高了查找、插入和删除操作的效率。 平衡二叉树的主要类型有AVL树和红黑树等。AVL树是最早被提出的自平衡二叉搜索...
C语言实现二叉树的创建、插入、删除、遍历等操作
05-28
二叉树的先序、中序、后续、计算叶子节点和树的深度的源代码，计算度为0,1,2的节点个数。 包括排序二叉树的实现
数据结构--平衡二叉树的插入详解
sayhello_world的博客
04-18 1764
平衡二叉树（AVLTree）： 平衡二叉树具有以下性质： 1.它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 2.这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。 3.频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。
平衡二叉树(AVL树)详细解析-通俗易懂
三千炼心的博客
12-20 3083
平衡二叉树定义:二叉排序树的平衡因子绝对值小于等于1，即平衡因子为-1、0、1,那么是平衡二叉树（平衡因子：根结点的左子树深度减右子树深度的差）。 最小不平衡子树：子树的根结点距离插入结点距离最近，且平衡因子绝对值大于1的树为最小不平衡子树。 平衡二叉树：当插入结点后出现最小不平衡子树，那么就要对最小不平衡子树重新构造，通过顺时针（平衡因子皆为正）或逆时针（平衡因子皆为负）旋转最小不平衡子树的根结...
【数据结构】平衡二叉树的插入、删除
fxkcsdn的博客
08-14 3万+
目录 定义：什么叫平衡二叉树 定义及原理 不平衡的四种情况 旋转操作 插入节点 删除节点 定义：什么叫平衡二叉树 是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一...
【数据结构】平衡二叉树AVLtree
SWELER的博客
05-29 185
基本概念 一般来说（如图1），二叉查找树的查找操作的时间复杂度为O（log2（n））但是，如果我们每次插入数据都在二叉树的一侧（如图2），那么二叉查找树就会退化成一个链表，查找操作的时间复杂度为O（n）。如何避免这种情况？需要在每次插入后从下往上逐个调整树的结构。图示是其中一种调节方法，经过调节后，根节点的两边子树高度差不会超过1，查找效率大大提高。 代码实现 和普通二叉树类似的，每个树节点都包含一个数据元素，一个左子树和一个右子树，另外还需要一个记录此树高度的数据height。 typedef int
平衡二叉树的插入调整
I'm George 的博客
07-17 1632
图详解平衡二叉树的插入调整过程
平衡二叉树的插入与删除
pjmike的博客
08-09 8991
定义 AVL树是带有平衡条件的二叉查找树。它要求在AVL树中任何节点的两个子树的高度(高度是指节点到一片树叶的最长路径的长) 最大差别为1,如下图所示: 为什么有AVL树 大多数BST操作，例如搜索，最大，最小，插入，删除等，消耗取O（h）时间，h是BST的高度。对于倾斜的二叉树，这些操作的成本可能会变成O(n)。 如果我们在每次插入和删除之后确保树的高度保持O（Logn），那么我...
二叉树结点深度及平衡因子计算算法
weixin_43213382的博客
05-25 5743
从下往上开始计算每个结点的深度及平衡因子。 #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 typedef int Status; typedef struct Node { int data; int bf; int depth; struct N...
平衡二叉树的插入
weixin_52530507的博客
12-04 123
int Max(int a, int b){ if(a>b) return a; else return b; } int GetHeight(AVLTree A){ if(A==NULL) return 0; return A->Height; } AVLTree LeftRotate(AVLTree A){ AVLTree B=A->Right; A->Right=B->Left
leetcode 二叉树-1
02-09
关于 leetcode 二叉树的算法系列-1

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值