AVL树--＞增加节点

最新推荐文章于 2024-10-15 15:30:22 发布
原创 最新推荐文章于 2024-10-15 15:30:22 发布 · 552 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#avl

文章目录

1.概念

AVL树称为高度平衡的二叉搜索树，首先要满足二叉搜索树的性质。然后做了一定改进，能够使二叉搜索树及其子树的左右分支的分支高度平衡。这样能够大大的提高查找效率。对于AVL树，如果它有N个结点，其高度可保持在 log 2 N，搜索时间复杂度O(log 2 N )。

具体实现思路为：对每个结点都有一个平衡因子参数（一般为右树高度减去左树高度），当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

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

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

如下图：
（a），（b）都是二叉搜索树，但是（a）不是AVL树，（b）为AVL树。
在这里插入图片描述

AVL树节点的定义：

template<class Type>
class AVLNode
{
public:
	AVLNode() :data(Type()), leftChild(nullptr), rightChild(nullptr), bf(0)
	{}
	AVLNode(Type d, AVLNode* left = nullptr, AVLNode* right = nullptr)
		:data(d), leftChild(left), rightChild(right), bf(0)
	{}
	~AVLNode()
	{}
private:
	Type data;
	AVLNode* leftChild;
	AVLNode* rightChild;
	int      bf;  //平衡因子
};

2.AVL树的插入

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

  1. 按照二叉搜索树的方式插入新节点
  2. 调整节点的平衡因子

整体插入流程思路：

bool AVLTree<Type>::Insert(AVLNode<Type>*& t, const Type& x)
{
	//先按Bst树插入节点 	
	AVLNode<Type>* p = t;
	stack< AVLNode<Type>*> stk;  //用一个栈记住插入时经过的路线，方便取出父节点
	AVLNode<Type>* pr = nullptr;  //父节点

	while (p != nullptr) {   //寻找插入位置
		if (x == p->data)
			return false;
		pr = p;
		stk.push(pr);
		if (x > p->data) {
			p = p->rightChild;
			continue;
		}	
		if (x < p->data)
			p = p->leftChild;
	}
					
	/////已经找到位置，开始插入
	p =new AVLNode<Type>(x);
	if (pr == nullptr) {   //空树则直接创建根节点返回
		t = p;
		return true;
	}
	if (x > pr->data)
		pr->rightChild = p;
	else
		pr->leftChild = p;

	//////插入完，调整平衡因子///  若在pr左数插入  pr->bf  -1  ; 在pr右树插入 bf->bf  +1
	while (!stk.empty()) {
		pr = stk.top();  
		stk.pop();
		if (pr->leftChild==p)  // 左数插入 pr->bf  -1
			pr->bf --;
		else
			pr->bf ++;
		
		if (pr->bf == 0) //树是平衡的  返回
			break;
		else if (pr->bf == 1 || pr->bf == -1)  // 向上回溯  pr的父节点处可能不平衡
		{
			p = pr;	    //开始下一轮while()循环，判断pr的父节点是否平衡，下一轮的pr为这一轮pr的父节点
		}
		else {  //树不平衡  需要调整  针对不平衡的节点调整   		
			if (pr->bf < 0) {
				if (p->bf < 0) {    //  /  右单旋
					RotateR(pr);
				}
				else {   //    <    先左旋后右旋
					RotateLR(pr);
				}
			}
			else {
				if (p->bf > 0) { //    \  左单旋
					RotateL(pr);
				}
				else {//   >    先右旋后左旋
					RotateRL(pr);
				}
			}
			break;
		}
	}

其中对于调整平衡因子时 满足（pr->bf == 1 || pr->bf == -1）条件要向上回溯的问题，这里做了简单图解：
在这里插入图片描述

其中调整平衡因子时，是根据平衡因子的正负变化来决定采用那种方法调整，如图：
在这里插入图片描述

具体调整平衡因子的四种旋转方法如下;

1.右单旋

在这里插入图片描述
实现：

void RotateR(AVLNode<Type>*& ptr)
	{
		AVLNode<Type>* subR = ptr;
		ptr = subR->leftChild;
		subR->leftChild = ptr->rightChild;
		ptr->rightChild = subR;
		ptr->bf = subR->bf = 0;	
	}

图解：
向上回溯到第一个不平衡的节点ptr，然后调整这个不平衡的子树即可，其它平衡的部分不用管。
然后如图设置好ptr subR指针的位置，然后转就完事了。
这里说明一下符号：

ptr 最终要指向需要调整的这个子树的根节点，最后将ptr跟其父节点连接起来，这样是一颗完整的树了。
subL是最终要连到ptr的左树的节点。
sunR是最终要连到ptr右树的节点.

在这里插入图片描述

2.左单旋

在这里插入图片描述
实现：

	void RotateL(AVLNode<Type>*& ptr)
	{
		AVLNode<Type>* subL = ptr;
		ptr = subL->rightChild;
		subL->rightChild = ptr->leftChild;
		ptr->leftChild = subL;
		ptr->bf = subL->bf = 0;
	}

3.先右单旋再左单旋

分为两个步骤，先右旋后左旋，比较难的部分是旋转完之后的平衡因子该怎么调整，这里画了图能比较直观点看到。
实现：

void RotateRL(AVLNode<Type>*& ptr){
		AVLNode<Type>* subL = ptr;
		AVLNode<Type>* subR = ptr->rightChild;
		ptr = subR->leftChild;

		subR->leftChild =ptr->rightChild;
		ptr->rightChild = subR;
		//调整subL->bf
		if (ptr->bf <= 0)
			subL->bf = 0;
		else
			subL->bf = -1;

		subL->rightChild = ptr->leftChild;
		ptr->leftChild = subL;
		
		//调整subR->bf
		if (ptr->bf >= 0)
			subR->bf = 0;
		else
			subR->bf = 1;

		ptr->bf = 0;
	}

对于旋转之后如可调整subL->bf和调整subR->bf这里可以通过画图就能找到规律。
共有以下三种情况：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

4.先左单旋再右单旋

方法类似先右单旋再左单旋（镜像）。不想画了…
实现：

	void RotateLR(AVLNode<Type>*& ptr)
	{
		AVLNode<Type>* subR = ptr;
		AVLNode<Type>* subL = ptr->leftChild;
		ptr = subL->rightChild;

		subL->rightChild = ptr->leftChild;
		ptr->leftChild = subL;
		//调整subL->bf
		if (ptr->bf <= 0)
			subL->bf = 0;
		else
			subL->bf = -1;

		subR->leftChild = ptr->rightChild;
		ptr->rightChild = subR;

		//调整subR->bf
		if (ptr->bf >= 0)
			subR->bf = 0;
		else
			subR->bf = 1;

		ptr->bf = 0;
	}
完整代码：
template<class Type>
class AVLTree;

template<class Type>
class AVLNode
{
	friend class AVLTree<Type>;
public:
	AVLNode() :data(Type()), leftChild(nullptr), rightChild(nullptr), bf(0)
	{}
	AVLNode(Type d, AVLNode* left = nullptr, AVLNode* right = nullptr)
		:data(d), leftChild(left), rightChild(right), bf(0)
	{}
	~AVLNode()
	{}
private:
	Type data;
	AVLNode* leftChild;
	AVLNode* rightChild;
	int      bf;
};

template<class Type>
class AVLTree
{
public:
	AVLTree() : root(nullptr)
	{}
public:
	bool Insert(const Type& x)
	{
		return Insert(root, x);
	}

protected:
	bool Insert(AVLNode<Type>*& t, const Type& x);
protected:

	void RotateL(AVLNode<Type>*& ptr)
	{
		AVLNode<Type>* subL = ptr;
		ptr = subL->rightChild;
		subL->rightChild = ptr->leftChild;
		ptr->leftChild = subL;
		ptr->bf = subL->bf = 0;
	}


	void RotateR(AVLNode<Type>*& ptr)
	{
		AVLNode<Type>* subR = ptr;
		ptr = subR->leftChild;
		subR->leftChild = ptr->rightChild;
		ptr->rightChild = subR;
		ptr->bf = subR->bf = 0;
	
	}


	void RotateLR(AVLNode<Type>*& ptr)
	{
		AVLNode<Type>* subR = ptr;
		AVLNode<Type>* subL = ptr->leftChild;
		ptr = subL->rightChild;

		subL->rightChild = ptr->leftChild;
		ptr->leftChild = subL;
		//调整subL bf
		if (ptr->bf <= 0)
			subL->bf = 0;
		else
			subL->bf = -1;

		subR->leftChild = ptr->rightChild;
		ptr->rightChild = subR;

		//调整subR bf
		if (ptr->bf >= 0)
			subR->bf = 0;
		else
			subR->bf = 1;

		ptr->bf = 0;
	}

	void RotateRL(AVLNode<Type>*& ptr){
		AVLNode<Type>* subL = ptr;
		AVLNode<Type>* subR = ptr->rightChild;
		ptr = subR->leftChild;

		subR->leftChild =ptr->rightChild;
		ptr->rightChild = subR;
		//调整subL bf
		if (ptr->bf <= 0)
			subL->bf = 0;
		else
			subL->bf = -1;

		subL->rightChild = ptr->leftChild;
		ptr->leftChild = subL;
		
		//调整subR bf
		if (ptr->bf >= 0)
			subR->bf = 0;
		else
			subR->bf = 1;

		ptr->bf = 0;
	}

private:
	AVLNode<Type>* root;
};

template<class Type>
bool AVLTree<Type>::Insert(AVLNode<Type>*& t, const Type& x)
{
	//先按Bst树插入节点 

	
	AVLNode<Type>* p = t;
	stack< AVLNode<Type>*> stk;  //用一个栈记住插入时经过的路线
	AVLNode<Type>* pr = nullptr;

	while (p != nullptr) {   //寻找插入位置
		if (x == p->data)
			return false;
		pr = p;
		stk.push(pr);
		if (x > p->data) {
			p = p->rightChild;
			continue;
		}	
		if (x < p->data)
			p = p->leftChild;
	}
				
	/////插入
	p =new AVLNode<Type>(x);
	if (pr == nullptr) {   //空树则直接创建根节点返回
		t = p;
		return true;
	}

	if (x > pr->data)
		pr->rightChild = p;
	else
		pr->leftChild = p;

	//////////调整平衡因子///  左数插入  bf -1  ; 右树插入 bf +1
	while (!stk.empty()) {
		pr = stk.top();
		stk.pop();

		if (pr->leftChild==p)  // 左数插入  bf -1 
			pr->bf --;
		else
			pr->bf ++;
		
		if (pr->bf == 0) //树是平衡的  返回
			break;
		else if (pr->bf == 1 || pr->bf == -1)  // 向上回溯  上面可能会不平衡
		{
			p = pr;	
		}
		else {  //树不平衡  需要调整  针对不平衡的节点调整

			if (pr->bf < 0) {
				if (p->bf < 0) {    //  /  右单旋
					RotateR(pr);
				}
				else {   //    <    先左旋后右旋
					RotateLR(pr);
				}
			}
			else {
				if (p->bf > 0) { //    \  左单旋
					RotateL(pr);
				}
				else {//   >    先右旋后左旋
					RotateRL(pr);
				}
			}
			break;
		}
	}

	//连接
	if (stk.empty())
		t = pr;
	else
	{
		AVLNode<Type>* q = stk.top();
		if (pr->data < q->data)
			q->leftChild = pr;
		else
			q->rightChild = pr;
	}

	return true;
}


int main()
{
	vector<int> iv{ 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	AVLTree<int> avl;

	for (const auto& e : iv)
		avl.Insert(e);
	return 0;
}
190-AVL树-下（插入 & 删除操作）
Edward_LF的博客
05-11 288
1、AVL树insert插入代码实现 AVL树也是一颗BST树，在BST树的插入基础上进行的！！ #include <iostream> using namespace std; //AVL树 二叉平衡搜索树 template<typename T> class AVLTree { private: //定义AVL树节点类型 struct Node { Node(T data = T()) :data_(data) , left_(nullptr)
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2979
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
二叉树搜索树---AVL树插入节点
fern_girl的博客
05-22 704
1.AVL树的概念： AVL树或则是空树，或是具有下列性质的二叉搜索树 它的左右子树都是AVL树； 左子树和右子树的高度之差简称（平衡因子）的绝对值不超过1； 2.AVL树的实现原理 与二叉搜索树的节点插入方法相同，具体步骤如下： 当树不平衡时，我们需要做出旋转调整，有四种调整方法，分别为右单旋、左单旋、先左单旋再右单旋、先右单旋在左单旋 左单旋 右单旋 先右旋再左旋 先左旋再右
ultratree的使用（三）：在树上面添加新节点
流波上的舞
07-28 4681
在树上添加新的节点的操作其实很简单，但是不能保存，如果要保存起来，那么你就要有数据库来保存，这样的话，你的树在启动的时候就需要动态加载。这个将在ultratree的使用（四）：动态加载树结构中有介绍。好了，闲话少说。添加树节点首先你要选择一个添加的位置，如果你的树没子节点那就无所谓了。首先定义一个全局变量来保存你选择节点的位置。 private UltraTreeNode PNode；
AVL树的创建、查找、删除节点、增加节点和释放内存的实现
qq_28107929的博客
08-22 3846
include “stdafx.h” include &amp;lt; iostream &amp;gt; include &amp;lt; stdlib.h &amp;gt; include &amp;lt; stdio.h&amp;gt; include &amp;lt; vector&amp;gt; include &amp;lt; assert.h&amp;gt; using namespace std;
AVL树节点的插入
sing_Hwang的博客
02-02 1371
先声明一下这里为什么只写了AVL树节点的插入哈 首先说一下AVL树的查找，因为查找并没有破坏节点位置。而我们的AVL树是在搜索树的基础上限定了树的左右树之间的高度不超过（-1 || 1），所以说查找是完全类比搜索二叉树的。 在来说一下删除吧，因为删除是也是要考虑树的高度，还有顺序的，这个想一想就有一点麻烦，不过只要多画几张图，把分类的几种情况理清楚了，还是可以画出来的，但是要清楚一个概念...
红黑树原理（增加节点、删除节点、修改节点、查询节点）
目与木鱼
12-26 2195
红黑树原理（增加节点、删除节点、修改节点、查询节点）
【C++】详解STL之 AVL tree --- “额外平衡条件的”二叉搜索树
最新发布
2401_83431652的博客
10-15 1250
VL树是一种高度平衡的二叉搜索树，通过严格控制左右子树高度差（不超过1）来保证操作效率为O(logN)。文章详细介绍了AVL树的核心概念、平衡因子机制及实现方法，重点阐述了插入操作时的四种旋转调整策略（左/右单旋、左右/右左双旋）及其代码实现。通过平衡检测函数验证树的平衡性，并提供了测试案例展示其性能优势。AVL树在保证搜索效率的同时，有效解决了普通二叉搜索树可能退化为链表的问题。
AVL树----java版
weixin_65846395的博客
10-12 1103
/平衡因子//左孩子的引用//右子树的引用//父亲节点的引用我们需要把AVL定义为三叉树，同时增加bf记录每个节点的平衡因子，通过获取节点的平衡因子来调节树的平衡。三叉结构增加一个指针指向父亲节点，可以更好的在增加节点时修改父亲节点的平衡因子。
数据结构学习笔记-----AVL树节点插入中平衡因子的调节及旋转问题
qq_41219243的博客
05-26 2468
目录 一、AVL树 （一）概念 （二）定义 二、AVL树的插入 （一）先按照二叉搜索树的规则将节点插入到AVL树中 （二）平衡因子调节 1.调节过程 2.代码实现 （三）旋转 1.概念 2.新节点插入较高左子树的左侧---左左：右单旋 3.新节点插入较高右子树的右侧---右右：左单旋 4. 新节点插入较高左子树的右侧---左右：先左单旋再右单旋 5.新节点插入较高右子树的左侧---右左：先右单旋再左单旋 一、AVL 树 （一）概念 对于一个AVL树，它是一个高度平衡的搜.
AVL树 创建 插入 删除
03-06
对AVL树进行了较为详细的阐述，创建、增加、删除等等
如何给树的每个节点添加数量为此节点深度的新节点，题目选自CS61A2021 LAB8 Q6：Add Leaves
weixin_63603830的博客
03-21 362
当求解树任一节点深度困难时如何解决需要深度的问题
第五十四课 树中节点的插入操作
diaozhiwa5526的博客
09-22 486
问题： 新插入节点的位置如何指定？ 非线性结构无法通过下标指定位置。 插入操作代码流程： 当前的树是一棵空树的话，新节点就当做空节点来插入。不是空树就查找新节点的父节点。 在GTree.h中添加插入操作： 1 #ifndef GTREE_H 2 #define GTREE_H 3 4 #incl...
AVL树插入新节点后调整的四种情况（左单旋、右单旋、双旋）
qq_56870066的博客
08-03 604
虽然插入之后，依旧会保持二叉搜索树的特性，但AVL树的特性可能被破坏了。
AVL树详解
程序员的规则
03-16 1469
目录 AVL树定义 节点定义 购买节点 插入节点 平衡化旋转 左旋 右旋 改变平衡因子 单旋与双旋的判断 先左后右型： 当为左单旋时图解： 当为双旋时（E的balance为1时）图解： 当为双旋时（E的balance为-1时）图解： 先右后左型： 当为单旋时： 当为双旋时（D的balance为-1时）图解： 当为双旋时（D的balance为1时）图解： AVL树定义 一颗AVL树或者是孔数，或者是具有以下性质的二叉搜索树：它的左子树和...
AVL树的初步生成与插入操作
u011446963的博客
07-02 3772
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法 平衡二叉树的常用算法有红黑树、AVL、Treap等。 最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n-2)+1 这个类似于一个递归的数列，可以参考Fibonacci数列
AVL树的插入与删除
haliluya123a的博客
08-25 796
AVL 树要在插入和删除结点后保持平衡，旋转操作必不可少。关键是理解什么时候应该左旋、右旋和双旋。在Youtube上看到一位老师的视频对这个概念讲解得非常清楚，再结合算法书和网络的博文，记录如下。 1.1 AVL 的旋转 一棵AVL树是其每个节点的左子树和右子树的高度差最多为1的二叉查找树(空树高度定义为-1)。AVL树插入和删除时都可能破坏AVL的特性，可以通过对树进行修正来保证特性，修正方
AVL树的插入操作
liuchenjane的博客
05-20 1682
AVL tree (Adelson-Velskii-Landis tree) 一颗AVL树是其每个节点的左子树和右子树的高度最多差1的二叉查找树。加了额外的平衡条件是为了确保整棵树的深度为O(logN) 在高度为h的AVL树，最少节点数S(h)=S(h-1)+S(h-2)+1. =========================================================
AVL树的插入操作（旋转）图解
weixin_30338481的博客
08-19 443
=================================================================== AVL树的概念 在说AVL树的概念之前，我们需要清楚二茬搜索树的概念。对于二叉搜索树，我们知道它可以降低查找速率，但是如果一个二叉搜索树退化成一棵只剩单支的搜索树，此时的查找速率就相当于顺序表中查找元素，效率变低，时间复杂度由原来的O（logN）变...
AVL树节点增删操作教程与程序实现
在处理AVL树的增加节点操作时，首先需要按照二叉搜索树的性质找到合适的插入位置，即将新节点作为叶子节点插入到树中。由于插入操作可能会破坏树的平衡，因此需要进行一系列的旋转操作来重新平衡树。AVL树的旋转操作...
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值