[学习笔记]AVL平衡二叉树

最新推荐文章于 2024-05-06 21:39:59 发布
最新推荐文章于 2024-05-06 21:39:59 发布
阅读量405 收藏
点赞数
分类专栏： 学习笔记 文章标签： AVL 平衡二叉树 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyxvc/article/details/48002455
版权

AVL平衡二叉树的实现：

#include "stdafx.h"
#include <iostream>
class CAVLTree
{
public:
	CAVLTree() :m_pRoot(nullptr){};
	~CAVLTree(){};
public:
	typedef struct _NODE
	{
		int nData;
		_NODE* pLeft;
		_NODE* pRight;
	}NODE, *pNODE;
public:
	//向二叉树中添加一个数据
	bool Insert(int nEle, int& nError);
	bool Insert(
		int nEle,			//插入的数据     
		pNODE& pNode,		//要插入的节点
		int& nError			//错误码
		);
	//从二叉树中删除一个数据
	bool Delete(int nEle, int& nError);
	bool Delete(
		int nEle,			//要被删掉的数据
		pNODE& pTree,		//要删除节点的子树
		int& nError			//错误码
		);
	//判断一棵树是否为空
	bool IsEmpty(){ return m_pRoot ? false : true; }
	//获取一个子树的高度
	int GetHeight(pNODE pTree);
	//获取最大值
	bool GetMax(pNODE pTree, int& nMax);
	//获取最小值
	bool GetMin(pNODE pTree, int& nMin);
	//前序遍历
	void PreOrderTraverse();
	void PreOrderTraverse(pNODE pNode);
	//中序遍历
	void InOrderTraverse();
	void InOrderTraverse(pNODE pNode);
	//后序遍历
	void PostOrderTraverse();
	void PostOrderTraverse(pNODE pNode);	
	//左旋和右旋
	bool SingleL(pNODE& pNode);
	bool SingleR(pNODE& pNode);
	bool DoubleLR(pNODE& pNode);
	bool DoubleRL(pNODE& pNode);
private:
	pNODE m_pRoot;	//根节点指针
};
//************************************************************
// 函数名称:	Insert
// 函数说明:	向二叉树中添加一个数据
// 作	者:	Dylan
// 时	间:	2015/08/25
// 参	数:	int nEle
// 参	数:	int & nError
// 返 回	值:	bool
//************************************************************
bool CAVLTree::Insert(int nEle, int& nError)
{
	if (Insert(nEle, m_pRoot, nError))
	{
		return true;
	}
	return false;
}
bool CAVLTree::Insert(int nEle, pNODE& pNode, int& nError)
{
	bool bSuccess = false;
	//1.判断是否是要插入的节点
	if (pNode == nullptr)
	{
		pNode = new NODE;
		pNode->pLeft = nullptr;
		pNode->pRight = nullptr;
		pNode->nData = nEle;
		return true;
	}
	//2.判断要插入的数据和当前根节点比较大小
	if (nEle>pNode->nData)
	{
		bSuccess = Insert(nEle, pNode->pRight, nError);
	}
	else if (nEle<pNode->nData)
	{
		bSuccess = Insert(nEle, pNode->pLeft, nError);
	}
	else
	{
		return false;
	}
	//AVL
	//3.判断一下经历了删除之后，本节点是否平衡
	int nLHight = GetHeight(pNode->pLeft);
	int nRHight = GetHeight(pNode->pRight);
	int nSub = nLHight - nRHight;
	//3.1如果左边高
	if (nSub == 2)
	{
		//3.1.1右旋
		nLHight = GetHeight(pNode->pLeft->pLeft);
		nRHight = GetHeight(pNode->pLeft->pRight);
		if (nLHight >= nRHight)
		{
			SingleR(pNode);
		}
		//3.1.2左右旋
		else
		{
			DoubleLR(pNode);
		}
	}
	//3.2如果右边高
	else if (nSub == -2)
	{
		//3.2.1左旋
		nLHight = GetHeight(pNode->pRight->pLeft);
		nRHight = GetHeight(pNode->pRight->pRight);
		if (nLHight <= nRHight)
		{
			SingleL(pNode);
		}
		//3.2.2右左旋
		else
		{
			DoubleRL(pNode);
		}
	}
	return true;
}
//************************************************************
// 函数名称:	Delete
// 函数说明:	从二叉树中删除一个数据
// 作	者:	Dylan
// 时	间:	2015/08/26
// 参	数:	int nEle
// 参	数:	int & nError
// 返 回	值:	bool
//************************************************************
bool CAVLTree::Delete(int nEle, int& nError)
{
	if (Delete(nEle, m_pRoot, nError))
	{
		return true;
	}
	return false;
}
bool CAVLTree::Delete(int nEle, pNODE& pTree, int& nError)
{
	bool bSuccess = false;
	//1.判断节点是否为空
	if (pTree == NULL)
	{
		return false;
	}
	//2.判断要删除的数据比当前子树的根节点大还是小
	if (nEle>pTree->nData)
	{
		bSuccess = Delete(nEle, pTree->pRight, nError);
	}
	else if (nEle<pTree->nData)
	{
		bSuccess = Delete(nEle, pTree->pLeft, nError);
	}
	//3.判断要删除的数据和当前子树根节点一样大，应该删除
	else
	{
		//3.1要删除的点是一个叶子节点
		if (pTree->pLeft == nullptr&&pTree->pRight == nullptr)
		{
			delete pTree;
			pTree = nullptr;
			return true;
		}
		//3.2要删除的点是一个树干
		//3.2.1分别获取此节点的左子树高和有子树高
		int nLeftHeight = 0;
		int nRightHeight = 0;
		nLeftHeight = GetHeight(pTree->pLeft);
		nRightHeight = GetHeight(pTree->pRight);
		//3.2.2判断一下，这两棵树谁高
		if (nLeftHeight>nRightHeight)
		{
			int nMax = 0;
			GetMax(pTree->pLeft, nMax);
			pTree->nData = nMax;
			bSuccess = Delete(nMax, pTree->pLeft, nError);
		}
		else
		{
			int nMin = 0;
			GetMin(pTree->pRight, nMin);
			pTree->nData = nMin;
			bSuccess = Delete(nMin, pTree->pRight, nError);
		}
	}
	if (bSuccess==false)
	{
		return bSuccess;
	}
	//AVL
	//5.判断一下经历了删除之后，本节点是否平衡
	int nLHight = GetHeight(pTree->pLeft);
	int nRHight = GetHeight(pTree->pRight);
	int nSub = nLHight - nRHight;
	//5.1如果左边高
	if (nSub == 2)
	{
		//5.1.1右旋
		nLHight = GetHeight(pTree->pLeft->pLeft);
		nRHight = GetHeight(pTree->pLeft->pRight);
		if (nLHight >= nRHight)
		{
			SingleR(pTree);
		}
		//5.1.2左右旋
		else
		{
			DoubleLR(pTree);
		}
	}
	//5.2如果右边高
	else if(nSub == -2)
	{
		//5.2.1左旋
		nLHight = GetHeight(pTree->pRight->pLeft);
		nRHight = GetHeight(pTree->pRight->pRight);
		if (nLHight <= nRHight)
		{
			SingleL(pTree);
		}
		//5.2.2右左旋
		else
		{
			DoubleRL(pTree);
		}
	}
	return true;
}
//************************************************************
// 函数名称:	GetHeight
// 函数说明:	获取一个子树的高度
// 作	者:	Dylan
// 时	间:	2015/08/26
// 参	数:	pNODE pTree
// 返 回	值:	int
//************************************************************
int CAVLTree::GetHeight(pNODE pTree)
{
	if (pTree == nullptr)
	{
		return 0;
	}
	int nLeftHeight = GetHeight(pTree->pLeft);
	int nRightHeight = GetHeight(pTree->pRight);
	return (nLeftHeight > nRightHeight ? nLeftHeight : nRightHeight) + 1;
}
//************************************************************
// 函数名称:	GetMax
// 函数说明:	获取最大值
// 作	者:	Dylan
// 时	间:	2015/08/26
// 参	数:	pNODE pTree
// 参	数:	int & nMax
// 返 回	值:	bool
//************************************************************
bool CAVLTree::GetMax(pNODE pTree, int& nMax)
{
	if (pTree == nullptr)
	{
		return false;
	}
	while (pTree)
	{
		nMax = pTree->nData;
		pTree = pTree->pRight;
	}
	return true;
}
//************************************************************
// 函数名称:	GetMin
// 函数说明:	获取最小值
// 作	者:	Dylan
// 时	间:	2015/08/26
// 参	数:	pNODE pTree
// 参	数:	int & nMin
// 返 回	值:	bool
//************************************************************
bool CAVLTree::GetMin(pNODE pTree, int& nMin)
{
	if (pTree == nullptr)
	{
		return false;
	}
	while (pTree)
	{
		nMin = pTree->nData;
		pTree = pTree->pLeft;
	}
	return true;
}
//************************************************************
// 函数名称:	PreOrderTraverse
// 函数说明:	前序遍历
// 作	者:	Dylan
// 时	间:	2015/08/25
// 返 回	值:	void
//************************************************************
void CAVLTree::PreOrderTraverse()
{
	PreOrderTraverse(m_pRoot);
	std::cout << std::endl;
}

void CAVLTree::PreOrderTraverse(pNODE pNode)
{
	if (pNode == nullptr)
	{
		return;
	}
	std::cout << pNode->nData << " ";
	PreOrderTraverse(pNode->pLeft);
	PreOrderTraverse(pNode->pRight);
}
//************************************************************
// 函数名称:	InOrderTraverse
// 函数说明:	中序遍历
// 作	者:	Dylan
// 时	间:	2015/08/25
// 返 回	值:	void
//************************************************************
void CAVLTree::InOrderTraverse()
{
	InOrderTraverse(m_pRoot);
	std::cout << std::endl;
}
void CAVLTree::InOrderTraverse(pNODE pNode)
{
	{
		if (pNode == nullptr)
		{
			return;
		}
		InOrderTraverse(pNode->pLeft);
		std::cout << pNode->nData << " ";
		InOrderTraverse(pNode->pRight);
	}
}
//************************************************************
// 函数名称:	PostOrderTraverse
// 函数说明:	后序遍历
// 作	者:	Dylan
// 时	间:	2015/08/25
// 返 回	值:	void
//************************************************************
void CAVLTree::PostOrderTraverse()
{
	PostOrderTraverse(m_pRoot);
	std::cout << std::endl;
}
void CAVLTree::PostOrderTraverse(pNODE pNode)
{
	{
		if (pNode == nullptr)
		{
			return;
		}
		PostOrderTraverse(pNode->pLeft);
		PostOrderTraverse(pNode->pRight);
		std::cout << pNode->nData << " ";
	}
}
//************************************************************
// 函数名称:	SingleL              K2                K1  
// 函数说明:	左单旋                 \              /  \
// 作	者:	Dylan                   K1     =>    K2   N
// 时	间:	2015/08/26               \
// 参	数:	pNODE & pNode             N
// 返 回	值:	bool
//************************************************************
bool CAVLTree::SingleL(pNODE& pNode)
{
	pNODE k2 = pNode;
	pNODE k1 = pNode->pRight;
	k2->pRight = k1->pLeft;
	k1->pLeft = k2;
	pNode = k1;
	return true;
}
//************************************************************
// 函数名称:	SingleR                  K2            K1      
// 函数说明:	右单旋                   /            / \
// 作	者:	Dylan                   K1     =>    N   K2 
// 时	间:	2015/08/26             /
// 参	数:	pNODE & pNode         N
// 返 回	值:	bool
//************************************************************
bool CAVLTree::SingleR(pNODE& pNode)
{
	pNODE k2 = pNode;
	pNODE k1 = pNode->pLeft;
	k2->pLeft = k1->pRight;
	k1->pRight = k2;
	pNode = k1;
	return true;
}
//************************************************************
// 函数名称:	DoubleLR          K2          K2         N
// 函数说明:	左右双旋          /           /         / \
// 作	者:	Dylan            K1    =>    N    =>  K1   K2
// 时	间:	2015/08/26         \        /
// 参	数:	pNODE & pNode       N      K1
// 返 回	值:	bool
//************************************************************
bool CAVLTree::DoubleLR(pNODE& pNode)
{
	SingleL(pNode->pLeft);
	SingleR(pNode);
	return true;
}
//************************************************************
// 函数名称:	DoubleRL         K2        K2              N
// 函数说明:	右左双旋           \         \            / \
// 作	者:	Dylan               K1 =>     N    =>   K2   K1
// 时	间:	2015/08/26         /           \
// 参	数:	pNODE & pNode     N             K1
// 返 回	值:	bool
//************************************************************
bool CAVLTree::DoubleRL(pNODE& pNode)
{
	SingleR(m_pRoot->pRight);
	SingleL(pNode);
	return true;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nError = 0;
	CAVLTree obj;
	for (int i = 1; i < 100;i+=5)
	{
		obj.Insert(i, nError);
	}
	//下个断点 观察根节点是否有左右子树，若有，则表明可以进行平衡插入。
	obj.PreOrderTraverse();
	obj.InOrderTraverse();
	obj.PostOrderTraverse();

	system("pause");
	return 0;
}


cyxvc
关注
专栏目录
java学习笔记——平衡二叉树（AVL算法）
qq_36334929的博客
03-17 352
目录平衡二叉树AVL树的左旋转AVL树的右旋转AVL树的双旋转 平衡二叉树 平衡二叉树是对二叉排序树的一种改进 二叉排序树：二叉树中的任何一个节点，它的左子树中所有的节点都比该节点要小，它的右子树中所有的节点都比该节点要大。（注意二叉排序树中应尽量避免重复的值，如果有重复的值，可以选择不插入，或者添加一个属性记录该值出现的次数，否则查找和删除的时候回出现麻烦） 对于排序二叉树而言，如果输入的数组是一个有序的数列，那么最后生成的二叉树的结构会产生不平衡的情况（即所有节点都在树的一边），例如根据数组{1,2,
Leetcode BST Preorder Traverse
Doubaoainangao的专栏
11-16 439
Given a binary tree, return the preorder traversal of its nodes' values. For example: Given binary tree {1,#,2,3}, 1 \ 2 / 3 return [1,2,3]. Note: Recursive soluti
函数指针作为函数的参数
幻想之渔
03-21 624
函数指针作为函数的参数 int min(int x, int y){ return (x < y ? x : y); } int(*pmin)(int, int)=min; int fun(int(*p)(int x, int y), int xx, int yy)//返回一个int类型值，有三个函数，第一个是有两个参数的函数指针 { return p(xx,yy); } int
(十三) AVL平衡二叉树
jssd的博客
09-04 410
文章目录AVL 平衡二叉树树的深度平衡因子如何将二叉搜索树改进成AVL什么时候改进怎么维护右旋转左旋转树的不平衡情况LLRRLRRL代码实现 AVL 平衡二叉树 树的深度 对于每个节点来说, 其存在的层数就是以此节点来表示的二叉树的深度. 二叉树的深度定义如下: 只有一个节点的树, 他的深度为1 一个节点的深度等于它的左孩子深度;和右孩子深度的最大值加1 平衡因子 每一个平衡树都会维护一个平衡...
AVL平衡二叉树学习笔记
LucasGao14的博客
03-18 134
AVL平衡二叉树学习笔记 平衡二叉树 平衡二叉树是一种特殊的排序二叉树，它的性质如下： 一棵二叉排序树，它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 正因为它有如下性质，它在大多数情况下比二叉排序树要矮的多，查找效率也高得多 平衡二叉树的实现方式有很多，比如说红黑树，AVL树，本文讲述AVL树的生成过程，插入过程和删除过程 生成一棵二叉排序树 ...
sheng的学习笔记-平衡二叉树（AVL）和3+4重构
coldstarry的专栏
09-30 1089
平衡二叉树，旋转，3+4重构，示例代码
学习笔记-平衡二叉树
touteng55的博客
04-01 170
平衡二叉树 对于数列{1，2，3，4，5，6}，创建一颗普通的二叉排序树，会有一些问题： 左子树全部为空，更像是链表而不是树 插入同样很快，但查询的效率降低了。 为了解决这个问题，提出了平衡二叉树，实际上是对二叉排序树的优化，可以提高查询的效率。 平衡二叉树的特点是每棵左子树和右子树的高度相差不超过1。 平衡二叉树的实现 实际上，平衡二叉树是通过对二叉排序树旋转来完成的。而旋转的实际意义是更改二叉排序树的根节点，通过二叉排序树的创立规则，数组的第一个数就作为根节点，但这样有时会导致左右子树不平衡，这时
平衡二叉树（AVL树）学习笔记-C语言，附手绘过程
NanamiKento的博客
09-15 483
真的很详细，很通俗易懂…… 至少作者这么觉得。
王道数据结构笔记02-平衡二叉树/平衡树/AVL树
testleaf.cn
08-31 2301
平衡二叉树（BalancedBinaryTree），简称平衡树（AVL树），树上任一结点的左子树和右子树的高度之差不超过1。简称AVL命名来源于其发明者G.M.Adelson-Velsky和E.M.Landis，不要和平均查找长度ASL混淆了。结点的平衡因子=左子树高-右子树高。平衡二叉树结点的平衡因子的值只可能是-1、0或1。只要有任一结点的平衡因子绝对值大于1，就不是平衡二叉树。intkey;//数据域intbalance;.......................................
平衡二叉树（AVL树）浅析
10-20
文档"平衡二叉树（AVL树）浅析.doc"应该包含了详细的理论解释和可能的示例图，有助于理解和学习AVL树的原理。 总的来说，AVL树通过维持树的平衡状态，确保了高效的查找、插入和删除操作。学习和掌握AVL树的原理和...
基础算法平衡二叉树（AVL）树实现
2401_83915900的博客
04-20 252
定义AVL树结点：// TreeNode AVL结点定义data int // 结点数据height int // 结点高度left *TreeNode // 左孩子right *TreeNode // 右孩子// NewTreeNode 构建一个新结点height: 0,left: nil,复制代码可以在二叉查找树的基础上进行修改，这里重点实现插入和删除的操作，其他一些基本上都和二叉树操作一样。// Insert 插入// TODO。
平衡二叉树（AVL Tree）（c 语言 + 源代码）笔记
qq_22613757的博客
12-12 513
写在前面 最近写东西用到了平衡二叉树，借机钻研学习一下。 概念 平衡二叉查找树，也被称为高度平衡树。相比于“二叉查找树”，它的特点为： AVL树中任何结点的两个子树的高度最大差为1。 AVL 树的查找、插入和删除在平均和最坏情况下都是O（logn）。 对AVL树插入或删除操作时，会破坏AVL树的平衡状态。为了将其重新维持平衡，需要对其进行旋转处理。旋转算法很重要！！ AVL树的实现 头...
【开卷数据结构 】平衡二叉树（AVL）_按照关键词序列创建平衡二叉树
最新发布
2401_84159813的博客
05-06 772
由于在结点A的左孩子(L)的左子树(L)上插入了新结点，A 的平衡因子由 1 增至 2 ，导致以 A 为根的子树失去平衡，需要一次向右的旋转操作，将 A 的左孩子 B 向右上旋转代替 A 成为根结点，将 A 结点向右下旋转成为 B 的右子树的根结点，而 B 的原右子树则作为 A 结点的左子树。由于在结点 A 的右孩子®的右子树®上插入了新结点，A 的平衡因子由 −1 减至 −2,导致以 A 为根的子树失去平衡，需要一次向左的旋转操作。
[学习笔记]用汇编语言编写一个函数 实现两个数相加
cyxvc
09-11 9393
用汇编语言编写一个函数 实现两个数相加
遍历PE文件头、扩展头、数据目录表、区段表信息
cyxvc
11-18 2949
遍历PE文件头、扩展头、数据目录表、区段表信息
[学习笔记]A星寻路算法实例
cyxvc
08-28 1361
A星寻路算法的实现，单击左键编辑障碍物，单击右键清除障碍物，双击右键开始自动寻路。
TLS回调函数的应用
cyxvc
10-22 1289
TLS回调函数是指，每当创建 / 终止进程的线程时会自动调用执行的函数。创建的主线程也会自动调用回调函数，且其调用执行先于EP代码。
[学习笔记]窗口子类化实例
cyxvc
10-02 1093
窗口子类化实例:点击一个按钮，在按钮本身的消息（按钮的消息回调函数）中弹出对话框，而不是在COMMAND（父类的消息回调函数）消息中弹出对话框。
郝斌数据结构视频学习笔记：线性与非线性结构解析
- 树：包含层级关系的数据结构，如二叉树、堆、AVL树等，广泛应用于文件系统、数据库索引等。 - 图：更复杂的非线性结构，表示节点间的多对多关系，如网络图、社交网络等。 5. 查找和排序 - 查找：在数据集合中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值