AVL树的C++实现

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

引言

       学习了map/multimap/set/multiset等容器之后，我们知道这几个容器的底层实现都是按照二叉搜索树来实现的，但是二叉搜索树也有着自身的缺陷，比如我们如果往树中插入的元素有序或者接近有序的话，二叉搜索树就会退化成单支树，查找元素就相当于在顺序表中查找元素，时间复杂度会退化成O(N),因此map，set等关联式容器的底层结构都是对二叉树进行了平衡处理，即由此引出了平衡二叉树。

一、AVL树的概念

AVL树是于1962年由两位俄罗斯数学家G.M.Adelson-Velskii和E.M.Landis发明的一种解决二叉搜索树退化成单支树的方法。该方法为：在我们向二叉搜索树中插入新结点后，如果我们能保证每个结点的左右子树高度之差的绝对值不超过1（不能为0，考虑偶数个结点），则可以降低树的高度，从而减少我们的平均搜索长度。

一颗AVL树要么是空树，要么有着以下的特点

  • 它的左右子树都是AVL树
  • 它的左右子树的高度之差（右子树的高度-左子树的高度）的绝对值不超过2

二、AVL树的简单实现

 AVL树的结点定义

首先我们要实现的是关联式容器，与序列式容器不同，其里面存储的是<key,value>的结构的键值对，这种存储在数据检索时比序列式容器的效率更高。

其次，我们构造一个三叉链，除了定义两个孩子结点，还需要一个指向父亲的结点。

接着，我们还需要一个平衡因子，方便我们监视和调整结点的子树的高度以满足平衡。

所以我们给出下列类模板

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;//三叉链
	int _bf;//balance factor平衡因子
	pair<K, V> _kv;//存储的键值对
	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
		, _kv(kv)
	{}
};

AVL树的插入

对于AVL树的插入，我们考虑如下步骤

  1. 先将该结点按照二叉搜索树的规则插入到树中
  2. 插入完成后更新平衡因子
  3. 对插入结点的父亲结点不同的的平衡因子做出不同的处理
  4. 当父亲结点的平衡因子为0时
  5. 当父亲结点的平衡因子为-1或1时
  6. 当父亲结点的平衡因子为-2或者2时，这里需要考虑旋转

插入

从头结点开始，我们使用键值对中的first来比较大小，遇到大的向左走，反之向右走。

if (_root == nullptr)
{
	_root = new Node(kv);
	return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
	parent = cur;
	if (cur->_kv.first > kv.first)	
		cur = cur->_left;
	else if (cur->_kv.first < kv.first)
		cur = cur->_right;
    else
        return false;
}
cur = new Node(kv);
if (parent->_kv.first<kv.first)
	parent->_right = cur;
else
	parent->_left = cur;
cur->_parent = parent;

更新平衡因子 

这里不用考虑该结点的插入位置，每次插入都是该树的叶子结点，无论是哪个叶子结点首先影响的是该结点的父亲结点，当结点插入到右边时则父亲结点的平衡因子加一，否则减一。 

if (cur == parent->_right)
	parent->_bf++;
else
	parent->_bf--;

分析平衡因子的不同对树的影响

经过分析我们知道在我们插入一个结点时，其影响的只会是其祖先的平衡因子，其他结点并不会受到影响，且并不是该点的所有祖先都会被它影响，所以这里我们将父亲结点的平衡因子分为三种情况来讨论：

1、更新后父亲结点的平衡因子是0

在插入新结点更新后的父亲的平衡因子为0，说明在插入前父亲的平衡因子为1或者-1，即该结点只有一个左叶子结点或者一个右叶子结点。此时再插入一个恰好使其平衡因子为0，说明新结点插入到了没有叶子结点的一边，此时父亲结点的高度并没有变化，所以它并不会影响到之后的祖先。

if (parent->_bf == 0)
{
	break;
}

2、更新后父亲结点的平衡因子是-1/1 

在插入新结点更新后的父亲的平衡因子为-1或1，说明在插入前父亲的平衡因子为0，说明父亲结点原来没有叶子结点，此时新插入的结点会影响到父亲节点及之后祖先的高度，这里需要不断向上更新祖先结点的平衡因子，观察祖先结点的平衡因子是否有问题。

else if(parent->_bf==1||parent->_bf==-1)
{
	cur = parent;
	parent=parent->_parent;
}

3、更新后父亲结点的平衡因子为2/-2

如果出现平衡因子为2或-2的情况，说明该结点不平衡，需要做旋转处理。根据新结点插入的位置不同，我们将其分成四种情况来讨论，对于这四种情况分别使用的不同的方法来解决问题。

1）新结点插入到较高左子树的左侧

当在较高左子树的左侧插入新结点后，该点失去平衡，需要调整。此时我们需要将左子树高度减一，右子树的高度增加一， 由于我们本身就是以二叉搜索树建树，所以满足每个结点的左子树都比其小，右子树都比其大，所以我们考虑将y作为6结点的左子树，6作为4结点的右子树，如下图所示

我们对平衡因子为-2 的点进行右旋转处理如下

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

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

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

	//分类讨论
	if (_root == parent)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (pparent->_left == parent)
			pparent->_left = subL;
		else
			pparent->_right = subL;
		subL->_parent = pparent;
	}
	subL->_bf = parent->_bf = 0;
}

2）新结点插入到较高右子树的右侧 

该情况与上一个情况类似，只不过是进行左单旋处理

 

void RotateL( Node* parent)
{
	Node* pparent = parent->_parent;//记录parent的父亲结点
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	parent->_right = subRL;
	if(subRL)
	   subRL->_parent = parent;

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

	if (_root == parent)//分情况讨论，如果parent是头节点
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else//parent是非头节点
	{
		if (parent == pparent->_left)
			pparent->_left = subR;
		else
			pparent->_right = subR;
		subR->_parent = pparent;
	}
	parent->_bf = subR->_bf = 0;
}

3）新结点插入到较高左子树的右侧

这里我们采用先对30进行左单旋，接着再对90进行右单旋。但是我们在这里需要注意的是在b点和在c点插入新结点或者考虑h为0的情况都会导致平衡树的高度变化，三种情况下旋转之后的结构是差不多的，但是其结点的平衡因子会因为情况的不同而不同。

所以我们考虑通过控制不同的平衡因子来区分不同的情况。上图是第一种情况，第二和第三种情况如下

 

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

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

4）新结点插入到较高右子树的左侧

与上一小节讨论类似，不过这里我们采用的是先右单旋再左单旋的方法，同样是分三种情况来讨论，这里过程我们省略直接上代码

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

小结

到此，我们的针对平衡树的所有情况的旋转已经完成了，我们可以看到当插入的结点和其 父亲结点及父亲结点的父亲结点在一条直线上时，我们只需要单旋，如果是条折线的话我们则需要双旋。

中序遍历打印

由于其是一颗二叉搜索树，当按照中序遍历打印时，刚好是按照从小到大的顺序排出来的。

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

}
void Inorder()
{
	_Inorder(_root);
	cout << endl;
}

由于类中的成员变量_root是私有的，不能在类外面直接传参，所以我们使用一个函数来调用另一个函数的子函数来解决这个问题。

 判断是否为平衡二叉树

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

	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);
	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
//判断是否平衡
bool _IsBalance(Node* root)
{
	if (root == nullptr)
		return true;
	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);

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

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

完整代码展示

如下

#pragma once
#include<iostream>
using namespace std;
template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;//三叉链
	int _bf;//balance factor平衡因子
	pair<K, V> _kv;//存储的键值对
	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)
	{}
	/*~AVLTree()
	{
		Destory(_root);
	}*/
	bool Insert(const pair<K,V>& kv)
	{
		//先按搜索树的规则插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			parent = cur;
			if (cur->_kv.first > kv.first)	
				cur = cur->_left;
			else if (cur->_kv.first <= kv.first)//multi版本的
				cur = cur->_right;
		}
		//找到了
		cur = new Node(kv);
		if (parent->_kv.first<kv.first)
			parent->_right = cur;
		else
			parent->_left = cur;
		cur->_parent = parent;

		//这里插入完成，准备更新平衡因子，插入一个平衡因子可能会影响到根
		while (parent)
		{
			if (cur == parent->_right)//节点插入到左边则平衡因子加一，否则减一
				parent->_bf++;
			else
				parent->_bf--;
			//判断平衡因子经过插入结点 后是否受影响
			if (parent->_bf == 0)//插入节点影响的只是他的祖先，且不一定所有祖先都会被影响，
				//如果插入之后该插入节点的父亲结点的平衡因子为0，
				// 则说明插入节点后父亲节点的高度没有变化，则它就不会对之后的祖先产生影响
			{
				break;
			}
			else if(parent->_bf==1||parent->_bf==-1)//说明之前parent节点的因子为0.再插入一个cur后才会变成1或-1，这样继续往上更新
			{
				cur = parent;
				parent=parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)//说明该结点不平衡，需要做旋转处理
			{
				//旋转处理
				if (parent->_bf == 2)
				{
					if (cur->_bf == 1)
					{
						//左旋
						RotateL(parent);
					}
					else if (cur->_bf == -1)
					{
						//右左双旋
						RotateRL(parent);

					}
				}
				if (parent->_bf == -2)
				{
					if (cur->_bf == -1)
					{
						RotateR(parent);
					}
					else if(cur->_bf==1)
					{
						//左右双旋
						RotateLR(parent);
					}
				}
				break;
			}	
		}
		return true;
	}
	//旋转处理的左单旋
	void RotateL( Node* parent)
	{
		Node* pparent = parent->_parent;//记录parent的父亲结点
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if(subRL)
		   subRL->_parent = parent;

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

		if (_root == parent)//分情况讨论，如果parent是头节点
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else//parent是非头节点
		{
			if (parent == pparent->_left)
				pparent->_left = subR;
			else
				pparent->_right = subR;
			subR->_parent = pparent;
		}
		parent->_bf = subR->_bf = 0;
	}

	//右旋转
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* pparent = parent->_parent;

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

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

		//分类讨论
		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (pparent->_left == parent)
				pparent->_left = subL;
			else
				pparent->_right = subL;
			subL->_parent = pparent;
		}
		subL->_bf = parent->_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=0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf==0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
	}
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_kv.first<< ":" << root->_kv.second << " ";
		_Inorder(root->_right);

	}
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		int bf = subLR->_bf;
		RotateL(subL);
		RotateR(parent);
		if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		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;
		}
	}
	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}
	//判断是否平衡
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

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

	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	Node* _root;
};
void Test_AVLTree()
{
	int a[] = { 16,3,7,11,9,26,18,14,15 };
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e,e));
	}
	t.Inorder();
	cout << t.IsBalance() << endl;
}

 

菜鸟康
关注
  • 19
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AVL树 C++ 实现
03-05
以上就是一个基本的AVL树C++实现框架。实际应用中，你可能还需要实现其他功能，如打印树、遍历树等。在Visual Studio 2008这样的IDE中，你可以创建一个项目，将这些代码放入头文件和源文件中，然后编译运行以测试其...
AVL树C++实现
10-20
学习AVL树的算法实现，使用c++在vc6.0中进行相应的算法实现，对正在学习算法的孩子有帮助
AVL树(C++实现)
清欢Allen的技术博客
04-14 1148
我们实现的是KV模型的AVL树,为了方便后续的操作,这里AVL树结点定义为三叉链结构,并且引入平衡因子,方便判断每棵树的平衡情况,并且还需要一个初始化列表将结点成员全部初始化.//三叉链 AVLTreeNode < K , V > * _left;//存储键值对 int _bf;
AVL树c++ 实现
xululala的博客
05-12 551
最近在看数据结构，参考了网上的代码，但是在调试时发现一些问题，于是自己修改了一下。AVL树大多数操作和二叉树一样，这里我只涉及到插入和删除操作。 1. 节点定义 相比较于普通二叉树的节点，多了一个节点高度，需要注意的是，对于空节点，高度默认为0，叶子节点高度为1。节点高度的设置是为了四种旋转操作。节点和树的具体实现如下（使用了类模板）： template<class T> class AVLnode{ public: AVLnode(const T& el){ i
数据结构之AVL树（C++实现）
CHAKMING1的博客
01-12 652
介绍了二叉搜索树如何优化到AVL树，介绍了AVL树的概念，用代码实现了插入和验证是否为AVL树的方法。
AVL树C++实现——高度平衡二叉搜索树
Brant_zero的博客
11-15 742
C++实现，详解AVL树，AVL树的插入(循环实现)以及测试用例。
【C++】AVL树模拟实现
m0_51064412的博客
02-22 494
文章目录一. 什么是AVL树？二. 为什么要有AVL树 一. 什么是AVL树？ 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1，达到高度平衡，即可降低树的高度，从而减少平均搜索长度。如果一棵二叉搜索树是高度平衡的，它就是AVL树。 空树也算AVL树，AVL树一般具有一下性质： 节点的平衡因子 = 右子树高度 - 左子树高度。绝对值不大于1 它的左右子树都是AVL树 二. 为什么要有AVL树 ...
C++实现AVL树
qq_61635026的博客
08-02 503
C++实现AVL树
c++——AVL树
Britney_dark的博客
11-08 1454
如果结果不如你所愿，就在尘埃落定前奋力一搏！
【数据结构】AVL树——C++实现
Sauron7i的博客
10-01 1039
AVL树特点：**在BST树的基础上，引入了节点“平衡”的概念，任意一个节点的左右子树高度差不超过1。** **为什么要引入平衡这个概念？** 在BST树中，由于插入后就是排序好的，那就会存在这样一种情况：如果插入的元素依次增大，就会导致理想中的二叉树，形成了一个链表，如下图，这种情况会导致增删查的时间复杂度并不是O(logn)，而是O(n)。为了解决这样情况，引入了平衡的概念。
AVL树的详细实现(C++)
code_peak
10-05 4567
AVL树概念 前面已经介绍了二叉搜索树，但是二叉搜索树在某些情况下会出现极度不平衡，其树形结构便退化成了链表，查找效率也会下降。于是出现了 AVL 树，AVL 树保证了二叉搜索树的平衡，引入了平衡监督机制，也就是在插入结点时，树中某一部分不平衡度超过一个阈值后将出发平衡调整操作，这样便保证了树的平衡度在可接受的范围内，最大的好处就是提高了搜索的效率。 AVL 树是一种平衡二叉树，其名字来源于发明者的名字（Adelson-Velskii 以及 Landis）。AVL树的递归定义如下： 左右子树的高度差小于等
AVL树的c++实现
08-03
总的来说，这个C++实现的AVL树利用了模板类的灵活性和`shared_ptr`的自动内存管理，能够高效且安全地处理二叉查找树的各种操作。理解AVL树的原理和实现对于提升数据结构与算法能力，尤其是处理动态数据集时的性能...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1268
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
【C语言】分支与循环（下）
weixin_74076508的博客
07-24 866
我们怎么想这个问题呢？1. 要从100~200之间找出素数，⾸先得有100~200之间的数，这⾥可以使⽤循环产生100~200的数字2. 怎么判断i是否为素数呢？我们可以使用试除法，也就是可以用 2 ~ i-1 之间的数字去试除i，那首先需要产⽣2~i-1之间的数字，也可以使⽤循环解决。3. 如果2~i-1之间有数字能整除i，则i不是素数，如果都不能整除，则i是素数。
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 316
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
《Cross-Modal Dynamic Transfer Learning for Multimodal Emotion Recognition》
buyaotutou的博客
07-25 1106
例如：第一章 Python 机器学习入门之pandas的使用文章链接Multimodal Emotion Recognition is an important research area for developing human-centric applications, especially in the context of video platforms. Most existing models have attempted to develop sophisticated fusion tech
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 728
C++ primer plus 第16章string 类和标准模板库, 关联容器。
avl树c++
05-24
AVL树是一种自平衡二叉搜索树，它的每个节点存储一个键值对，且每个节点的左子树和右子树的高度差不超过1。这种平衡特性使得AVL树在查找、插入和删除操作方面都有很好的性能表现。 下面是一个简单的AVL树的C++实现： ```c++ #include <iostream> using namespace std; // AVL树节点 struct Node { int key; int height; Node *left; Node *right; Node(int k) : key(k), height(1), left(NULL), right(NULL) {} }; // 获取节点高度 int height(Node *node) { if (node == NULL) { return 0; } return node->height; } // 获取节点平衡因子 int balanceFactor(Node *node) { if (node == NULL) { return 0; } return height(node->left) - height(node->right); } // 更新节点高度 void updateHeight(Node *node) { node->height = max(height(node->left), height(node->right)) + 1; } // 右旋操作 Node* rightRotate(Node *node) { Node *leftChild = node->left; Node *rightChild = leftChild->right; leftChild->right = node; node->left = rightChild; updateHeight(node); updateHeight(leftChild); return leftChild; } // 左旋操作 Node* leftRotate(Node *node) { Node *rightChild = node->right; Node *leftChild = rightChild->left; rightChild->left = node; node->right = leftChild; updateHeight(node); updateHeight(rightChild); return rightChild; } // 插入节点 Node* insert(Node *node, int key) { if (node == NULL) { return new Node(key); } if (key < node->key) { node->left = insert(node->left, key); } else if (key > node->key) { node->right = insert(node->right, key); } else { return node; } updateHeight(node); int bf = balanceFactor(node); if (bf > 1) { if (balanceFactor(node->left) >= 0) { return rightRotate(node); } else { node->left = leftRotate(node->left); return rightRotate(node); } } else if (bf < -1) { if (balanceFactor(node->right) <= 0) { return leftRotate(node); } else { node->right = rightRotate(node->right); return leftRotate(node); } } return node; } // 中序遍历AVL树 void inOrder(Node *node) { if (node == NULL) { return; } inOrder(node->left); cout << node->key << " "; inOrder(node->right); } int main() { Node *root = NULL; root = insert(root, 10); root = insert(root, 20); root = insert(root, 30); root = insert(root, 40); root = insert(root, 50); root = insert(root, 25); inOrder(root); cout << endl; return 0; } ``` 在上面的实现中，我们使用了递归插入节点，并在插入节点后更新了节点的高度和平衡因子。当节点的平衡因子大于1或小于-1时，我们进行相应的旋转操作来保持树的平衡。最后，我们在main函数中插入一些节点，并进行中序遍历来检查树是否正确构建。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值