C++中“AVL”树的模拟实现以及实现中遇见的问题

最新推荐文章于 2024-08-16 23:08:36 发布
最新推荐文章于 2024-08-16 23:08:36 发布
阅读量210 收藏 7
点赞数 10
分类专栏： C++日常笔记 文章标签： c++ 数据结构 b树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sakeww/article/details/125018860
版权

目录


高度平衡二叉搜索树

1. insert

一、先按照搜索树的规则找到插入点
二、插入数据
三、此时的树会发生变化
但是：
（1）在没有插入这个节点的时候，这个树还是高度平衡的，也就是说这个树的所有节点的平衡因子都是0或者1
（2）因为这个节点的插入，这个节点的所有父节点都会发生变化，我们按照规则将其（这些父节点的bf）重新赋值
1.curparent->left parent->bf–;
2.curparent->right parent->bf++:
3.更新以后，parent->bf0,更新结束。
说明：更新前parent->bf 是1或者-1，现在变成0，说明填上矮的那边，parent所在的子树高度不变
4.更新之后，parent->bf1/-1 继续往上更新。
说明：更新前，parent->bf 是0，现在变成1或者-1，我有一边变高了，parent所在的子树高度变了
5.更新以后，parent->bf==2/-2,parent所在子树已经不平衡了，需要旋转处理。
四、关于旋转处理
在这里插入图片描述
个人对这个旋转处理的理解：

  1. 一共四种情况，如果出现第五种情况，那么只能说明你的上一次旋转处理，处理的有问题，也就是你的代码写的有问题
  2. 比较难理解的是第一个和第三个
  3. 第一个
    在这里插入图片描述需要变动的线，也就只有这两条，建议仔细观看这两条线段的变化，最好自己画一下，（不知道怎么说）
  4. 第三个在这里插入图片描述需要变动的只是这三条线段，这三个线段的前世今生我也标记出来了

温馨提醒：这个代码有问题，但是整体思路是符合上述分析的那些点的

	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;
			cur->_parent = parent;
		}
		else{
			parent->_left = cur;
			cur->_parent = parent;
		}
		//cur新增，只会影响cur祖先节点的平衡因子
		//控制平衡
		//1.更新平衡因子---新增节点到根节点的祖先路径
		//2.出现异常的平衡因子，就需要旋转平衡处理
		while (parent)
		{
			if (cur == parent->_left)
				parent->_bf--;
			else
				parent->_bf++;

			if (parent->_bf == 0)
				break;
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				//继续往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//旋转处理
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1) // 左单旋
				{
					RotateL(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 RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* parentParent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

		if (_root == parent){
			_root = subR;
			subR->_parent = nullptr;
		}
		else{
			if (parentParent->_left == parent)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;
			subR->_parent = parentParent;
		}
		subR->_bf = parent->_bf = 0;
	}

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if(subLR) subLR->_parent = parent;//subLR可能为空
		Node* parentparent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (parentparent->_left == parent)
				parentparent->_left = subL;
			else
				parentparent->_right = subL;
			subL->_parent = parentparent;
		}
		subL->_bf = 0;
		parent->_bf = 0;
	}
	void RotateLR(Node* parent)
	{
		RotateL(parent->_left);
		RotateR(parent);
	}

	void RotateRL(Node* parent)
	{
		RotateR(parent->_right);
		RotateL(parent);
	}

最终理解草图：
在这里插入图片描述

2. 如何判断你的AVL树符合规则

高度平衡

1.检查平衡因子？
不行，
因为平衡因子是你规定的，在你的代码中可能会直接设置的“正确”
2.检查高度？

	int Height(Node* root)
	{
		if (root == nullptr) return 0;

		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		return max(leftHeight, rightHeight)+1;
	}

	bool IsBalance()//balance均衡
	{
		return _IsBalance(_root);
	}
	bool _IsBalance(Node* root)
	{
		if (root == NULL) return true;

		//对当前树进行检查
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

平衡因子是否正确

	bool _IsBalance(Node* root)
	{
		if (root == NULL) return true;

		//对当前树进行检查
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		if (rightHeight - leftHeight != root->_bf)
		{
			cout << root->_kv.first << "现在是:" << root->_bf << endl;
			cout << root->_kv.first << "应该是:" << rightHeight - leftHeight << endl;
			return false;
		}

		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

开始检查

当输入为：int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
在这里插入图片描述

出现问题

解决步骤：
在这里插入图片描述
在这里插入图片描述
则可以推出是插入14时，出现问题

根据监控可以画出这个二叉树
在这里插入图片描述
可以推出是双旋出了问题
双旋分为两种类型，各自三种情况
在这里插入图片描述

在这里插入图片描述

	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == 1)
		{
			parent->_bf = 0;
			subR->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

3.最终代码

#pragma once

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)
		,_bf(0)
		,_kv(kv)
	{}
};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
		:_root(nullptr)
	{}

	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;
			cur->_parent = parent;
		}
		else{
			parent->_left = cur;
			cur->_parent = parent;
		}
		//cur新增，只会影响cur祖先节点的平衡因子
		//控制平衡
		//1.更新平衡因子---新增节点到根节点的祖先路径
		//2.出现异常的平衡因子，就需要旋转平衡处理
		while (parent)
		{
			if (cur == parent->_left)
				parent->_bf--;
			else
				parent->_bf++;

			if (parent->_bf == 0)
				break;
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				//继续往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//旋转处理
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1) // 左单旋
				{
					RotateL(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 RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* parentParent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

		if (_root == parent){
			_root = subR;
			subR->_parent = nullptr;
		}
		else{
			if (parentParent->_left == parent)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;
			subR->_parent = parentParent;
		}
		subR->_bf = parent->_bf = 0;
	}

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if(subLR) subLR->_parent = parent;//subLR可能为空
		Node* parentparent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (parentparent->_left == parent)
				parentparent->_left = subL;
			else
				parentparent->_right = subL;
			subL->_parent = parentparent;
		}
		subL->_bf = 0;
		parent->_bf = 0;
	}
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == 1)
		{
			parent->_bf = 0;
			subR->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	
	void InOder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root == NULL) return;
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}
	 
	int Height(Node* root)
	{
		if (root == nullptr) return 0;

		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		return max(leftHeight, rightHeight)+1;
	}

	bool IsBalance()//balance均衡
	{
		return _IsBalance(_root);
	}
	bool _IsBalance(Node* root)
	{
		if (root == NULL)
			return true;

		// 对当前树进行检查
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		if (rightHeight - leftHeight != root->_bf)
		{
			cout << root->_kv.first << "现在是:" << root->_bf << endl;
			cout << root->_kv.first << "应该是:" << rightHeight - leftHeight << endl;
			return false;
		}

		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

private:
	Node* _root;
};

void TestAVLTree()
{ 
	AVLTree<int, int> t;
	int a[] = {4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
		cout << t.IsBalance() << endl;//检查代码
	}
	t.InOder();
	cout << t.IsBalance() << endl;
}
sakeww
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
【C/C++】AVL树的特点及模拟实现
Yfan133的博客
02-08 256
文章目录AVL树的特点AVL插入后的四种场景代码实现 AVL树的特点 二叉搜索树可以使查找的效率提升到log2nlog_2nlog2​n，但如果数据基本有序那么二叉搜索树会退化成单枝树，查找效率相当于在顺序表中搜索数据，效率低。两种平衡二叉搜索树解决了这个问题：AVL树和红黑树 AVL树特点： 每个节点的左右子树高度差的绝对值不超过1，即降低了树的高度，从而降低平均搜索时间 空树也是AVL树，AVL树的每颗子树都是AVL树 因此AVL树每进行一次插入删除操作都要保证树的平衡 AVL插入后的四种场景
C++模板实现的AVL树
eskimoer的专栏
11-03 3280
1 AVL树的定义 AVL树是一种自平衡二叉排序树，它的特点是任何一个节点的左子树高度和右子树的高度差在-1,0,1三者之间。AVL树的任何一个子树都是AVL树。 2 AVL树的实现 AVL树本质是一种二叉排序树，所以二叉排序树的任何性质AVL树都具有，但是AVL树稍微复杂的地方就是AVL树必须满足平衡条件，具体跟BST不同的地方主要体现在插入，删除操作。 插入操作：当插入之后可能会出现不
红黑树/红黑树迭代器封装（C++）
m0_74830524的博客
06-10 1422
本篇将会较为全面的讲解有关红黑树的特点，插入操作，然后使用代码模拟实现红黑树，同时还会封装出红黑树的迭代器。 在 STL 库中的 set 和 map 都是使用红黑树封装的，在前文中我们讲解了 AVL树，对于红黑树和 AVL 树来说，这两种树都是效率很高的搜索二叉树，但是相对而言 AVL 树会更加接近平衡二叉树，但是用于封装 set 和 map 的却是红黑树，这是因为虽然红黑树不是很接近平衡二叉树，但是和 AVL 树的搜索效率相比较其实相差不是很多，相反而言，对于红黑树在插入时
C++中“map和set”相关内容整理分析
sakeww的博客
06-02 242
目录1. 关联式容器2. 键值对3. 树形结构的关联式容器set 和 map简单使用：set简单使用inserterasevs multisetfinderasemap的简单使用insert4. 底层结构5. 作业 1. 关联式容器 STL将自己的数据结构分为六大组件， 容器分为： 序列式容器：vector list … 类似于数据结构中的线性表，数据和数据之间没有关联，为了单纯的存储数据， 关联式容器：map和set… 底层是：平衡搜索树，数据和数据之间具有强烈的关系 2. 键值对 3. 树形结构的关联式
C++平衡Avl树实现.zip
08-20
在C++中，我们通常通过定义一个结构体或类来表示AVL树的节点。节点包含三个主要部分：键（key）、值（value）和三个辅助字段：高度（height）、左子树指针（left）和右子树指针（right）。例如： ```cpp struct ...
AVL树 C++ 实现
03-05
在C++中实现AVL树，我们可以利用模板类来创建一个泛型的数据结构，这样就可以处理不同类型的元素。 首先，我们需要定义AVL树的节点结构。每个节点包含三个部分：键（key）存储元素值，高度（height）用于计算树的...
AVL树的c++实现
08-03
在C++中实现AVL树，我们可以利用模板类来增强代码的通用性，并通过智能指针如`shared_ptr`来管理内存，避免内存泄漏。 首先，我们需要定义一个AVL树节点结构体，包括节点值、高度、左子树和右子树的指针。由于我们...
AVL树的模拟实现代码
06-19
AVL树代码
C++实现AVL树
11-15
C++实现AVL树,有兴趣的可以看看，可能不是很好，仅作为参考
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 203
C语言 | Leetcode C语言题解之第337题打家劫舍III
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 766
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
【C++】一文掌握C++中的IO流
JLX_1的博客
08-16 440
本文详细讲解了C++中的IO流体系，讲解了各种接口的使用方法！
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 226
C++ | Leetcode C++题解之第337题打家劫舍III
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 936
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 956
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
C++ 126类和对象_面像对像_继承
最新发布
cjh16606260986的博客
08-16 195
126类和对象_面像对像_继承
C语言 ——— 修改默认对齐数以及结构传参
weixin_55341642的博客
08-16 267
在上一篇中，有讲解到结构体内存对齐的规则以及默认对齐数C语言 ——— 结构体内存对齐-CSDN博客。
C++_基本语法笔记_继承和多态
qq_45629864的博客
08-13 551
思想与Java差不多。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值