C++数据结构(上):模拟实现AVL

最新推荐文章于 2023-11-13 18:21:49 发布
最新推荐文章于 2023-11-13 18:21:49 发布
阅读量337 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RNGWGzZs/article/details/126016218
版权

 "我们无法一直活在过去,亦如我们从未能挽救死亡"

(1)AVL树:

概念:平衡搜索二叉树。

性质:

①根节点的左右子树 是AVL树

②左右子树的高度的差 不超过1

③比根节点大的 插在根节点的右边。 小的 在左边。

(2)AVL树模拟实现: 

 关于AVL树概念上的东西，多讲无用。我们现在直接来实现。

① 结构框架:

注:这里实现的是key值版。

//AVL树的 节点
template<class T>
struct AVLTreeNode
{
	//节点指针
	AVLTreeNode<T>* _left;
	AVLTreeNode<T>* _right;
	AVLTreeNode<T>* _parent;
	//节点数值
	T _key;  

	//为了调节平衡 这里引入平衡因子;
	int _bf;

	//构造
	AVLTreeNode(const T& key)
		:_left(nullptr),
		: _right(nullptr),
		_parent(nullptr),
		_key(key),
		_bf(0)      //任何新插入的 节点 平衡因子都默认设置为0
	{}

};

template<class K>
class AVLTree
{
	typedef AVLTreeNode<T> Node;

	AVLTree()
		:_root(nullptr)
	{}

private:
	Node* _root;
};

对于AVL树而言，显然难点在插入的部分。所以这留到最后讲。那么这部分进行相关功能的实现。

 ②查找+中序遍历:

	Node* find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if(key < cur->_key)
			{
				cur = cur->_left;
			}
			else
			{
				//找到了
				return cur;
			}
		}
		return nullptr;
	}


	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_key << endl;
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
	}

③检查平衡+析构:

	
	void _Destory(Node* root)
	{
		if (root == nullptr)
			return;
		_Destory(root->_left);
		_Destory(root->_right);
		delete root;
	}

     ~AVLTree()
	{
		_Destory(_root);
		_root =nullptr;
	} 


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

		int leftdepth = TreeHight(root->_left);
		int rightdepth = TreeHight(root->_right);

		//返回 左右子树 大的那个
		return leftdepth > rightdepth ? leftdepth + 1 : rightdepth + 1;
	}

	bool _isBalance(Node* root)
	{
		if (root == nullptr)
			return true;  //空树也是平衡树

		int Maxleft = TreeHight(_root->_left);
		int Maxright = TreeHight(_root->_right);

		return abs(Maxleft - Maxright) < 2
			&& _isBalance(root->_left)
			&& _isBalance(root->_right);
	}

	bool _isBalance()
	{
         return _isBalance(_root);
	}

 关于如何理解检查这棵树是否平衡的函数，也就不多赘述。因为在前面二叉树篇讲过。

下面就进入重头戏~

④AVL的插入;

        

	//如果是第一次插入 直接去做根 root
		if (_root == nullptr)
		{
			_root = new Node(k);
			return true;
		}

		//不是第一个值
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)  //这里和find的思想一样 
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//如果走到这里 说明 已经插入了和key 一样的数
				return true;
			}
		}

		//cur 走到空的位置了
		cur = new Node(key);
		Node* newnode = cur;

		//更新与parent的关系
		if (cur->_key  > parent->_key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		//注意我们设计的是三叉连 结构
		//cur 还有反过来 指向parent
		cur->_parent = parent;

 

任何一次对树数据的操作，都可能造成对树结构的破坏。

所以，为了 保护树的结构。我们需要根据不同情况，对树进行位置的更换

(1)平衡因子:

 我们让在根节点 右插入对 _bf ++ 

                                左插入 _bf--;

由此,每棵树节点的 平衡因子会分为三种情况。

 [0]  [-1,1]  [2,-2]

 

	//调节平衡因子;
		//while(parent)
		while (cur != root)
		{
		   //更新节点bf
			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;
			}
			else if(parent->_bf == -2 || parent->_bf == 2)
			{
				//调整
			}
			else
			{
				//理论上不会走到这里来
				//如果走到这里来 也是调整前 已经不是AVL数
				assert(false);
			}
		}

 

(2)左右单旋:

 我们在看单旋图中,就是bf=-1,1 的节点(也就是parent) 是旋转的轴。

	else if(parent->_bf == -2 || parent->_bf == 2)
			{
				//调整
				//左边新增节点
				if (parent->_bf == -2)  
				{
					if (cur->_bf == -1) //新节点在左边插入
					{
						//左高 右边低 需要右翻转
						RotateR(parent);
					}
					else  //新增节点插入在右边
					{

					}
				}
				else //右边新增节点
				{
					if (cur->_bf == 1)  //新节点从右边插入
					{
						//此时 右高 左低 需要 右翻转
						RotateL(parent);
					}
					else //新增节点在左边
					{

					}
				}
				//翻转完 就跳出
				break;
			}

这也就是单旋插入的逻辑。

右单旋实现:

也及时sub subLR parent 三方的关系;

 

	void RotateR(Node* parent)
	{
		Node* sub = parent->_left;
		Node* subLR = sub->_right;

		//让subLR去做parent的左
		parent->_left = subLR;
		//subLR可能不存在
		if(subLR)
		subLR->_parent = parent;

		sub->_right = parent;
		//记录 父节点 因为 sub 可能不是唯一独立的树
		Node* grandparent = parent->_parent;
		parent->_parent = sub;

		if (parent == _root)
		{
			//独立树
			_root = sub;
			sub->_parent = nullptr;
		}
		else
		{
			//子树
			//parent的 父亲仍然保留着 节点地址
			if (grandparent->_left == parent)
			{
				grandparent->_left = sub;
			}
			else
			{
				grandparent->_right = sub;
			}
			//更新回来
			sub->_parent = grandparent;
		}
		
		//调节平衡因子
		parent->_bf = sub->_bf = 0;
	}

 

 

	RotateL(Node* parent)
	{
		Node* sub = parent->_right;
		Node* subRL = sub->_left;

		//让subRL 去做parent的右边
		parent->_right = subRL;
		//仍然注意避坑
		if(subRL)
			subRL->_parent = parent;

		Node* grandparent = parent->_parent;
		sub->_left = parent;
		parent->_parent = sub;

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

(3)双旋转:

左右双旋转:
 

	void RotateLR(Node* parent)
	{
		Node* sub = parent->_left;
		Node* subLR = sub->_right;
		//保存插入处 的平衡因子~
		int bf = subLR->_bf;

		RotateL(sub);
		RotateR(parent);

		//调整平衡因子
		if (bf == -1)  //左边B插入
		{
			sub->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 1;
		}
		else if(bf ==1)
		{
			sub->_bf = -1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if(bf ==0)
		{
			sub->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

右左双旋:

这个同上也就 不再多分析。

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

		RotateR(sub);
		RotateL(parent);

		if (bf == 1) //从C插入
		{
			subRL->_bf = 0;
			sub->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subRL->_bf = 0;
			sub->_bf = 1;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subRL->_bf = 0;
			sub->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

④测试;

插入也就到此为止,我们先来试着跑几组数据看是否正确。

 

 (3)K、V版AVL 树

namespace dy
{
	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;

		//构造
		AVLTreeNode(const pair<K,V>& kv)
			:_left(nullptr),
			_right(nullptr),
			_parent(nullptr),
			_kv(kv),
			_bf(0)      //任何新插入的 节点 平衡因子都默认设置为0
		{}
	};

	template<class K,class V>
	struct AVLTreeKV
	{
		typedef AVLTreeNode<K, V> Node;
		Node* _root;

		AVLTreeKV()
			:_root(nullptr)
		{}

		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_kv.first << ":"<<root->_kv.second<<endl;
			_InOrder(root->_right);
		}


		//没封装迭代器 暂且用Node* 替
		pair<Node*,bool> insert(const pair<K,V> kv)
		{
			//如果是第一次插入 直接去做根 root
			if (_root == nullptr)
			{
				_root = new Node(kv);
				return make_pair(_root,true);
			}

			//不是第一个值
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)  //这里和find的思想一样 
			{
				if (kv.first > cur->_kv.first)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (kv.first < cur->_kv.first)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//如果走到这里 说明 已经插入了和key 一样的数
					return make_pair(cur,true);
				}
			}

			//cur 走到空的位置了
			cur = new Node(kv);
			Node* newnode = cur;

			//更新与parent的关系
			if (cur->_kv.first > parent->_kv.first)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			//注意我们设计的是三叉连 结构
			//cur 还有反过来 指向parent
			cur->_parent = parent;

			//调节平衡因子;
			//while(parent)
			while (cur != _root)
			{
				//更新节点bf
				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)
					{
						if (cur->_bf == -1) //新节点在左边插入
						{
							//左高 右边低 需要右翻转
							RotateR(parent);
						}
						else  //新增节点插入在右边
						{
							//此时 是折线
						   //使用双旋
							RotateLR(parent);
						}
					}
					else //右边新增节点
					{
						if (cur->_bf == 1)  //新节点从右边插入
						{
							//此时 右高 左低 需要 右翻转
							RotateL(parent);
						}
						else //新增节点在左边
						{
							RotateRL(parent);
						}
					}
					//翻转完 就跳出
					break;
				}
				else
				{
					//理论上不会走到这里来
					//如果走到这里来 也是调整前 已经不是AVL数
					assert(false);
				}
			}
			return make_pair(newnode,true);
		}

}

 

总结: 

①AVL树 插入节点时很看重平衡因子。

②平衡因子条件 [0] [-1,1] [-2,2]

③单旋是直线 双旋 为折线

内容到这里也就结束啦，感谢你的阅读。

祝你好运~

 

WGzZsyu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
VC++自动数据模拟生成趋势图源码
08-14
VC++自动数据模拟生成趋势图源码，可以编译通过，仅供参考
c++对象模拟游戏数据
Cineze的博客
08-16 451
C中的结构体存在缺点：1.main函数中的任意赋值语句都可以访问结构体中的成员，但在现实生活中并不是什么数据都可以被随意访问的，因此C语言中的结构体的数据是不安全的；2.结构体中的数据和对该数据的操作是分离的，并不是一个被封装起来的整体，因此使程序难以重用，影响了软件生产效率；于是C++中引入了类的概念。 　　C++中类的一般格式为： class Kid { 　　priva
AVL树的模拟实现
qq_56663697的博客
02-25 257
文章目录AVL树的概念AVL树节点的定义AVL树的插入AVL树的旋转右单旋左单旋先左单旋再右单旋先右单旋再左单旋AVL树的验证AVL树的性能 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进
AVL Tree
热门推荐
hebtu666
12-18 1万+
前言   希望读者 了解二叉搜索树 了解左旋右旋基本操作 https://blog.csdn.net/hebtu666/article/details/84992363 直观感受直接到文章底部，有正确的调整策略动画，自行操作。 二叉搜索树   二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子...
C++数据结构期末课程项目设计：源码+报告
10-19
在本项目设计中，主题是"C++数据结构期末课程项目"，这通常涵盖了一系列与C++编程、数据结构以及算法相关的复杂概念。数据结构是计算机科学的基础，它研究如何有效地存储和检索数据，以优化程序的性能。在这个项目中...
C、C++数据结构.zip
06-27
在这个“C、C++数据结构.zip”文件中，我们主要探讨的是如何在C和C++中实现和应用基本的数据结构。 1. **数组**：数组是最基础的数据结构，它是一个存储固定大小同类型元素的集合。在C和C++中，数组可以通过声明...
c++实现数据结构，代码很全.zip
11-24
5. **树**：树数据结构模拟了自然界中的树状结构，每个节点包含数据和指向子节点的指针。常见的树有二叉树、二叉搜索树、平衡树（如AVL树和红黑树）等。树在搜索、排序等领域有着广泛应用。 6. **图**：图是由顶点...
《数据结构》算法模拟动画.zip
06-16
C/C++/JAVA/Python是编程语言中的四巨头，它们都被广泛用于实现数据结构和算法。这个压缩包“《数据结构》算法模拟动画.zip”显然是为帮助大学生们深入理解和掌握数据结构而设计的，它包含多种编程语言的学习笔记和...
《数据结构与算法分析》上的代码实现.zip
最新发布
06-16
在C/C++/JAVA/Python中，常见数据结构包括数组、链表、栈、队列、树（如二叉树、平衡树AVL和红黑树）、图以及哈希表等。数组是最基础的数据结构，提供了随机访问的便利；链表则通过指针或引用连接元素，便于插入和...
【C++笔记】AVL树的模拟实现
kk702392702的博客
11-13 259
/ 定义AVL树节点int _bf;// 平衡因子// 构造,_val(key),_bf(0){}// AVL树public:// ……
【C++】模拟实现List 功能
ly_6699的博客
03-17 318
List.h #define _CRT_SECURE_NO_WARNINGS 1 #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #include &lt;assert.h&gt; #include &lt;algorithm&gt;//算法头文件 #include &lt;iostream&gt; using namespace std; ...
C++之AVL树和红黑树
weixin_56054625的博客
09-27 690
因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不过与删除不同的是，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。，更差的是在删除时，有可能一直要让旋转持续到根的位置。
（C++进阶）二叉搜索树 （K KV）
qq_57594025的博客
07-22 345
个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树。③如果根节点key>查找key，在其左子树查找。如果根节点key...
C/C++ 模拟小型数据库系统(DBMS)
TK_wang_的博客
06-22 7320
模拟了数据库的创建，删除(文件夹)，数据表的创建，删除(.txt文件)以及数据的增加、查询、修改和删除(简化)，用基本的几条SQL语言来进行操纵，即代码中的说明。 #include <iostream> #include <string> #include <vector> #include <cstdio> #include <string> #include <sstream> #include <iomanip> #
C++ 数据结构与算法（三）（滑动窗口、模拟）
chenyfan_blog
02-24 2087
滑动窗口 模拟 代码随想录 LeetCode
C++ 模拟报数
Object_的博客
09-21 1452
缘起:普及练习场-线性数据结构-约瑟夫问题 先上代码 #include&amp;amp;lt;cstdio&amp;amp;gt; #include&amp;amp;lt;iostream&amp;amp;gt; using namespace std; int data[101];//数据 int n,m; int index; int count=0; int main(){ //cout&amp;amp;lt;&amp;a
C++算法篇 模拟算法
流年的博客
07-30 9046
1、接水问题NOIP2010普及组 题目描述 学校里有一个水房，水房里一共装有m个龙头可供同学们打开水，每个龙头每秒钟的供水量相等，均为1。 现在有n名同学准备接水，他们的初始接水顺序已经确定。将这些同学按接水顺序从1到n编号，i号同学的接水量为wi​。接水开始时，1到m号同学各占一个水龙头，并同时打开水龙头接水。当其中某名同学jj完成其接水量要求wj​后，下一名排队等候接水的同学k马上接替j同学的位置开始接水。这个换人的过程是瞬间完成的，且没有任何水的浪费。即j同学第x秒结束时完...
C++版数据结构和算法课程
05-07
本课程主要探讨的是C++实现的数据结构和算法，对于学习者来说，这是提升编程能力和解决问题能力的重要途径。首先，课程介绍了大O记法，这是一种衡量算法效率的方法，它描述了算法在最坏情况下的运行时间增长趋势。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值