AVL树的构造、插入和删除（C++）

最新推荐文章于 2024-09-29 12:32:27 发布
最新推荐文章于 2024-09-29 12:32:27 发布
阅读量3.4k 收藏 27
点赞数 10
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Love_Irelia97/article/details/82895991
版权

昨天搞了一个晚上，可算是把AVL树的概念搞明白。而后又参阅了大量的博客和书籍，终于是自己搞了一套代码（期间各种BUG搞得我欲仙欲死= =、）虽然考研可能不要求实现，但还是写点东西，就算是自己总结一下吧。

AVL树是一种BST（二叉搜索树），但是AVL是需要保持平衡的，即若AVL非空，那么它上面每一结点的左、右子树高度之差的绝对值不超过1，即 |hl - hr| \leq 1，其中hl - hr记做平衡因子bf

定义部分：

#include <iostream>
#include <string>
#include <cmath>
using namespace std;

//	AVL树 结点结构体定义 
typedef int ElementType;
typedef struct TreeNode{
	ElementType val;
	TreeNode*  left;
	TreeNode* right;
	int bf;		//	平衡因子 = 左子树高度 - 右子树高度，只可能是-1,0,1 
	int height;	//	树高
	//	构造函数 
	TreeNode(ElementType x):val(x), left(nullptr), right(nullptr)
		, bf(0), height(0){}			
}*AVLTree;

这就要求了AVL树在插入、删除时可能会造成某些结点的不平衡，此时就需要对离插入、删除结点最近的那一个失去平衡的结点进行一些操作，使之重新达到平衡

每一次插入、删除、旋转都是需要更新树高和平衡因子（这里定义空树高度为-1）

int getHeight(TreeNode* t)
{
	return ( t==nullptr ? -1:t->height );
}

void reHeight_Bf(AVLTree root)
{
	//	按我们学校教材规定，空树的树高为 -1	
	int hl = getHeight(root->left);
	int hr = getHeight(root->right);
	//	更新树高、平衡因子 
	root->height =  max(hl, hr) + 1;
	root->bf = hl - hr;		 
	
}

 

 

具体的操作是什么呢？ 有四种，分别是LL, RR, LR, RL

注：四种旋转，因为RL和LR旋转是基于RR和LL的，因此要按顺序定义。另外需要注意的是，旋转后的结点的高度、平衡因子均可能发生变化，记得更新（昨天被这里坑了，调试了半天o(╯□╰)o）

LL平衡旋转：是由于在结点A的左子树的左子树上插入，导致该结点平衡因子hl - hr大于1，失去平衡。此时就需要LL旋转，具体如下：

取下A结点（即为t），A的左子树记为B，B结点右子树BR链接到A的左子树，B替换A的位置，t链接到B的右子树

//	rotation n. 旋转，转动; 轮流，循环;
void LL_rotation(AVLTree& A)
{
	AVLTree t  = A;		//保存A	 					
	AVLTree B  = A->left;	//A的左子树 
	AVLTree BR = B->right;	//A的左子树 的 右子树 
	
	B->right = t;	//	B结点右子树链接原来的A结点 
	t->left = BR;	//	A结点左子树链接原来B结点的右子树 
	A = B;		//	原来树中的A结点用B结点替代 
	
	//	旋转后结点位置变化，需要更新树高
	reHeight_Bf(A->right);
	reHeight_Bf(A); 
}

RR平衡旋转：与LL镜像相反。

是由于在结点A的右子树的右子树上插入，导致该结点平衡因子hl - hr小于-1，失去平衡。此时就需要RR旋转，具体如下：

取下A结点（即为t），A的右子树记为B，B结点左子树BL链接到A的右子树，B替换A的位置，t链接到B的左子树

 

void RR_rotation(AVLTree& A)
{
	AVLTree t  = A;		//保存A	 					
	AVLTree B  = A->right;	//A的左子树 
	AVLTree BL = B->left;	//A的右子树 的 左子树 
	
	B->left = t;	//	B结点左子树链接原来的A结点 
	t->right = BL;	//	A结点右子树链接原来B结点的左子树 
	A = B;		//	原来树中的A结点用B结点替代 
	
	//	旋转后结点位置变化，需要更新树高
	reHeight_Bf(A->left);
	reHeight_Bf(A); 	
}

 

 LR平衡旋转：是因为在结点A的左子树的右子树上插入，导致该结点A的平衡因子hl - hr大于1，失去平衡。此时就需要1次RR操作，1次LL操作。具体如下：

①、对A的左子树B进行RR操作；②、对A进行LL操作

void LR_rotation(AVLTree& A)
{
	RR_rotation(A->left);	//	先对A的左子树根结点RR旋转 
	LL_rotation(A);		//	再对A结点LL旋转 
}

 

 

RL平衡旋转：与LR镜像相反

是因为在结点A的右子树的左子树上插入，导致该结点A的平衡因子hl - hr小于-1，失去平衡。此时就需要1次LL操作，1次RR操作。具体如下：

①、对A的右子树B进行LL操作；②、对A进行RR操作

 

void RL_rotation(AVLTree& A)
{
	LL_rotation(A->right);	//	先对A的右子树根结点LL旋转	
	RR_rotation(A);		//	再对A结点RR旋转 
}

 

之前在BST那块写了非递归的插入和删除，这里就偷懒一哈写递归的了（递归还是简洁好懂啊~）

插入：

//	BST写过非递归的，这里就写递归形式的好了( 其实是想偷懒了(#^.^#) ) 
bool AVL_Insert(AVLTree& root, const ElementType& x)
{
	if( !root ){
		root = new TreeNode(x);
		return true;
	}
	//	AVL树满足BST性质，不允许有相同的值存在 
	if( x == root->val ){
		cerr << "Same value in AVL_Tree!\n\n";
		return false;
	}
	//	左子树递归 
	else if( x < root->val )
	{
		AVL_Insert(root->left, x);
		reHeight_Bf(root);    //    插入后记得更新
		if( root->bf > 1 ){
			//	结点插入到左子树的左结点，LL 
			if( x < root->left->val ){
				cout << "value " << root->val << " LL rotation!\n";
				LL_rotation(root);
			}
			//	否则插入到左子树的右节点，LR
			else{
				cout << "value " << root->val << " LR rotation!\n";
				LR_rotation(root);			
			}
		}			
	}
	//	右子树递归		
	else if( x > root->val )
	{
		AVL_Insert(root->right, x);
		reHeight_Bf(root);    //    插入后记得更新
		if( root->bf < -1 ){
			//	结点插入到右子树的右结点，RR 
			if( x > root->right->val ){
				cout << "value " << root->val << " RR rotation!\n";
				RR_rotation(root);
			}
			//	否则插入到右子树的左节点，RL
			else{
				cout << "value " << root->val << " RL rotation!\n";
				RL_rotation(root);			
			}
		}			
	}
	return true;
}

删除：

之前的搞错了，删除比我想象的要复杂点。大体分2种：

①、删除后平衡因子仍在范围内，不作处理；

②、1）删除左子树的结点后，若失衡，令t = 右子树，若t的左子树高度 > t的右子树高度，相当于在右子树的左子树插入结点，执行RL操作；否则执行RR操作

        2）删除右子树的结点后，若失衡，令t = 左子树，若t的左子树高度 > t的右子树高度，相当于在左子树的左子树插入结点，执行LL操作； 否则执行LR操作

//	中序遍历下的前驱	
TreeNode* find_LeftMax(AVLTree root)
{
	TreeNode* t = root->left;	//左子树中查找最右下结点 
	while( t->right )
		t = t->right;
	return t;	
}

//	中序遍历下的后继 
TreeNode* find_RightMin(AVLTree root)
{
	TreeNode* t = root->right;	//右子树中查找最左下结点 
	while( t->left )
		t = t->left;
	return t;	
}

bool AVL_Delete(TreeNode*& p, const int& x)
{
	if( !p ){
		cerr << "No found value " << x << "\n";
		return false;
	}	
	//	查找到要删除的结点p 
	if( x == p->val)
	{
		//	以下直接更改p的指向，是因为传入的参数是引用型
		//	引用型是直接对原树的结点(而非拷贝)进行操作
		TreeNode* t = p;
		//	左、右子树均存在 
		if( p->left && p->right){
			//	若删除结点的 左子树高度 > 右子树高度
			//	找该结点的前驱 
			if( getHeight(p->left) > getHeight(p->right) ){
				t = find_LeftMax(p);
				p->val = t->val;
				AVL_Delete(p->left,  t->val);
			}
			//	否则找该结点的后继 
			else{
				t = find_RightMin(p);
				p->val = t->val;
				AVL_Delete(p->right, t->val);
			}	
		}
		else{
			p = (p->left) ? p->left:p->right;
			delete t;
		}
	}
	//	左子树递归 
	else if( x < p->val )
	{
		//	未找到删除节点，直接返回 
		if( !AVL_Delete(p->left, x) )
			return false;
		reHeight_Bf(p);
			//	删除左子树结点后失去平衡 
		if( p->bf < -1 ){
			TreeNode* t = p->right;
			//	右子树的左子树 比 右子树的右子树高
			//	相当于在右子树的左子树插入结点 ， RL 
			if( getHeight(t->left) > getHeight(t->right) ){
				cout << "value " << p->val << " RL rotation!\n";
				RL_rotation(p);
			}
			//	否则相当在右子树的右子树插入结点，RR
			else{
				cout << "value " << p->val << " RR rotation!\n";
				RR_rotation(p);		 
			}
		}
	}
	//	右子树递归 
	else if( x > p->val )
	{
		//	未找到删除节点，直接返回 
		if( !AVL_Delete(p->right, x) )
			return false;
		reHeight_Bf(p);	
		//	删除右子树结点后失去平衡 
		if( p->bf > 1 ){
			TreeNode* t = p->left;
			//	左子树的左子树 比 左子树的右子树高
			//	相当于在左子树的左子树插入结点 ， LL 
			if( getHeight(t->left) > getHeight(t->right) ){
				cout << "value " << p->val << " LL rotation!\n";
				LL_rotation(p);
			}
			//	否则相当在左子树的右子树插入结点，LR
			else{
				cout << "value " << p->val << " LR rotation!\n";
				LR_rotation(p);		 
			}
		}	
	}
	return true; 
}

前、中、后序遍历：

void visit(TreeNode* p)
{
	cout << p->val << " ";
}

//	因为AVL树满足BST树的性质，
//	即 左结点值 < 根节点值 < 右节点值 
//	因此按中序遍历恰好可以输出严格递增序列 
void inOrder(AVLTree root)
{
	if( root ){
		inOrder(root->left);
		visit(root);
		inOrder(root->right);	
	}
}

void preOrder(AVLTree root)
{
	if( root ){
		visit(root);
		preOrder(root->left);
		preOrder(root->right);	
	}	
}

void postOrder(AVLTree root)
{
	if( root ){
		postOrder(root->left);
		postOrder(root->right);	
		visit(root);
	}	
}

测试代码：参考了一位博客园大佬的例子（AVL树的C测试程序，点击左侧跳转）

int main( )
{
	AVLTree root = nullptr;
	
	int value[] = {3, 2, 1, 4, 5, 6, 7, 16, 15, 
				   14, 13, 12, 11, 10, 8, 9};	
	for(int x : value){
		cout << "Insert value " << x << ":\n";
		AVL_Insert(root, x);
		cout << "preOrder: ";
		preOrder(root);
		cout << "\n";
		cout << "inOrder: ";
		inOrder(root);
		cout << "\n\n";	
	}
	
	cout << "\n";
	preOrder(root);
	cout << "\n";	
	inOrder(root);
	cout << "\n";	
	postOrder(root);
	cout << "\n\n\n";

	int n = sizeof(value) / sizeof(value[0]);	
	while( n-- ){
		AVL_Delete(root, value[n]);
		cout << "preOrder: ";
		preOrder(root);
		cout << "\n";
		cout << "inOrder: ";
		inOrder(root);
		cout << "\n\n";
	}
	
    return 0;
}

 

Love_Irelia97
关注
专栏目录
c++ AVL树 插入 删除
CoderZhuuu
04-14 1167
AVL树的插入很简单，根据BST树的特性插入之后在回溯的过程中调整即可 AVL树的删除也不是很难，一共有三种情况 第一种是左子树为空（右子树为不为空无所谓） 第二种是右子树为空（此时左子树不为空） 这两种直接用另一半子树覆盖当前节点然后删除再回溯调整树即可 第三种是左右子数都不为空 这个情况首先找到要删除的节点，然后找到比该节点大的节点中最小的一个节点（右子树中最左边的节点），或者比该...
AVL树插入删除算法详解（有图） -- C++语言实现
热门推荐
FreeeLinux's blog
08-14 1万+
一：AVL树介绍 AVL树本质上还是一棵二叉搜索树，它的特点是： 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。在本文中用分别用-1，0，1定义左边树高，等高，右边树高。平衡因子用m_bf表示。 也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）。 二：插入算法 由于AVL树具有BST树的
AVL树C++实现（插入，删除，查找，清空，遍历操作）
weixin_34405557的博客
12-13 383
AVL.h文件代码 #pragma once #include<iostream> #include<stack> #include <assert.h> using namespace std; using namespace std; template<class T> struct AVLNode{ T data; AVLNo...
数据结构之AVL树（万字详解）
最新发布
都市隸人的博客
09-29 1248
本文介绍了数据结构中的AVL树，给出了C++的代码实现
[C++]AVL搜索树 查找/插入/删除
mzman的博客
12-13 758
AVL搜索树同时具有AVL树和搜索树的性质，相当于一种把高度控制在O(log n)的搜索树，从而保证了查找、插入、删除的时间都为O(log n)。 AVL树保证对于树中的任意节点，其两子树的高度之差不大于1，于是引入平衡因子这一概念。平衡因子表示一个节点的左子树的高度减去右子树的高度。也就是说，正常的AVL搜索树的任一节点，其平衡因子为1,0或-1，而当插入或删除了节点之后，树中出现某些节点平衡因子可能会变为2或-2，此时需要调整树的平衡。 现在假设节点nodeX是距离插入/删除位置最近、且平衡因子为2或-
Avl树插入、删除c++实现
03-11
最近在看数据结构，用c++实现了下avl树插入、删除、打印实现。实现之后，只达到可以使用的程度，还有较大的重构、优化空间。有感兴趣的同学 可以尝试改进，拿来共享。共同进步
AVL树的插入与输出
cui240558023的博客
11-23 2220
概念引用：https://www.cnblogs.com/zhuwbox/p/3636783.html AVL树： 　　AVL树本质上是一颗二叉查找树，但是它又具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为平衡二叉树。下面是平衡二叉树和非平衡二叉树对比的例图： 　　...
C++平衡Avl树实现.zip
08-20
在`MyavlTreeTest.cpp`中，可能会包含测试用例，这些用例会创建AVL树，插入一系列元素，然后执行查找、删除等操作，验证AVL树的正确性和性能。`MyavlTree.h`则可能包含了AVL树节点的定义以及上述插入、删除、查找等...
AVL树的实现基于C++语言
12-03
它的主要特性是任何节点的两个子树的高度差不超过1，这使得AVL树在插入和删除操作后能够快速恢复平衡，从而保持高效的查询性能。在C++中实现AVL树，我们需要关注以下几个关键点： 1. **节点结构**：AVL树中的每个...
AVL树的C++实现
11-06
AVL树通过在每次插入或删除节点后进行旋转操作来确保树的平衡。 在C++中实现AVL树，通常包括以下几个关键部分： 1. **AVLTreeNode类**：这个类代表AVL树的节点，通常包含以下属性： - 数据字段：存储节点的值。 ...
C++实现AVL树
番茄都是西红柿
04-12 1983
AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 一棵AVL树有如下必要条件： 1.它必须是二叉查找树。 2.每个节点的左子树和右子树的高度差至多为1。 左边二叉树的节点45左子树高度2，右子树高度0，...
AVL树的查找、删除、插入
09-18
AVL树的查找、删除、插入，并写了测试程序测试程序的正确性
C++实现AVL Tree（平衡二叉树）的构建与增删
weixin_51049319的博客
01-30 543
C++实现AVL Tree（平衡二叉树）的构建与增删
AVL树的建立与删除（JAVA）
qq_45620803的博客
10-20 287
一、树形结构定义（Tree） 这里有一些不太合理的代码，比如把AVL树专属的平衡因子加入到了树的定义上，这是最开始遗留的问题，暂时没改，等以后敲其他树的算法的时候再改一下吧 package com.bn; public abstract class Tree{ //左孩子 private Tree left; //右孩子 private Tree right; //父亲节点 private Tree father; //数...
图解数据结构树之AVL树
weixin_30552811的博客
03-31 374
AVL树(平衡二叉树)： 　　AVL树本质上是一颗二叉查找树，但是它又具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为平衡二叉树。下面是平衡二叉树和非平衡二叉树对比的例图： 　　平衡因子(bf)：结点的左子树的深度减去右子树的深度，那么显然-1<=bf<=1...
AVL树（查找、插入、删除）——C语言
weixin_30437481的博客
08-13 624
AVL树 平衡二叉查找树（Self-balancing binary search tree）通常是指一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且任意节点的左右两个子树都是一棵平衡二叉树（即严格的平衡二叉查找树，“严格”二字体现在任意节点的左右子树高度差不超过1），平衡二叉树有多种实现方法（红黑树、AVL、替罪羊树、Treap、伸展树等）本篇随笔分析的AVL树（AVL树是根...
【C++ 学习 ㉒】- 超详解 AVL 树的插入、平衡调整以及删除（含源代码）
melonyzzZ的博客
09-21 1950
超详解 AVL 树： 一、AVL 树的概念 二、AVL 树节点的定义 三、AVL 树的插入 四、AVL 树的平衡调整 五、AVL 树的删除 六、AVL 树的实现
AVL树的详细实现(C++)
code_peak
10-05 4902
AVL树概念 前面已经介绍了二叉搜索树，但是二叉搜索树在某些情况下会出现极度不平衡，其树形结构便退化成了链表，查找效率也会下降。于是出现了 AVL 树，AVL 树保证了二叉搜索树的平衡，引入了平衡监督机制，也就是在插入结点时，树中某一部分不平衡度超过一个阈值后将出发平衡调整操作，这样便保证了树的平衡度在可接受的范围内，最大的好处就是提高了搜索的效率。 AVL 树是一种平衡二叉树，其名字来源于发明者的名字（Adelson-Velskii 以及 Landis）。AVL树的递归定义如下： 左右子树的高度差小于等
AVL树删除节点deletenode函数分析 （C++实现）
Tokameine的博客
02-05 1593
先放一下代码：（这里只放一些必要的内容。因为每个人的习惯不同，只有思路可以借鉴。请注意注释。关于旋转函数，我在上一篇帖子分析insert时贴出过，仅供参考。如果在某个地方没有理解，请先继续往下看一会，或许能找到答案。如果发现代码和解释有问题，请务必指出。） typedef struct avlnode* position; typedef struct avlnode* avltree; struct avlnode{ avltree left; avltree right; int heigh.
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值