C++AVL树

最新推荐文章于 2024-08-20 10:48:49 发布
最新推荐文章于 2024-08-20 10:48:49 发布
阅读量343 收藏 9
点赞数 6
分类专栏： C++学习之路 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ayf9999/article/details/134651642
版权

AVL树的概念

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

AVL树可以是一棵空树，也可以是具有以下性质的一棵二叉搜索树：

  1. 树的左右子树都是AVL树。
  2. 树的左右子树高度之差（简称平衡因子）的绝对值不超过1（-1/01）。

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

AVL树节点的定义

AVL树节点的定义 ：

template<class T>
struct AVLTreeNode
{
 AVLTreeNode(const T& data)
     : _pLeft(nullptr)
    , _pRight(nullptr)
    , _pParent(nullptr)
    , _data(data), _bf(0)
 {}
 AVLTreeNode<T>* _pLeft;   // 该节点的左孩子
 AVLTreeNode<T>* _pRight;  // 该节点的右孩子
 AVLTreeNode<T>* _pParent; // 该节点的双亲
 T _data;
 int _bf;                  // 该节点的平衡因子
};

 AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么
AVL树的插入过程可以分为两步：
1. 按照二叉搜索树的方式插入新节点
2. 调整节点的平衡因子

因为AVL树本身就是一棵二叉搜索树，因此寻找结点的插入位置是非常简单的，按照二叉搜索树的插入规则：

  1. 待插入结点的key值比当前结点小就插入到该结点的左子树。
  2. 待插入结点的key值比当前结点大就插入到该结点的右子树。
  3. 待插入结点的key值与当前结点的key值相等就插入失败。

如此进行下去，直到找到与待插入结点的key值相同的结点判定为插入失败，或者最终走到空树位置进行结点插入。

新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否
破坏了AVL树的平衡性

 

所以我们插入结点后需要倒着往上更新平衡因子，更新规则如下：

  1.     新增结点在parent的右边，parent的平衡因子 + + ++ ++。
  2.     新增结点在parent的左边，parent的平衡因子 − − -- −−。

每更新完一个结点的平衡因子后，都需要进行以下判断：

  1.     如果parent的平衡因子等于-1或者1，表明还需要继续往上更新平衡因子。
  2.     如果parent的平衡因子等于0，表明无需继续往上更新平衡因子了。
  3.     如果parent的平衡因子等于-2或者2，表明此时以parent结点为根结点的子树已经不平衡了，需要进行旋转处理。
     

 

Cur插入后，Parent的平衡因子一定需要调整，在插入之前，Parent
的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：
 1. 如果Cur插入到Parent的左侧，只需给Parent的平衡因子-1即可
 2. 如果Cur插入到Parent的右侧，只需给Parent的平衡因子+1即可
此时：Parent的平衡因子可能有三种情况：0，正负1， 正负2
 1. 如果Parent的平衡因子为0，说明插入之前Parent的平衡因子为正负1，插入后被调整
成0，此时满足AVL树的性质，插入成功
 2. 如果Parent的平衡因子为正负1，说明插入前Parent的平衡因子一定为0，插入后被更
新成正负1，此时以pParent为根的树的高度增加，需要继续向上更新
 3. 如果Parent的平衡因子为正负2，则Parent的平衡因子违反平衡树的性质，需要对其进
行旋转处理

而在最坏情况下，我们更新平衡因子时会一路更新到根结点。例如下面这种情况： 

 说明一下： 由于我们插入结点后需要倒着往上进行平衡因子的更新，所以我们将AVL树结点的结构设置为了三叉链结构，这样我们就可以通过父指针找到其父结点，进而对其平衡因子进行更新。当然，我们也可以不用三叉链结构，可以在插入结点时将路径上的结点存储到一个栈当中，当我们更新平衡因子时也可以通过这个栈来更新祖先结点的平衡因子，但是相对较麻烦。
若是在更新平衡因子的过程当中，出现了平衡因子为-2/2的结点，这时我们需要对以该结点为根结点的树进行旋转处理，而旋转处理分为四种，在进行分类之前我们首先需要进行以下分析：

我们将插入结点称为cur，将其父结点称为parent，那么我们更新平衡因子时第一个更新的就是parent结点的平衡因子，更新完parent结点的平衡因子后，若是需要继续往上进行平衡因子的更新，那么我们必定要执行以下逻辑：

cur = parent;
parent = parent->_parent;

这里我想说明的是：当parent的平衡因子为-2/2时，cur的平衡因子必定是-1/1而不会是0。

理由如下：
若cur的平衡因子是0，那么cur一定是新增结点，而不是上一次更新平衡因子时的parent，否则在上一次更新平衡因子时，会因为parent的平衡因子为0而停止继续往上更新。
而cur是新增结点的话，其父结点的平衡因子更新后一定是-1/0/1，而不可能是-2/2，因为新增结点最终会插入到一个空树当中，在新增结点插入前，其父结点的状态有以下两种可能：

  1.     其父结点是一个左右子树均为空的叶子结点，其平衡因子是0，新增结点插入后其平衡因子更新为-1/1。
  2.     其父结点是一个左子树或右子树为空的结点，其平衡因子是-1/1，新增结点插入到其父结点的空子树当中，使得其父结点左右子树当中较矮的一棵子树增高了，新增结点后其平衡因子更新为0。
     

 根据此结论，我们可以将旋转处理分为以下四类：

  1. 当parent的平衡因子为-2，cur的平衡因子为-1时，进行右单旋。
  2. 当parent的平衡因子为-2，cur的平衡因子为1时，进行左右双旋。
  3. 当parent的平衡因子为2，cur的平衡因子为-1时，进行右左双旋。
  4. 当parent的平衡因子为2，cur的平衡因子为1时，进行左单旋。

并且，在进行旋转处理后就无需继续往上更新平衡因子了，因为旋转后树的高度变为插入之前了，即树的高度没有发生变化，也就不会影响其父结点的平衡因子了。具体原因请看后面的旋转讲解。

代码如下： 

//插入函数
bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr) //若AVL树为空树，则插入结点直接作为根结点
	{
		_root = new Node(kv);
		return true;
	}
	//1、按照二叉搜索树的插入方法，找到待插入位置
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (kv.first < cur->_kv.first) //待插入结点的key值小于当前结点的key值
		{
			//往该结点的左子树走
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first) //待插入结点的key值大于当前结点的key值
		{
			//往该结点的右子树走
			parent = cur;
			cur = cur->_right;
		}
		else //待插入结点的key值等于当前结点的key值
		{
			//插入失败（不允许key值冗余）
			return false;
		}
	}

	//2、将待插入结点插入到树中
	cur = new Node(kv); //根据所给值构造一个新结点
	if (kv.first < parent->_kv.first) //新结点的key值小于parent的key值
	{
		//插入到parent的左边
		parent->_left = cur;
		cur->_parent = parent;
	}
	else //新结点的key值大于parent的key值
	{
		//插入到parent的右边
		parent->_right = cur;
		cur->_parent = parent;
	}

	//3、更新平衡因子，如果出现不平衡，则需要进行旋转
	while (cur != _root) //最坏一路更新到根结点
	{
		if (cur == parent->_left) //parent的左子树增高
		{
			parent->_bf--; //parent的平衡因子--
		}
		else if (cur == parent->_right) //parent的右子树增高
		{
			parent->_bf++; //parent的平衡因子++
		}
		//判断是否更新结束或需要进行旋转
		if (parent->_bf == 0) //更新结束（新增结点把parent左右子树矮的那一边增高了，此时左右高度一致）
		{
			break; //parent树的高度没有发生变化，不会影响其父结点及以上结点的平衡因子
		}
		else if (parent->_bf == -1 || parent->_bf == 1) //需要继续往上更新平衡因子
		{
			//parent树的高度变化，会影响其父结点的平衡因子，需要继续往上更新平衡因子
			cur = parent;
			parent = parent->_parent;
		}
		else if (parent->_bf == -2 || parent->_bf == 2) //需要进行旋转（此时parent树已经不平衡了）
		{
			if (parent->_bf == -2)
			{
				if (cur->_bf == -1)
				{
					RotateR(parent); //右单旋
				}
				else //cur->_bf == 1
				{
					RotateLR(parent); //左右双旋
				}
			}
			else //parent->_bf == 2
			{
				if (cur->_bf == -1)
				{
					RotateRL(parent); //右左双旋
				}
				else //cur->_bf == 1
				{
					RotateL(parent); //左单旋
				}
			}
			break; //旋转后就一定平衡了，无需继续往上更新平衡因子(旋转后树高度变为插入之前了)
		}
		else
		{
			assert(false); //在插入前树的平衡因子就有问题
		}
	}

	return true; //插入成功
}

 AVL树的旋转

如果在一棵原本是平衡的 AVL 树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，
使之平衡化。根据节点插入位置的不同， AVL 树的旋转分为四种：
1. 新节点插入较高左子树的左侧 --- 左左：

右单旋

右单旋的步骤如下：

  1. 让subL的右子树作为parent的左子树。
  2. 让parent作为subL的右子树。
  3. 让subL作为整个子树的根。
  4. 更新平衡因子。

右单旋后满足二叉搜索树的性质：

  1. subL的右子树当中结点的值本身就比parent的值小，因此可以作为parent的左子树。
  2. parent及其右子树当中结点的值本身就比subL的值大，因此可以作为subL的右子树。

 平衡因子更新如下：

 可以看到，经过右单旋后，树的高度变为插入之前了，即树的高度没有发生变化，所以右单旋后无需继续往上更新平衡因子。

代码如下： 

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

	//1、建立subL和parent之间的关系
	subL->_right = parent;
	parent->_parent = subL;

	//2、建立parent和subLR之间的关系
	parent->_left = subLR;
	if (subLR)
		subLR->_parent = parent;

	//3、建立parentParent和subL之间的关系
	if (parentParent == nullptr)
	{
		_root = subL;
		_root->_parent = nullptr;
	}
	else
	{
		if (parent == parentParent->_left)
		{
			parentParent->_left = subL;
		}
		else //parent == parentParent->_right
		{
			parentParent->_right = subL;
		}
		subL->_parent = parentParent;
	}

	//4、更新平衡因子
	subL->_bf = parent->_bf = 0;
}

 注意： 结点是三叉链结构，改变结点关系时需要跟着改变父指针的指向。

 左单旋

 

左单旋的步骤如下：

    让subR的左子树作为parent的右子树。
    让parent作为subR的左子树。
    让subR作为整个子树的根。
    更新平衡因子。

左单旋后满足二叉搜索树的性质：

    subR的左子树当中结点的值本身就比parent的值大，因此可以作为parent的右子树。
    parent及其左子树当中结点的值本身就比subR的值小，因此可以作为subR的左子树。
经过左单旋后，树的高度变为插入之前了，即树的高度没有发生变化，所以左单旋后无需继续往上更新平衡因子。

代码如下： 

//左单旋
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	Node* parentParent = parent->_parent;

	//1、建立subR和parent之间的关系
	parent->_parent = subR;
	subR->_left = parent;

	//2、建立parent和subRL之间的关系
	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;

	//3、建立parentParent和subR之间的关系
	if (parentParent == nullptr)
	{
		_root = subR;
		subR->_parent = nullptr; //subR的_parent指向需改变
	}
	else
	{
		if (parent == parentParent->_left)
		{
			parentParent->_left = subR;
		}
		else //parent == parentParent->_right
		{
			parentParent->_right = subR;
		}
		subR->_parent = parentParent;
	}

	//4、更新平衡因子
	subR->_bf = parent->_bf = 0;
}

 左右双旋

新节点插入较高左子树的右侧---左右：先左单旋再右单旋  

将双旋变成单旋后再旋转，即： 先对 30 进行左单旋，然后再对 90 进行右单旋 ，旋转完成后再
考虑平衡因子的更新。

左右双旋的步骤如下：

  1. 以subL为旋转点进行左单旋。
  2. 以parent为旋转点进行右单旋。
  3. 更新平衡因子。

左右双旋后满足二叉搜索树的性质：
左右双旋后，实际上就是让subLR的左子树和右子树，分别作为subL和parent的右子树和左子树，再让subL和parent分别作为subLR的左右子树，最后让subLR作为整个子树的根（结合图理解）。

  1.     subLR的左子树当中的结点本身就比subL的值大，因此可以作为subL的右子树。
  2.     subLR的右子树当中的结点本身就比parent的值小，因此可以作为parent的左子树。
  3.     经过步骤1/2后，subL及其子树当中结点的值都就比subLR的值小，而parent及其子树当中结点的值都就比subLR的值大，因此它们可以分别作为subLR的左右子树。

 左右双旋后，平衡因子的更新随着subLR原始平衡因子的不同分为以下三种情况：
1、当subLR原始平衡因子是-1时，左右双旋后parent、subL、subLR的平衡因子分别更新为1、0、0。

 2、当subLR原始平衡因子是1时，左右双旋后parent、subL、subLR的平衡因子分别更新为0、-1、0。

3、当subLR原始平衡因子是0时，左右双旋后parent、subL、subLR的平衡因子分别更新为0、0、0。 

可以看到，经过左右双旋后，树的高度变为插入之前了，即树的高度没有发生变化，所以左右双旋后无需继续往上更新平衡因子。 

代码如下： 

//左右双旋
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf; //subLR不可能为nullptr，因为subL的平衡因子是1

	//1、以subL为旋转点进行左单旋
	RotateL(subL);

	//2、以parent为旋转点进行右单旋
	RotateR(parent);

	//3、更新平衡因子
	if (bf == 1)
	{
		subLR->_bf = 0;
		subL->_bf = -1;
		parent->_bf = 0;
	}
	else if (bf == -1)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 1;
	}
	else if (bf == 0)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 0;
	}
	else
	{
		assert(false); //在旋转前树的平衡因子就有问题
	}
}

 右左双旋

 

1、插入新结点。

2、以90为旋转点进行右单旋。

 3、以30为旋转点进行左单旋。

右左双旋的步骤如下：

  1. 以subR为旋转点进行右单旋。
  2. 以parent为旋转点进行左单旋。
  3. 更新平衡因子。

右左双旋后满足二叉搜索树的性质：
右左双旋后，实际上就是让subRL的左子树和右子树，分别作为parent和subR的右子树和左子树，再让parent和subR分别作为subRL的左右子树，最后让subRL作为整个子树的根（结合图理解）。

  1.     subRL的左子树当中的结点本身就比parent的值大，因此可以作为parent的右子树。
  2.     subRL的右子树当中的结点本身就比subR的值小，因此可以作为subR的左子树。
  3.     经过步骤1/2后，parent及其子树当中结点的值都就比subRL的值小，而subR及其子树当中结点的值都就比subRL的值大，因此它们可以分别作为subRL的左右子树。

 右左双旋后，平衡因子的更新随着subLR原始平衡因子的不同分为以下三种情况：
1、当subRL原始平衡因子是1时，左右双旋后parent、subR、subRL的平衡因子分别更新为-1、0、0。

 2、当subRL原始平衡因子是-1时，左右双旋后parent、subR、subRL的平衡因子分别更新为0、1、0。

3、当subRL原始平衡因子是0时，左右双旋后parent、subR、subRL的平衡因子分别更新为0、0、0。

 可以看到，经过右左双旋后，树的高度变为插入之前了，即树的高度没有发生变化，所以右左双旋后无需继续往上更新平衡因子。

代码如下：

//右左双旋
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;

	//1、以subR为轴进行右单旋
	RotateR(subR);

	//2、以parent为轴进行左单旋
	RotateL(parent);

	//3、更新平衡因子
	if (bf == 1)
	{
		subRL->_bf = 0;
		parent->_bf = -1;
		subR->_bf = 0;
	}
	else if (bf == -1)
	{
		subRL->_bf = 0;
		parent->_bf = 0;
		subR->_bf = 1;
	}
	else if (bf == 0)
	{
		subRL->_bf = 0;
		parent->_bf = 0;
		subR->_bf = 0;
	}
	else
	{
		assert(false); //在旋转前树的平衡因子就有问题
	}
}

AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，也就是说AVL树也是二叉搜索树，因此我们可以先获取二叉树的中序遍历序列，来判断二叉树是否为二叉搜索树。

代码如下：

//中序遍历
void Inorder()
{
	_Inorder(_root);
}
//中序遍历子函数
void _Inorder(Node* root)
{
	if (root == nullptr)
		return;
	_Inorder(root->_left);
	cout << root->_kv.first << " ";
	_Inorder(root->_right);
}

 但中序有序只能证明是二叉搜索树，要证明二叉树是AVL树还需验证二叉树的平衡性，在该过程中我们可以顺便检查每个结点当中平衡因子是否正确。

采用后序遍历，变量步骤如下：

  1. 从叶子结点处开始计算每课子树的高度。（每棵子树的高度 = 左右子树中高度的较大值 + 1）
  2. 先判断左子树是否是平衡二叉树。
  3. 再判断右子树是否是平衡二叉树。
  4. 若左右子树均为平衡二叉树，则返回当前子树的高度给上一层，继续判断上一层的子树是否是平衡二叉树，直到判断到根为止。（若判断过程中，某一棵子树不是平衡二叉树，则该树也就不是平衡二叉树了）

代码如下：

//判断是否为AVL树
bool IsAVLTree()
{
	int hight = 0; //输出型参数
	return _IsBalanced(_root, hight);
}
//检测二叉树是否平衡
bool _IsBalanced(Node* root, int& hight)
{
	if (root == nullptr) //空树是平衡二叉树
	{
		hight = 0; //空树的高度为0
		return true;
	}
	//先判断左子树
	int leftHight = 0;
	if (_IsBalanced(root->_left, leftHight) == false)
		return false;
	//再判断右子树
	int rightHight = 0;
	if (_IsBalanced(root->_right, rightHight) == false)
		return false;
	//检查该结点的平衡因子
	if (rightHight - leftHight != root->_bf)
	{
		cout << "平衡因子设置异常：" << root->_kv.first << endl;
	}
	//把左右子树的高度中的较大值+1作为当前树的高度返回给上一层
	hight = max(leftHight, rightHight) + 1;
	return abs(rightHight - leftHight) < 2; //平衡二叉树的条件
}

加一zZ
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ AVL树
weixin_53946312的博客
01-27 1095
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
c++ AVL树 插入 删除
CoderZhuuu
04-14 1063
AVL树的插入很简单，根据BST树的特性插入之后在回溯的过程中调整即可 AVL树的删除也不是很难，一共有三种情况 第一种是左子树为空（右子树为不为空无所谓） 第二种是右子树为空（此时左子树不为空） 这两种直接用另一半子树覆盖当前节点然后删除再回溯调整树即可 第三种是左右子数都不为空 这个情况首先找到要删除的节点，然后找到比该节点大的节点中最小的一个节点（右子树中最左边的节点），或者比该...
C++：AVL树
zhang_si_hang的博客
08-19 963
二叉搜索树虽可以缩短查找的效率，但。
c++——AVL树
Britney_dark的博客
11-08 1517
如果结果不如你所愿，就在尘埃落定前奋力一搏！
c++AVL树
2301_80163789的博客
03-26 757
{}//左孩子//右孩子//该结点的父结点T_data;int _bf;
【C++】AVL树（平衡二叉树）
Tianzhenchuan的博客
08-19 2652
AVL树，全称平衡二叉搜索（排序）树。二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。平衡因子（Balance Factor，简写为bf）
AVL树(C++实现)
清欢Allen的技术博客
04-14 1177
我们实现的是KV模型的AVL树,为了方便后续的操作,这里AVL树结点定义为三叉链结构,并且引入平衡因子,方便判断每棵树的平衡情况,并且还需要一个初始化列表将结点成员全部初始化.//三叉链 AVLTreeNode < K , V > * _left;//存储键值对 int _bf;
【C++】AVL树
奔赴在热爱征程上的小小孩~
04-27 578
二叉搜索树、AVL树
【C++】AVL树模拟实现
m0_51064412的博客
02-22 513
文章目录一. 什么是AVL树？二. 为什么要有AVL树 一. 什么是AVL树？ 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1，达到高度平衡，即可降低树的高度，从而减少平均搜索长度。如果一棵二叉搜索树是高度平衡的，它就是AVL树。 空树也算AVL树，AVL树一般具有一下性质： 节点的平衡因子 = 右子树高度 - 左子树高度。绝对值不大于1 它的左右子树都是AVL树 二. 为什么要有AVL树 ...
C++ AVL树的实现
07-10
在C++中实现AVL树，通常会涉及以下几个关键部分： 1. **基础结构**：首先，我们需要定义一个表示AVL树节点的结构体或类，它至少包含三个成员：键（key）、高度（height）以及指向左子树和右子树的指针。例如： ```...
基于C++ AVL树的航空客运订票系统【100012693】
06-12
《基于C++ AVL树的航空客运订票系统详解》 航空客运订票系统是现代航空公司运营中的关键组成部分，它能够高效地处理航班信息、预订和退票等业务。本项目以C++编程语言为基础，利用AVL树这一自平衡二叉搜索树的数据...
AVL树的c++实现
08-03
在C++中实现AVL树，我们可以利用模板类来增强代码的通用性，并通过智能指针如`shared_ptr`来管理内存，避免内存泄漏。 首先，我们需要定义一个AVL树节点结构体，包括节点值、高度、左子树和右子树的指针。由于我们...
AVL树 C++ 实现
03-05
在C++中实现AVL树，我们可以利用模板类来创建一个泛型的数据结构，这样就可以处理不同类型的元素。 首先，我们需要定义AVL树的节点结构。每个节点包含三个部分：键（key）存储元素值，高度（height）用于计算树的...
C++实现AVL树
11-15
C++实现AVL树,有兴趣的可以看看，可能不是很好，仅作为参考
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 319
基于Pygame和PIL的迷宫生成器
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 764
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 492
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II
最新发布
铁马冰河入梦来
08-20 198
哈希表解决存在重复元素二问题
c++ avl树构建
09-09
AVL树是一种自平衡的二叉搜索树，用于高效地插入、删除和查询数据。构建AVL树的基本步骤如下： 1. 首先，创建一个空的AVL树。 2. 从根节点开始，插入第一个元素作为根节点。 3. 对每个新插入的节点，更新它的平衡...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值