C++ AVLTree 的实现

最新推荐文章于 2024-05-13 09:55:25 发布
最新推荐文章于 2024-05-13 09:55:25 发布
阅读量31 收藏 1
点赞数 3
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eyuyanniniu/article/details/132836312
版权

AVLTree前言：二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年
发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

目录：

  • AVLTree特性
  • AVLTree定义
  • AVLTree插入
    • 插入第一步
    • 插入第二步
  • AVLTree旋转过程
    • 单旋转的抽象图
    • 单旋旋转过程
    • 双旋转抽象图
    • 双旋转抽象过程
  • AVLTree实现

AVLTree特性

  • 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
  • 它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
    在这里插入图片描述

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 O ( l o g 2 n ) O(log_2 n) O(log2​n)，搜索时间复杂度O( l o g 2 n log_2 n log2​n)

AVLTree定义

在这里插入图片描述

template<class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& data = T())
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _bf(0)
	{}

	AVLTreeNode<T>* _pLeft;
	AVLTreeNode<T>* _pRight;
	AVLTreeNode<T>* _pParent;
	T _data;
	int _bf;   // 节点的平衡因子
};

AVLTree插入

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

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

第一步的过程：

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

在这里插入图片描述

请添加图片描述

第二步的过程：

调整节点的平衡因子
在这里插入图片描述
请添加图片描述

旋转过程

旋转有四种旋转：左单旋，右单旋，左右双旋，右左双旋

单旋转的抽象图

AVLTree的抽象图是抽象子树的高度
长方形代表所有平衡的子树

左单旋、右单旋抽象图

在这里插入图片描述

单旋旋转过程

代码实现：要注意的点

  1. grandparent是否为根
  2. curLeft是否为空
  3. 不仅要更新左右孩子指针，还有更新父亲指针
  4. 一共涉及四个结点的改动：
    1.grandparent的parent
    2.grandparent
    3.cur
    4.curLeft
    在这里插入图片描述

请添加图片描述

右单旋类似于左单旋
左右单旋实现代码如下

// 右单旋
	void RotateR(Node* pParent)
	{
		Node* grandparent = pParent->_pParent;
		Node* cur = pParent->_pLeft;
		Node* curRight = cur->_pRight;

		cur->_pRight = pParent;
		cur->_pParent = grandparent;

		pParent->_pLeft = curRight;
		pParent->_pParent = cur;

		if (curRight)
			curRight->_pParent = pParent;
		if (pParent == _pRoot)
		{
			_pRoot = cur;
		}
		else
		{
			if (grandparent->_pLeft == pParent)
			{
				grandparent->_pLeft = cur;
			}
			else
			{
				grandparent->_pRight = cur;
			}
		}
		pParent->_bf = cur->_bf = 0;
	}
	// 左单旋
	void RotateL(Node* pParent)
	{
		Node* grandparent = pParent->_pParent;
		Node* cur = pParent->_pRight;
		Node* curLeft = cur->_pLeft;

		cur->_pLeft = pParent;
		cur->_pParent = grandparent;

		pParent->_pRight = curLeft;
		pParent->_pParent = cur;

		if (curLeft)
			curLeft->_pParent = pParent;
		if (pParent == _pRoot)
		{
			_pRoot = cur;
		}
		else
		{
			if (grandparent->_pLeft == pParent)
			{
				grandparent->_pLeft = cur;
			}
			else
			{
				grandparent->_pRight = cur;
			}
		}
		pParent->_bf = cur->_bf = 0;
	}

双旋转抽象图

第一种情况
在这里插入图片描述

第二种情况
左边为左右双旋，右边为右左双旋
在这里插入图片描述

双旋旋转过程

在这里插入图片描述

请添加图片描述

右左单旋类似于左右单旋
双旋实现代码如下

// 右左双旋
	void RotateRL(Node* pParent)
	{
		Node* cur = pParent->_pRight;
		Node* curLeft = cur->_pLeft;

		if (curLeft->_bf == 1)
		{
			RotateR(cur);
			RotateL(pParent);
			curLeft->_bf = 0;
			pParent->_bf = -1;
			cur->_bf = 0;
		}
		else if (curLeft->_bf == -1)
		{
			RotateR(cur);
			RotateL(pParent);
			cur->_bf = 1;
			pParent->_bf = curLeft->_bf = 0;
		}
		else
		{
			RotateR(cur);
			RotateL(pParent);
			pParent->_bf = curLeft->_bf = cur->_bf = 0;
		}

	}
	// 左右双旋
	void RotateLR(Node* pParent)
	{
		Node* cur = pParent->_pLeft;
		Node* curRight = cur->_pRight;

		if (curRight->_bf == 1)
		{
			RotateL(cur);
			RotateR(pParent);
			cur->_bf = -1;
			curRight->_bf = pParent->_bf = 0;
		}
		else if (curRight->_bf == -1)
		{
			RotateL(cur);
			RotateR(pParent);
			cur->_bf = curRight->_bf = 0;
			pParent->_bf = 1;
		}
		else
		{
			RotateL(cur);
			RotateR(pParent);
			pParent->_bf = curRight->_bf = cur->_bf = 0;
		}
	}

AVLTree代码实现如下


template<class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& data = T())
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _bf(0)
	{}

	AVLTreeNode<T>* _pLeft;
	AVLTreeNode<T>* _pRight;
	AVLTreeNode<T>* _pParent;
	T _data;
	int _bf;   // 节点的平衡因子
};


// AVL: 二叉搜索树 + 平衡因子的限制
template<class T>
class AVLTree
{
	typedef AVLTreeNode<T> Node;
public:
	AVLTree()
		: _pRoot(nullptr)
	{}

	// 在AVL树中插入值为data的节点
	bool Insert(const T& data)
	{
		if (_pRoot == nullptr)
		{
			_pRoot = new Node(data);
			return true;
		}
		Node* cur = _pRoot;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_data < data)
			{
				parent = cur;
				cur = cur->_pRight;
			}
			else if (cur->_data > data)
			{
				parent = cur;
				cur = cur->_pLeft;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(data);
		if (parent->_data > cur->_data)
		{
			parent->_pLeft = cur;
		}
		else
		{
			parent->_pRight = cur;
		}
		cur->_pParent = parent;

		while (parent)
		{
			if (parent->_pRight == cur)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}

			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == -1 || parent->_bf == 1)
			{
				cur = parent;
				parent = parent->_pParent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//旋转
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				break;
				// AVL树的验证
				bool IsAVLTree()
				{
					return _IsAVLTree(_pRoot);
				}
			}
			else
			{
				assert("违反平衡因子规则");
			}
		}

	}
	

private:
	// 根据AVL树的概念验证pRoot是否为有效的AVL树
	bool _IsAVLTree(Node* pRoot)
	{
		if (pRoot == nullptr)
			return true;
		int leftH = _Height(pRoot->_pLeft);
		int rightH = _Height(pRoot->_pRight);
		if (leftH - rightH > 1 || leftH - rightH < -1)
			return false;

		_IsAVLTree(pRoot->_pLeft);
		_IsAVLTree(pRoot->_pRight);
		return true;
	}
	size_t _Height(Node* pRoot)
	{
		if (pRoot == nullptr)
			return 0;
		int leftH = _Height(pRoot->_pLeft) + 1;
		int rightH = _Height(pRoot->_pRight) + 1;
		if (leftH > rightH)
		{
			return leftH;
		}
		else
		{
			return rightH;
		}
	}
	// 右单旋
	void RotateR(Node* pParent)
	{
		Node* grandparent = pParent->_pParent;
		Node* cur = pParent->_pLeft;
		Node* curRight = cur->_pRight;

		cur->_pRight = pParent;
		cur->_pParent = grandparent;

		pParent->_pLeft = curRight;
		pParent->_pParent = cur;

		if (curRight)
			curRight->_pParent = pParent;
		if (pParent == _pRoot)
		{
			_pRoot = cur;
		}
		else
		{
			if (grandparent->_pLeft == pParent)
			{
				grandparent->_pLeft = cur;
			}
			else
			{
				grandparent->_pRight = cur;
			}
		}
		pParent->_bf = cur->_bf = 0;
	}
	// 左单旋
	void RotateL(Node* pParent)
	{
		Node* grandparent = pParent->_pParent;
		Node* cur = pParent->_pRight;
		Node* curLeft = cur->_pLeft;

		cur->_pLeft = pParent;
		cur->_pParent = grandparent;

		pParent->_pRight = curLeft;
		pParent->_pParent = cur;

		if (curLeft)
			curLeft->_pParent = pParent;
		if (pParent == _pRoot)
		{
			_pRoot = cur;
		}
		else
		{
			if (grandparent->_pLeft == pParent)
			{
				grandparent->_pLeft = cur;
			}
			else
			{
				grandparent->_pRight = cur;
			}
		}
		pParent->_bf = cur->_bf = 0;
	}
	// 右左双旋
	void RotateRL(Node* pParent)
	{
		Node* cur = pParent->_pRight;
		Node* curLeft = cur->_pLeft;

		if (curLeft->_bf == 1)
		{
			RotateR(cur);
			RotateL(pParent);
			curLeft->_bf = 0;
			pParent->_bf = -1;
			cur->_bf = 0;
		}
		else if (curLeft->_bf == -1)
		{
			RotateR(cur);
			RotateL(pParent);
			cur->_bf = 1;
			pParent->_bf = curLeft->_bf = 0;
		}
		else
		{
			RotateR(cur);
			RotateL(pParent);
			pParent->_bf = curLeft->_bf = cur->_bf = 0;
		}

	}
	// 左右双旋
	void RotateLR(Node* pParent)
	{
		Node* cur = pParent->_pLeft;
		Node* curRight = cur->_pRight;

		if (curRight->_bf == 1)
		{
			RotateL(cur);
			RotateR(pParent);
			cur->_bf = -1;
			curRight->_bf = pParent->_bf = 0;
		}
		else if (curRight->_bf == -1)
		{
			RotateL(cur);
			RotateR(pParent);
			cur->_bf = curRight->_bf = 0;
			pParent->_bf = 1;
		}
		else
		{
			RotateL(cur);
			RotateR(pParent);
			pParent->_bf = curRight->_bf = cur->_bf = 0;
		}
	}


private:
	Node* _pRoot;
};
im长街
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AVLTree的C++的实现
qq_46655061的博客
02-18 502
AVL树的添加元素实现，主要的旋转讲解。
【C++】AVL Tree总结
HenryBlog
04-21 1290
文章目录一、AVL Tree概念二、左/右单旋三、左/右双旋 一、AVL Tree概念 上次我们介绍的二叉搜索树也有弊端，如果数据是有序或接近有序二叉搜索树将退化为单枝，相当于查找时在顺序表中搜索元素，效率变的很低。 我们这里介绍的AVL是一颗高度平衡的二叉搜索树，如果他有n个节点，其高度保持在O(log2n)，搜索时间复杂度为O(log2n)。 AVL树的要求是，保证每个节点的左右子树高低之差绝对值不超过1 具体在树的结构里面加入一个平衡因子，去衡量二叉树的左右高度差是不是超过1，通过右边高度来减左边高
模拟实现AVLTree超详解（C++）
m0_67430750的博客
05-09 828
模拟实现AVLTree万字详解，包括了KV模型和K模型。同时封装了正反迭代器（const和非const）。
AvlTree的C++实现
小昊
06-03 175
#ifndef AVL_TREE_H #define AVL_TREE_H #include "dsexceptions.h" #include <algorithm> #include <iostream> using namespace std; // AvlTree class // // CONSTRUCTION: zero parameter // // ******************PUBLIC OPERATIONS*********************
c++实现AVL_tree
A_Bo的博客
10-23 752
写在前面 AVL_Tree是一棵自平衡的二叉树，在树中任意节点的左右子树之间的高度差小于等于1，很好的弥补了二叉搜索树有可能出现不平衡的情况，只是在二叉搜索树的基础上添加了四种旋转操作，使二叉搜索树变成自平衡的二叉搜索树 AVLTree的数据结构 首先它是一个二叉树，那么他一定包含左右子节点的信息，并且为了方便进行高度的判断调整等，还要包含高度信息，最后还要有当前节点的数值信息，所以他的数据...
AVL树(C++实现)
清欢Allen的技术博客
04-14 1052
我们实现的是KV模型的AVL树,为了方便后续的操作,这里AVL树结点定义为三叉链结构,并且引入平衡因子,方便判断每棵树的平衡情况,并且还需要一个初始化列表将结点成员全部初始化.//三叉链 AVLTreeNode < K , V > * _left;//存储键值对 int _bf;
AVLTree的实现C++
C++
02-22 254
普通的binary Search Tree的大量插入删除操作会造成树的不平衡，使得查找等操作效率不再为O(logn)。 AVLTree能够保证插入，删除，查找等操作在O(logn)内完成。 组成AVLTree的最少节点数与斐波那契数列的关系。 AVLTree的插入操作完成插入后需要更新节点的高度信息，并重新平衡此树， 找到发现问题的节点（imbalance factor == 2），并平衡以...
AVL tree 实现 dictionary
m0_74835917的博客
12-11 122
用平衡树实现字典，查找开头字符串
C++实现AVL Tree（平衡二叉树）的构建与增删
weixin_51049319的博客
01-30 265
C++实现AVL Tree（平衡二叉树）的构建与增删
avltree实现
10-16
平衡二叉树实现 平衡二叉树的实质就是保持树“尽量胖，尽量矮
C++平衡Avl树实现.zip
08-20
C++平衡树实现
AVLTree自平衡二叉树C++模板类实现
01-19
使用C++实现的AVLTree自平衡二叉树，支持动态插入与删除操作，供C++数据结构课程学习与交流使用。
AVLTree 平衡二叉树c++实现
06-26
c++平衡二叉树的实现 带内存分配，非常全面 ，有错误欢迎留言
AVLTree:AVL 树的 C++ 实现
07-01
AVL树AVL 树的 C++ 实现
C++ 使用matplot++ 处理数据生成svg图表
最新发布
小蝈蝈的博客
05-13 159
python的图表库很丰富，C++依赖于python的 matplotlib的库却有很多功能不足，显得很鸡肋，其他的一些库没有过多的研究，Matplot++编译需要依赖一堆第三方库，可以参考官网，但是github上也提供了编译好的静态库，使用Matplot++同时需要下载安装gnuplot，并将gnuplot的bin加入到环境变量。将include、lib加入到对应的位置，并配置好路径和库连接，这部分不多说了。这里主要说说不依赖于python的纯C++ 的图表库 Matplot++
Linux学习C语言版 LED 灯实验
qq_44219883的博客
05-10 652
大部分情况下都是使用 C 语言去编写的。只是在开始部分用汇编来初始化一下 C 语言环境，比如初始化 DDR、设置堆栈指针 SP 等等，当这些工作都做完以后就可以进入 C 语言环境，也就是运行 C 语言代码，一般都是进入 main 函数。所以我们有两部分文件要做：①、汇编文件汇编文件只是用来完成 C 语言环境搭建。②、C 语言文件C 语言文件就是完成我们的业务层代码的，其实就是我们实际例程要完成的功能。
UE5C++ FString做为参数取值时报错error：C4840
YanisWu的博客
05-11 177
UE5 C++ 的FString类型取值问题。
多线程测试+互斥锁（1）【C++】
weixin_45690131的博客
05-10 232
多线程测试
帮我实现一个 c++ AVL树
03-04
好的，我可以帮您实现一... printf("Preorder traversal of the constructed AVL tree is: \n"); preOrder(root); return ; } ``` 这是一个简单的 AVL 树实现，包括插入和前序遍历。您可以根据需要进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值