【数据结构】一步一步实现AVL树

最新推荐文章于 2024-06-24 17:49:50 发布
最新推荐文章于 2024-06-24 17:49:50 发布
阅读量452 收藏 7
点赞数 6
分类专栏： 数据结构 CPP 文章标签： 数据结构 c++ AVL树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73865858/article/details/136340058
版权

树和节点的定义

template<class K,class V>
class 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)
	{}
};

插入

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 (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		//父链接子，子要反向链接父
		cur->_parent = parent;

		//update bf
		while (parent)
		{
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}

			if (parent->_bf == 1 || parent->_bf == -1)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//rotate

			}
			else
			{
				assert(false);
			}
		}

		return true;
	}

平衡因子的调整

1.parent->bf等于1||-1,说明parent所在的子树高度变了，（因为插入前parent->bf等于0，插入前左右子树高度相等，现在有一边高了）需要继续向上更新平衡因子。
2.parent->bf等于2||-2，parent所在的子树不平衡，需要旋转处理这棵子树。
3.parent->bf等于0，parent所在的子树平衡无需更新。

旋转

在这里插入图片描述
我们先定义有以上三种子节点，分别记为x，y，z，以便后文讲解。

左单旋

在这里插入图片描述
上述这种情况，c只能是x，若非那么c节点本身就要先旋转调整。
b变成了30的右边，30变成60的左边，60变成整棵树的根。
注意点：1.双向连接2.subRL可能为空3.parent是否为根
代码实现：

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

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

		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		//判断上面是否有根
		if (ppNode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
				subR->_parent = ppNode;
			}
			else
			{
				ppNode->_right = subR;
				subR->_parent = ppNode;
			}
		}

		parent->_bf = subR->_bf = 0;
	}

右单旋

在这里插入图片描述

void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppNode = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

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

		if (ppNode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else if(ppNode->_left==parent)
		{
			ppNode->_left = subL;
			subL->_parent = ppNode;
		}
		else
		{
			ppNode->_right = subL;
			subL->_parent = ppNode;
		}

		parent->_bf = subL->_bf = 0;

	}

左右双旋

在这里插入图片描述
难点：平衡因子的调整
以上图为例，记录subLR初始的bf，然后分三种情况讨论即可

 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;
			subLR->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}

	}

右左双旋

在这里插入图片描述

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

		RotateR(subR);
		RotateL(parent);

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

	}

判断是否为平衡二叉树

bool IsBalance()
	{
		return _IsBalance(_root);
	}
bool _IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;
		int lefth = _Height(root->_left);
		int righth = _Height(root->_right);

		if (righth - lefth != root->_bf)
		{
			cout << root->_kv.first << "节点平衡因子异常" << endl;
		}

		return abs(lefth - righth) < 2 && _IsBalance(root->_left)&&_IsBalance(root->_right);
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);
		return (leftH > rightH ? leftH : rightH) + 1;
	}

注意这里我们用递归获得子树的高度后，判断左右子树绝对值是否小于2还不行，还要逐层递归下去判断子树。

完整代码

#pragma once
#include<assert.h>
#include<iostream>
#include<time.h>

using namespace std;

template<class K,class V>
class AVLTreeNode
{
public:
	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)
	{}
};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	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 (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		//父链接子，子要反向链接父
		cur->_parent = parent;

		//update bf
		while (parent)
		{
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}

			if (parent->_bf == 1 || parent->_bf == -1)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//rotate
				if (parent->_bf == 2 && cur->_bf == 1)
					RotateL(parent);
				else if (parent->_bf == -2 && cur->_bf == -1)
					RotateR(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;
	}

private:
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

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

		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		//判断上面是否有根
		if (ppNode == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
				subR->_parent = ppNode;
			}
			else
			{
				ppNode->_right = subR;
				subR->_parent = ppNode;
			}
		}

		parent->_bf = subR->_bf = 0;
	}

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppNode = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

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

		if (ppNode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else if(ppNode->_left==parent)
		{
			ppNode->_left = subL;
			subL->_parent = ppNode;
		}
		else
		{
			ppNode->_right = subL;
			subL->_parent = ppNode;
		}

		parent->_bf = subL->_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;
			subLR->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}

	}

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

		RotateR(subR);
		RotateL(parent);

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

	}
public:
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}

	
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;
		int lefth = _Height(root->_left);
		int righth = _Height(root->_right);

		if (righth - lefth != root->_bf)
		{
			cout << root->_kv.first << "节点平衡因子异常" << endl;
		}

		return abs(lefth - righth) < 2 && _IsBalance(root->_left)&&_IsBalance(root->_right);
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);
		return (leftH > rightH ? leftH : rightH) + 1;
	}
private:
	Node* _root=nullptr;
};

void Test_AVLTree1()
{
	int a[] = { 16,3,7,11,9,26,18,14,15 };
	AVLTree<int, int> t1;
	for (int e : a)
	{
		t1.Insert(make_pair(e,e));
	}

	t1.InOrder();
	cout<<t1.IsBalance();
}

//生成随机数测试
void Test_AVLTree2()
{
	srand(time(0));
	const size_t N = 10000;
	AVLTree<int, int> t;
	for (size_t i = 0; i < N; i++)
	{
		size_t x = rand();
		t.Insert(make_pair(x, x));
		//cout << t.IsBalance() << endl;
	}
	cout << t.IsBalance() << endl;
}
MLGDOU
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 - AVL树
TPON的博客
11-10 706
AVL树 - 平衡二叉搜索树
数据结构课设PPT_地图着色_推销商问题_遗传算法_AVL树_回溯法
08-22
在这个课设中，我们关注的是几种关键的数据结构和算法，包括地图着色问题、推销商问题、遗传算法以及AVL树。 地图着色问题是一个典型的图论问题，目标是用最少的颜色给地图上的各个区域着色，相邻的区域不能使用...
数据结构-AVL树（平衡二叉树）
m0_61433144的博客
08-11 921
规定在插入和删除二叉搜索树的结点时，要保证任意结点的左右子树高度差的绝对值不超过1，我们将这样特殊的二叉搜索树称为AVL树（平衡二叉树）。每一个结点中有记录其左右子树高度差的平衡因子，也即平衡因子的值只可能是-1,0,1。（1如果某结点的左子树高度比右子树高度高一则平衡因子为-1，如果某结点的左子树高度比右子树高度低一则平衡因子为1，如果某结点的左子树高度与右子树高度一样则平衡因子为0）。............
数据结构——AVL树
m0_57249790的博客
04-02 301
我们不同于普通的二叉搜索树的是，我们的AVL树的结点需要多一个父指针指向自己的父节点，还有一个记录平衡因子的变量，构成了特殊的三叉链结构。因为我们要保持AVL树的左右子树高度差的绝对值不超过1，所以要对树的结构进行旋转。所以通过看平衡因子的值就能知道是否左右子树高度不超过1。//需要存储的键值对//特殊的三叉链结构int _bf;//平衡因子（balance factor）//构造函数:_kv(kv), _bf(0){}关于AVL树，我们只是做一个了解。
数据结构 树 平衡二叉树（AVL树）
潘超博客
02-08 5016
AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。
【C++、数据结构】AVL树 模拟实现
上上谦. 的博客
01-11 775
上一章节我们学习了二叉搜索树，并且模拟实现了二叉搜索树的实现。在学习完之后我们知道二叉搜索树查找的时间复杂度是〇（N），这里并不是〇（logN）具体的原因就是要搜索的二叉树并不是非常的平衡。并不是所有要查找的二叉树都是满二叉树或者是完全二叉树，有可能是单边树的情况，平均下来的时间复杂度就是〇（N）。前情回顾：二叉搜索树 👉传送门本章我们将学习AVL树，来解决上一章节二叉搜索树的查找时二叉树不平衡的问题，搬好小板凳准备开讲啦~~~ 🙋 🙋 🙋 🙋 🙋。
【数据结构】AVLTree实现详解
EWIAW_ilove的博客
06-08 1074
在二叉搜索树的博客中，我们提到了，当插入的数据有序或者接近有序的时候，二叉搜索树会退化成单支树，导致其效率变低，所以为了解决这种情况，于是我们提出了AVLTree，即二叉平衡搜索树。如下图就是一棵二叉搜索树退化成的单支树。那么AVLTree又是如何实现使二叉树搜索树不会退化成单支树的呢，它又是如何保证效率的呢？因为AVLTree严格的要求左右子树的高度差不能大于1，且每一棵子树也一样。如下图所示。
Python - 深夜数据结构与算法之 AVL 树 & 红黑树
BITDDD小栈
01-15 1642
AVL 树、红黑树简介。
python数据结构 树_Python数据结构——AVL树的实现
weixin_39599372的博客
11-23 168
既然，我们已经证明，保持 AVL 树的平衡将会使性能得到很大的提升，那我们看看如何在程序中向树插入一个新的键值。因为所有的新键是作为叶节点插入树的，而新叶子的平衡因子为零，所以我们对新插入的节点不作调整。不过一旦有新叶子的插入我们必须更新其父节点的平衡因子。新叶子会如何影响父节点的平衡因子取决于叶节点是左子节点还是右子节点。如果新节点是右子节点，父节点的平衡因子减 1。如果新节点是左子节点，父节点...
C++进阶数据结构_AVL树
代码铺子
06-05 218
AVL是一颗绝对平衡的二叉搜索树，要求每个节点的左右子树的高度差的绝对值不超过1，这样可以保证查询时候的时间复杂度为logN。
数据结构期末复习资料111
01-09
数据结构是计算机科学中至关重要的基础课程，涵盖了多种数据组织方式和操作算法。这份期末复习资料111主要涵盖以下几个核心知识点： 1. **单链表**：学习如何创建、插入、删除和查找单链表中的元素。创建链表涉及...
数据结构&算法1
08-03
除了二叉查找树，还有其他高级数据结构，如堆（Heap）、并查集（Disjoint Set）、Trie树、AVL树和红黑树。堆常用于优先队列（Priority Queue）实现，确保父节点的值总是大于或等于其子节点，从而实现快速的最大值...
数据结构与算法思维导图1
08-03
最后，我们提到了一些特定的数据结构，如**Trie树**，用于字符串搜索，通过建立树形结构来节省空间。还有平衡二叉树，如**AVL树**和**红黑树**，它们保证了树的高度平衡，从而在查找、插入和删除操作中保持O(logN)的...
十套数据结构试题及答案.doc
09-28
树是一种非线性的数据结构，由节点和边构成，每个节点可以有零个或多个子节点。常见的树类型有二叉树、二叉搜索树、平衡二叉树（如AVL树和红黑树）、B树和B+树等。这些数据结构在文件系统、数据库索引和图形遍历等...
【数据结构】比较顺序表和链表的区别（优缺点），细讲CPU高速缓存命中率
最新发布
2301_79633555的博客
06-24 649
顺序表链表的比较 ，主存和本地二级存储，寄存器和三级缓存，顺序表缓存命中率，链表缓存命中率
列举几种常见的数据结构，以及线性数据结构
m0_46552684的博客
06-18 760
数据结构是计算机科学中用来组织、存储和管理数据的方式。它定义了数据元素之间的逻辑关系，以及如何对数据进行操作。数据结构的选择对于算法的效率至关重要，因为它直接影响到数据在计算机中的存储和访问方式。线性数据结构是数据元素之间存在一对一关系的数据结构，即除了第一个元素和最后一个元素外，每个元素都有一个直接前驱和一个直接后继。线性数据结构通常用于表示具有线性关系的数据，例如有序列表或序列。这些线性数据结构在算法设计和程序开发中都有重要的作用，它们可以根据具体的应用场景来选择使用。
轻松解决Android复杂数据结构序列化
duihuapixiu的博客
06-21 724
当我编写quickupload库时，因为需要在 Service中进行上传任务，向Service传递时我发现需要传递的数据很多并且结构复杂，如果处理不好就会导致以下几个问题为了解决这个问题
Java中的数据结构：选择与优化
weixin_44627014的博客
06-21 558
选择合适的数据结构是编写高效Java程序的关键。通过了解不同数据结构的特性和应用场景，结合实际需求选择最优的数据结构，并通过优化策略提升性能，可以显著提高程序的运行效率。希望本文的介绍能帮助大家更好地掌握Java中的数据结构选择与优化技巧，在实际开发中编写出更加高效和可靠的代码。
山东大学数据结构课程设计avl树的实现
07-23
总之，山东大学数据结构课程设计要求实现AVL树，通过定义节点结构和实现插入、删除和查找操作，可以实现一个具有良好平衡性和高效性能的AVL树。 ### 回答2： 山东大学的数据结构课程设计中，我实现了AVL树。 AVL...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值