AVL树（高度平衡二叉搜索树）基本原理及简单实现

于 2023-05-31 14:37:34 发布
阅读量121 收藏
点赞数
文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59535638/article/details/130964421
版权

目录

一.AVL树的性质

二.AVL树的节点定义

三.AVL树的插入

1.按照二叉搜索树的方式插入新节点

2.调整节点的平衡因子

四.AVL树的旋转处理

1.新节点插入到较高右子树的右边---右右，进行左单旋

 2.新节点插入到较高左子树的左侧---左左，进行右单旋

 3.新节点插入到较高左子树的右侧--左右，先进行左单旋，再进行右单旋

4.新节点插入到较高右子树的左侧---右左，先进行右单旋，再进行左单旋

五.AVL树简单实现的整体代码

一.AVL树的性质

1.它的左右子树都是AVL树

2.左右子树高度之差（简称平衡因子）的绝对值不超过1（-1/0/1）

如果一颗二叉搜索树是高度平衡的，它就是AVL树。假设它的节点数为n，其高度可保持在\log_2 n,搜索时间复杂度为O（\log_2 n）。

二.AVL树的节点定义

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

};

三.AVL树的插入

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

1.按照二叉搜索树的方式插入新节点

2.调整节点的平衡因子

而在这两点中，更新平衡因子尤为重要，其详细过程课分为以下几点

①.当新增节点在右时，parent->_bf需要+1，新增节点在左时，parent->_bf需要-1。

②.更新后，parent->_bf == 1 or -1,说明parent插入前的平衡因子为0，说明原左右子树高度相等，插入后有一边子树变高，此时改变了parent的高度，便需要往上继续更新平衡因子。

③.更新后，parent->_bf == 0，说明parent插入前的平衡因子为 1 or -1，说明左右子树一边高一边低，插入后两边变为一样高度，parent所在子树高度不变，不需要继续向上面的节点更新平衡因子。

④.更新后，parent->_bf == 2 or -2,说明parent插入前的平衡因子为 1 or -1，此时原左右子树已经存在一边高一边低的情况，继续插入的节点导致parent的平衡因子变为 2 or -2，平衡被打破，则parent所在子树需要旋转处理。

⑤.更新后，parent->_bf > 2 or parent->_bf < -2的值，存在这种情况，说明在插入前的就已经不是AVL树，需要检查之前的树。

下图将简略描述以上几点：

对于第四点旋转处理将在下方详细介绍。

四.AVL树的旋转处理

AVL树的旋转处理又分为四种。

1.新节点插入到较高右子树的右边---右右，进行左单旋

 

通过上图发现当对较高右子树的右边进行插入时，向上更新平衡因子，造成parent节点平衡因子变为2，此时需要进行旋转处理，来降低右子树的高度来达到新的平衡，可以看出将60节点变为新的parent节点，再将b子树链接到30节点的右边，便可以达到新的平衡。

具体左旋代码如下：

void RotateL(Node* parent)
	{	
		//记父节点的右为subR
		//subR的左为subRL
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		//将父节点与subRL进行链接
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
		//记parent节点的上一级节点为ppNode（方便更新平衡因子）
		Node* ppNode = parent->_parent;
		//继续链接
		subR->_left = parent;
		parent->_parent = subR;
		//原parent节点为根节点的情况
		if (_root == subR)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else  //原parent节点为一棵子树
		{	
			//将subR与原parent的上层节点进行链接
			//链接到左
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else //链接到右
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
		subR->_bf = parent->_bf = 0;
	}

 2.新节点插入到较高左子树的左侧---左左，进行右单旋

 通过上图发现当对较高左子树的左边进行插入时，向上更新平衡因子，造成parent节点平衡因子变为-2，此时需要进行旋转处理，来降低左子树的高度来达到新的平衡，可以看出将30节点变为新的parent节点，再将b子树链接到60节点的左边，便可以达到新的平衡。

具体左旋代码如下：

void RotateR(Node* parent)
	{	
		//记父节点的左为subL
		//subL的右为subLR
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		//将subLR与父节点的进行链接
		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		//记parent节点的上一级节点为ppNode（方便更新平衡因子）
		Node* ppNode = parent->_parent;
		//继续链接
		subL->_right = parent;
		parent->_parent = subL;
		//原parent节点为根节点的情况
		if (_root == parent)
		{	
			_root = subL;
			subL->_parent = nullptr;
		}
		else //原parent节点为一棵子树
		{	
			//将subL与原parent的上层节点进行链接
			//链接到左
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else //连接到右
			{
				ppNode->_right = subL;
			}
		}
		//更新平衡因子
		subL->_bf = parent->_bf = 0; 
	}

 3.新节点插入到较高左子树的右侧--左右，先进行左单旋，再进行右单旋

 

而左右双旋又可以分为三种情况（便于调整平衡因子），以上图为例。

1.b插入新增节点，引发双旋。（图中情况）

2.c插入新增节点，引发双选。

3.a/b/c/d为空树，60即为新增节点，引发双旋。

双旋的过程与单旋并没有什么区别，因此可以复用单旋的代码，需要注意的是对平衡因子的调整。

具体左右双旋代码如下：

void RotateLR(Node* parent)
	{	
		//记父节点的左为subL
		//subL的右为subLR
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		//记录subLR的平衡因子，方便针对插入节点的情况，进行平衡因子的调整
		int bf = subLR->_bf;
		//左单旋
		RotateL(parent->_left);
		//右单旋
		RotateLR(parent);

		//双旋过后subLR平衡因子为0
		subLR->_bf = 0;
		//对父节点和subL平衡因子进行调整的三种情况
		//新增节点在subLR的右
		if (bf == 1)
		{	
			parent->_bf = 0;
			subL->_bf = -1;
		}
		//新增节点在subLR的左
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
		}
		//该节点即为新增节点
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

4.新节点插入到较高右子树的左侧---右左，先进行右单旋，再进行左单旋

 

同样右左双旋也可以分为三种情况（便于调整平衡因子），以上图为例。

1.b插入新增节点，引发双旋。

2.c插入新增节点，引发双选。（图中情况）

3.a/b/c/d为空树，60即为新增节点，引发双旋。

双旋的过程与单旋并没有什么区别，因此可以复用单旋的代码，需要注意的是对平衡因子的调整。

具体右左双旋的代码如下：

void RotateRL(Node* parent)
	{	
		//记父节点的右为subR
		//subR的左为subRL
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		//记录subRL的平衡因子，方便针对插入节点的情况，进行平衡因子的调整
		int bf = subRL->_bf;
		//右单旋
		RotateR(parent->_right);
		//左单旋
		RotateL(parent);
		
		//双旋后subRL的平衡因子为0
		subRL->_bf = 0;
		//对父节点和subR平衡因子进行调整的三种情况
		//新增节点在subRL的右
		if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
		}
		//新增节点在subRL的左
		else if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
		}
		//该节点即为新增节点
		else if (bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

五.AVL树简单实现的整体代码

#pragma once
#include<iostream>
#include <map>
#include <string>
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>
struct AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{	
		//原树无节点，直接在根插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			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;
			}
		}
			//在子树插入
			cur = new Node(kv);
			if (parent->_kv.first < kv.first)
			{
				parent->_right = cur;
			}
			else // (parent->_kv.first > kv.first)
			{
				parent->_left = cur;
			}

			cur->_parent = parent;

			//控制平衡
			//更新平衡因子
			while (parent)
			{
				if (cur = parent->_right)
				{
					parent->_bf++
				}
				else //(cur = parent->left)
				{
					parent->_bf--;
				}

				if (parent->_bf == 0)
				{
					break;
				}
				else if (abs(parent->_bf) == 1)   //向上调整
				{
					parent = parent->_parent;
					cur = cur->_parent;
				}
				else if (abs(parent->_bf) == 2) //说明此时parent所在子树已不平衡,需要进行旋转平衡
				{
					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)
					{
						RotateLR(parent);
					}
					else if (parent->_bf == 2 && cur->_bf == -1)
					{
						RotateRL(parent);
					}
					else
					{
						assert(false);
					}
					break;
				}
				else
				{
					assert(false);
				}
			}
		return true;
	}

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

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	//计算高度
	int Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
	//递归累加
		return max(Height(root->_left), Height(root->_right)) + 1;
	}
	//判断是否平衡
	bool _IsBalance(Node* root)
	{	
		//空树平衡
		if (root == nullptr)
		{
			return true;
		}
		//递归找左子树高度
		int leftHt = Height(root->_left);
		//递归找右子树高度
		int rightHt = Height(root->_right);
		//查看平衡因子是否在（-1/0/1）的范围
		int diff = rightHt - leftHt;
		if (diff != root->_bf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
		//递归找左子树是否异常和递归找右子树是否异常
		return abs(diff) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right)
	}


	void RotateL(Node* parent)
	{	
		//记父节点的右为subR
		//subR的左为subRL
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		//将父节点与subRL进行链接
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
		//记parent节点的上一级节点为ppNode（方便更新平衡因子）
		Node* ppNode = parent->_parent;
		//继续链接
		subR->_left = parent;
		parent->_parent = subR;
		//原parent节点为根节点的情况
		if (_root == subR)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else  //原parent节点为一棵子树
		{	
			//将subR与原parent的上层节点进行链接
			//链接到左
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else //链接到右
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
		subR->_bf = parent->_bf = 0;
	}

	void RotateR(Node* parent)
	{	
		//记父节点的左为subL
		//subL的右为subLR
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		//将subLR与父节点的进行链接
		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		//记parent节点的上一级节点为ppNode（方便更新平衡因子）
		Node* ppNode = parent->_parent;
		//继续链接
		subL->_right = parent;
		parent->_parent = subL;
		//原parent节点为根节点的情况
		if (_root == parent)
		{	
			_root = subL;
			subL->_parent = nullptr;
		}
		else //原parent节点为一棵子树
		{	
			//将subL与原parent的上层节点进行链接
			//链接到左
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else //连接到右
			{
				ppNode->_right = subL;
			}
		}
		//更新平衡因子
		subL->_bf = parent->_bf = 0; 
	}

	void RotateLR(Node* parent)
	{	
		//记父节点的左为subL
		//subL的右为subLR
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		//记录subLR的平衡因子，方便针对插入节点的情况，进行平衡因子的调整
		int bf = subLR->_bf;
		//左单旋
		RotateL(parent->_left);
		//右单旋
		RotateLR(parent);

		//双旋过后subLR平衡因子为0
		subLR->_bf = 0;
		//对父节点和subL平衡因子进行调整的三种情况
		//新增节点在subLR的右
		if (bf == 1)
		{	
			parent->_bf = 0;
			subL->_bf = -1;
		}
		//新增节点在subLR的左
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
		}
		//该节点即为新增节点
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateRL(Node* parent)
	{	
		//记父节点的右为subR
		//subR的左为subRL
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		//记录subRL的平衡因子，方便针对插入节点的情况，进行平衡因子的调整
		int bf = subRL->_bf;
		//右单旋
		RotateR(parent->_right);
		//左单旋
		RotateL(parent);
		
		//双旋后subRL的平衡因子为0
		subRL->_bf = 0;
		//对父节点和subR平衡因子进行调整的三种情况
		//新增节点在subRL的右
		if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
		}
		//新增节点在subRL的左
		else if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
		}
		//该节点即为新增节点
		else if (bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

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

		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptrl;
};

倔强的山核桃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
平衡二叉树——AVL树
HMT的博客
11-08 194
平衡二叉树 平衡二叉树的定义 平衡二叉树是一棵空的二叉排序树，或者是具有下列性质的二叉排序树 根节点的左子树和右子树的深度最多相差1 根节点的左子树和右子树也是平衡二叉树 平衡因子 结点的平衡因子是该节点左子树和右子树的深度之差，如下图，每个结点里所注的数字是该节点的平衡因子 最小不平衡子树 最小不平衡子树是指在平衡二叉树的构造过程中，以距离插入结点最近的、且平衡因子绝对值大于1的结点为根的子树。 平衡化旋转 LL型 RR型 LR型 RL 平衡树创建例子 按{20，35，40，15，30，25
高度平衡二叉树的构建_构建平衡二叉树
weixin_32404293的博客
12-24 681
选取一组数来构建平衡二叉树，数组为[3,2,1,4,5,6,7,10,9,8] BTNode root = NULL; root = insert(root, 3); root = insert(root, 2); root = insert(root, 1); root = insert(root, 4); root = insert(root, 5); r...
【数据结构—查找】高度平衡树（AVL树）（含代码实现）
青山的青衫的博客
04-02 1018
文章目录高度平衡树（AVL树）1.定义AVL结点定义2.AVL的插入失衡情况平衡方案1.单旋转（LL\RR）LL型（右旋转）RR型（左旋转）2.双旋转—旋转两次（LR\RL）LR型（以C为轴先左转后右转）RL型（以C为轴先右转后左转）AVL插入的总结3.AVL树的删除（代码未实现） 高度平衡树（AVL树） 1.定义 关于二叉查找树~ 高度平衡树结点q的平衡系数为q的右子树高度减去左子树高度。 另：树的高度是指树中结点的最大层数（似乎不同教材对于从0开始还是从1开始的定义不同） 高度平衡树所有结点的平衡
高度平衡二叉树的构建_平衡二叉树 构造方法(绝妙)
weixin_39799825的博客
12-19 351
构造方法平衡二叉树对于二叉查找树，尽管查找、插入及删除操作的平均运行时间为O(logn)，但是它们的最差运行时间都是O(n),原因在于对树的形状没有限制。平衡二叉树又称为AVL树，它或者是一棵空树，或者是有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左右子树的深度之差的绝对值不超过1。二叉树的的平衡因子BF为：该结点的左子树的深度减去它的右子树的深度，则平衡二叉树的所有结点的平衡因子为只...
高度平衡二叉树的构建_如何构建平衡二叉树（AVL树）
weixin_32248531的博客
01-14 426
一、基本概念：平衡二叉树(Balanced Binary Tree)又被称为AVL树(有别于AVL算法)，且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。二、四种旋转情况当我们对AVL树进行删除或者插入操作时，有可能会导致其左右子树高度差不超过1的性质遭到破坏，因此需要进行旋转操作来调整。旋转操作分为以下四种情况：(1)左左 (2)左...
一个简单的 AVL树、splay树、以及二叉搜索树的代码实现
05-04
一个简单的 AVL树、splay树、以及二叉搜索树的代码实现 也可在我的github仓库中下载： https://github.com/yunwei37/myClassNotes
AVL___Tree.rar_AVL树_avl_二叉搜索树
09-22
c++编的几个数据结构代码。包括AVL树、二叉搜索树、二叉树、Kruskal算法和图的邻接表表示
二叉搜索树，红黑树，AVL平衡树，B树
05-08
完整实现二叉搜索树，红黑树，AVL平衡树，B树的搜索插入删除基本功能和其它功能。红黑树和B树参考自算法导论。
AVL（平衡二叉检索）树模板（带template）
08-17
AVL树模板，支持操作如下 template struct BSTNode { T data; int h; BSTNode<T> * lchild, *rchild; }; template class AVLTree { public: AVLTree() :root(NULL),node_num(0) {} ~AVLTree() { Release...
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
7-3 平衡二叉树的根 (25分)_【数据结构】AVL树（平衡二叉树）画法 速成教学
weixin_39541227的博客
11-24 820
基本理论：一、AVL树的前身是二叉排序树（二叉查找树）。二叉排序树的一个重要性质：左子树上的所有结点都小于根结点，右子树上的所有结点都大于根节点。简而言之，左小右大。图1如图1。10左边的数都比它小，右边的数都比它大。对于9和15来说也是一样。所以如果要插入一个数字14，那么该如何做呢？图2如图2。14比10大，所以在10的右边。比15小，所以在15的左边。比12大，所以在12的右边。二、何来“平...
二叉树知识
weixin_44548640的博客
03-09 397
二叉树的深度优先遍历（DFS）与广度优先遍历（BFS） DFS深度优先遍历：从根节点出发，沿着左子树方向进行纵向遍历，直到找到叶子节点为止。然后回溯到前一个节点，进行右子树节点的遍历，直到遍历完所有可达节点为止。利用数据结构“栈”，父节点入栈，父节点出栈，先右子节点入栈，后左子节点入栈。递归遍历全部节点。 DFS:ABDGCEFH BFS广度优先遍历：从根节点出发，在横向遍历二叉树层段节点的基础...
AVL树的构建----高度平衡树实现 （C语言实现）
stefzeus的专栏
10-09 3327
 /*************************************************************************/                                            构建AVL树--高度平衡     通过旋转的方法，构建AVL树，InsertAVL（）函数插入元素；当结点左边子树集高时调用LeftBalance()修复AVL
高级数据结构与算法 | AVL树 （高度平衡树）
凌桓丶的博客
06-28 3460
文章目录AVL树实现思路数据结构查找平衡因子旋转右旋左旋右左双旋左右双旋插入删除AVL树的验证中序遍历平衡判断AVL树的性能完整代码实现 AVL树 AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis AVL树其实就是在二叉搜索树的基础上，引入了平衡因子的概念，通过旋转来调整平衡因子，使得二叉树始
平衡二叉树(AVLTree)的构造等——超详细
qq_44819750的博客
07-28 2420
平衡二叉树概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当 于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 1.它的左右子树都是AVL
平衡二叉树 构造方法
UnrealEngine4 、Delta3D、OSG
06-07 2万+
平衡二叉树 对于二叉查找树，尽管查找、插入及删除操作的平均运行时间为O(logn)，但是它们的最差运行时间都是O(n),原因在于对树的形状没有限制。平衡二叉树又称为AVL树，它或者是一棵空树，或者是有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左右子树的深度之差的绝对值不超过1。二叉树的的平衡因子BF为
平衡二叉树的构造过程实例
热门推荐
fu_jian_ping的博客
04-14 3万+
平衡二叉树实现的实例 选取一组数据分别为2，1，0，3，4，5，6，9，8，7的10个结点来构造平衡二叉树。 首先数据为2的结点作为根结点插入，接着插入1，仍是平衡的，再插入0是，2的平衡因子变为2，此时出现了不平衡，因此需要进行调整，最低不平衡结点为2，属于LL型，调整过程如图1所示。 接着插入3，是平衡的，再插入4，此时出现了不平衡，结点 1 和 2的平衡因子都为 -2，结点2为最低...
数据结构与算法
chenwen521的博客
10-19 418
-------单链表 特点：不知道总个数。 package com.weichen.Singlelinkedlist; import java.util.Stack; //alt+shift+L public class Singlelinkedlist2 { public static void main(String[] args) { // TODO Auto-generated method stub //new 新节点 HeroNode_new node1=new Her
高度平衡树
ccsu_deer
10-23 520
#include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;iostream&gt; #include&lt;cmath&gt; using namespace std; struct TreeNode { int val; TreeNode *left; TreeNode *right; Tr...
二叉平衡树和二叉搜索树
最新发布
08-02
二叉平衡树和二叉搜索树是两种不同的数据结构。 二叉搜索树（BST）是一种二叉树，它满足以下性质：非空左子树的所有键值小于其根结点的键值，非空右子树的所有键值大于其根结点的键值，左、右子树都是二叉搜索树。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值