【C++进阶】带你手撕AVL树

于 2023-06-15 18:34:43 发布
阅读量300 收藏
点赞数 4
分类专栏： C++进阶 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61654591/article/details/131230482
版权
AVL树是一种自平衡二叉搜索树，通过在节点中增加平衡因子并进行特定的旋转操作来确保树的高度平衡。插入操作后，会检查并调整平衡因子，当平衡因子为-2或2时执行相应单旋或双旋。文章详细介绍了左旋、右旋、左右双旋和右左双旋的原理和代码实现，并提供了验证AVL树平衡性的方法。
摘要由CSDN通过智能技术生成

文章目录

一、什么是AVL树

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

AVL树相比前边的二叉搜索树，最大的区别就是在插入后判断左右子树的高度差，若不满足条件，就要进行旋转使高度差满足条件。

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

它的左右子树都是AVL树
左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

在这里插入图片描述
对于一颗AVL树而言，不仅要求这个数的根节点在左右子树是高度平衡的，并且要求每一个结点的左右子树都是高度平衡的。如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 O ( l o g 2 n ) O(log_2 n) O(log2​n)，搜索时间复杂度O( l o g 2 n log_2 n log2​n)。

二、AVL树的定义

在实现AVL树之前，需要先实现一个AVL树的节点，由于在后边要实现map的需要，所以实现key-value结构，所以树节点的值就是一个键值对，并且为了方便查找父结点的值，选择三叉链结构。
我们也控制了一个节点的平衡因子，是为了更方便控制是否平衡。

template<class K,class V>
class treeNode
{
public:
	treeNode(const pair<K,V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_bf(0)
		,_kv(kv)
	{}

	treeNode<K,V>* _left;
	treeNode<K, V>* _right;
	treeNode<K, V>* _parent;
	int _bf;
	pair<K, V> _kv;
};

三、AVL树的插入

1.理论讲解

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。

平衡因子如何控制？

当在一个节点的左边插入节点时，那么该节点的平衡因子- -
当在一个节点的右边插入节点时，那么该节点的平衡因子++

那么AVL树的插入过程可以分为两步：

1. 按照二叉搜索树的方式插入新节点

和前边二叉搜索树的方法类似，当插入值大于某节点值时，继续与其右子树判断，如果插入值小于某结点值时，继续与其左子树判断，知道判断到空，如果要插入结点的值与某一节点值相同时，那么就返回false，这是因为不能插入相同的值。

2. 调整节点的平衡因子

当在合适的位置插入新节点之后，就必须对其父结点的平衡因子进行判断，那么就会有以下的几种情况：

1.父结点的平衡因子为0

那么说明插入前父结点的平衡因子一定是-1或1，说明本来父结点的左右子树高度不相等，但是在插入之后，左右子树的高度相同了，插入的结点把本来空缺的位置补齐了。

2.父结点的平衡因子为-1或1

那么说明插入前父结点的平衡因子一定为0，不可能为2或-2，因为如果为-2和2就会发生旋转，所以插入后导致父结点不平衡，所以必须向上修改平衡因子。

3.父结点的平衡因子为-2或2

那么插入前父节点平衡因子一定为1或-1，此时就要进行旋转，调整结点的位置，使其再次成为AVL树。

当出现了平衡因子为-2或2时，根据情况不同就有四种旋转方法：

1.当父结点的平衡因子为2，子节点的平衡因子为1。

那么此时说明右边的高度大，那么就要进行左旋使其左右高度趋于平衡。

2.当父结点的平衡因子为-2，子节点的平衡因子为-1。

那么此时左边的高度大，要进行右旋使其左右高度趋于平衡。

3.当父结点的平衡因子为-2，子节点的平衡因子为1。

此时要进行左右双旋。

4.当父结点的平衡因子为2，子节点的平衡因子为-1。

此时要进行右左双旋。

2.代码实现

	bool insert(const pair<K,V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		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;
		}
		else if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			if (cur == parent->_right)
			{
				parent->_bf++;
			}

			if (parent->_bf == 0)
			{
				break;
			}
			else if (abs(parent->_bf) == 1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (abs(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;
			}
		}
	}

四、AVL树的旋转

1.左单旋

当父结点的平衡因子为2，且子节点的平衡因子为1时，即右边高度大于左边，进行左旋。
在这里插入图片描述
此处的a，b，c的高度都是h，所以h可能是0，1，2或者很长，所以代表着无数种情况。

在c处插入一个节点后，c高度变为和h+1，所以60结点的平衡因子变为1,30这个节点的平衡因子变为2，符合我们前边提提到做单旋的情况，所以进行左单旋。

对父节点进行左单旋，要进行以下的几步：

1.将子节点的左子树成为父结点的右子树。
2.将父结点变为子节点的左子树。
3.更新平衡因子parent结点和其右节点subR的平衡因子都变为0。

在这里插入图片描述

感性来看，就是把父结点往下压成为子节点的左子树的过程，称为左单旋，但是还有一点要注意就是在旋转完之后，需要判断父节点是否为根节点，若为根节点，就对根节点重新赋值，若不为根节点，就必须保存原父结点的父结点，就必须让子节点与这个保存的结点连接。

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

		Node* pparent = parent->_parent;

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

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

2.右单旋

右单旋为左单旋类似，只是在左边的高度较大时进行右单旋，当父节点的平衡因子为-2，子节点平衡因子为-1时进行右单旋。
在这里插入图片描述
在进行右单旋时进行以下的步骤：

1.将子节点的右子树作为父结点的左子树
2.将父结点作为子节点的右子树
3.调整平衡因子都有0
在这里插入图片描述

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

		Node* pparent = parent->_parent;

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

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

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

3.左右双旋

当父节点的平衡因子为-2，而子节点的平衡因子为1时，就要进行左右双旋。
左右双旋的会有以下的几步:

先对父结点的左节点进行左单旋.
再去父结点进行右单旋。

在这里插入图片描述
我们可以直接复用前边写好的左单旋和右单旋，其实左右双旋最难控制的是平衡因子怎么变化。
我们先来看上图
当在b出插入一个值时，此时的subLR的平衡因子为-1，在进行左右双旋之后，parent的平衡因子变为1，而subL的平衡因子变为0。
再来看下边这张图：
在这里插入图片描述
当subLR的平衡因子为1时，在进行左右双旋之后，parent的平衡因子为0，而subL的平衡因子为-1.

最后一种情况就是h的高度为0时，更新好的平衡因子都是0.

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

		//Node* pparent = parent->_parent;

		int bf = subLR->_bf;
		RotateL(parent->_left);
		RotateR(parent);

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

4.右左双旋

在当父结点在平衡因子为2，而子节点的平衡因子为-1时，要对父节点进行右左双旋。
进行右左双旋要进行以下的步骤：

1.对父节点的右子树进行右单旋。
2.对父节点进行左单旋。
3.更新平衡因子。

与左右双旋类似，前边的旋转可以直接复用左单旋与右单旋，而关键的是更新平衡因子。
我们通过以下的图片来判断如果更新平衡因子：

当subRL的平衡因子为1，即在c处插入
在这里插入图片描述

当subRL的平衡因子为-1，即在b处插入
在这里插入图片描述

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

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

五、 AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

  1. 验证其为二叉搜索树
    如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
  2. 验证其为平衡树

每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)

节点的平衡因子是否计算正确

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 << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

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

		int leftHT = Height(root->_left);
		int rightHT = Height(root->_right);
		int diff = rightHT - leftHT;

		if (diff != root->_bf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}

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

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

		return max(Height(root->_left), Height(root->_right)) + 1;
	}

我们通过生成随机数来检测是否为AVL树：

void TestAVLTree2()
{
	size_t N = 100;
	srand(time(0));
	AVL<int, int> t1;
	for (size_t i = 0; i < N; ++i)
	{
		int x = rand();
		t1.insert(make_pair(x, i));
			bool ret = t1.IsBalance();
			if (ret == false)
			{
				int u = 1;
			}
			else
			{
				cout << "Insert:" << x << " IsBalance:" <<ret<< endl;
			}
	}
	cout << "IsBalance:" << t1.IsBalance() << endl;
}

在这里插入图片描述

六、完整源码

AVL.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

template<class K,class V>
class treeNode
{
public:
	treeNode(const pair<K,V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_bf(0)
		,_kv(kv)
	{}

	treeNode<K,V>* _left;
	treeNode<K, V>* _right;
	treeNode<K, V>* _parent;
	int _bf;
	pair<K, V> _kv;
};

template<class K,class V>
class AVL
{
public:
	typedef treeNode<K, V> Node;
	//AVL()
	//{

	//}
	//~AVL()
	//{

	//}
	bool insert(const pair<K,V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		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;
		}
		else if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			if (cur == parent->_right)
			{
				parent->_bf++;
			}

			if (parent->_bf == 0)
			{
				break;
			}
			else if (abs(parent->_bf) == 1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (abs(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;
			}
		}
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		Node* pparent = parent->_parent;

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

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

		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == pparent->_left)
			{
				pparent->_left = subL;
			}
			else
			{
				pparent->_right = subL;
			}
			subL->_parent = pparent;
		}
		subL->_bf = parent->_bf = 0;
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		Node* pparent = parent->_parent;

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

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

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

		//Node* pparent = parent->_parent;

		int bf = subLR->_bf;
		RotateL(parent->_left);
		RotateR(parent);

		if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if(bf == 0)
		{
			parent->_bf = subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		//Node* pparent = parent->_parent;
		int bf = subRL->_bf;
		RotateR(parent->_right);
		RotateL(parent);
		if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
		}
		else if(bf==0)
		{
			subR->_bf = parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

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

		int leftHT = Height(root->_left);
		int rightHT = Height(root->_right);
		int diff = rightHT - leftHT;

		if (diff != root->_bf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}

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

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

		return max(Height(root->_left), Height(root->_right)) + 1;
	}

	Node* _root = nullptr;
};

//void testAVL()
//{
//	AVL<int, int> a;
//	
//}
void TestAVLTree1()
{
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };  // 测试双旋平衡因子调节
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	AVL<int, int> t1;
	for (auto e : a)
	{
		t1.insert(make_pair(e, e));
	}
	t1.InOrder();
	cout << "IsBalance:" << t1.IsBalance() << endl;
}
void TestAVLTree2()
{
	size_t N = 100;
	srand(time(0));
	AVL<int, int> t1;
	for (size_t i = 0; i < N; ++i)
	{
		int x = rand();
		t1.insert(make_pair(x, i));
			bool ret = t1.IsBalance();
			if (ret == false)
			{
				int u = 1;
			}
			else
			{
				cout << "Insert:" << x << " IsBalance:" <<ret<< endl;
			}
	}
	cout << "IsBalance:" << t1.IsBalance() << endl;
}

test.cpp

#include"AVL.h"

int main()
{
	//TestAVLTree1();
	TestAVLTree2();
	return 0;
}
清扰077
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
AVL树的c++实现
08-03
在C++中实现AVL树，我们可以利用模板类来增强代码的通用性，并通过智能指针如`shared_ptr`来管理内存，避免内存泄漏。 首先，我们需要定义一个AVL树节点结构体，包括节点值、高度、左子树和右子树的指针。由于我们...
手撕AVL_二叉平衡树(图文并茂)
最新发布
weixin_73869209的博客
11-25 356
大家好,今天带大加手撕AVL树的插入一 .为了AVL树实现简单，AVL树节点在定义时维护一个平衡因子，具体节点定义如下：int val;int bf;// 平衡因子 -> 当前节点的平衡因子=右子树高度-左子树的高度// 节点的左孩子// 节点的右孩子// 节点的双亲注意： 当前节点的平衡因子=右子树高度-左子树的高度。但是，不是每棵树，都必须有平衡因子，这只是其中的一种实现 方式。大家多多理解,我们下一篇博客见。
【高阶数据结构（壹）】——一步一步教你手撕AVL树（增删查改）画图详解，内含代码实现包含注释）
sjp11的博客
01-17 932
???? 1.AVL树的概念 AVL树一颗二叉搜索树 左右子树高度之差(简称平衡因子)的绝对值不超过1。 如果一颗AVL树有n个节点，其高度可以保持在O(logn),搜索的时间复杂度是O(logn). ???? 2.AVL树节点的定义 template<class K,class V> struct AVLTreeNode { AVLTreeNode* _left;//左孩子节点 AVLTreeNode* _right;//右孩子节点 AVLTreeNode* parent;//
手撕AVL树
GG_Bruse的博客
11-19 802
两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明AVL树
手撕，高级数据结构——AVL树的实现和插入方法
回水的博客
07-31 1246
AVL树的实现和插入方法
AVL树 C++ 实现
03-05
在C++中实现AVL树，我们可以利用模板类来创建一个泛型的数据结构，这样就可以处理不同类型的元素。 首先，我们需要定义AVL树的节点结构。每个节点包含三个部分：键（key）存储元素值，高度（height）用于计算树的...
基于C++ AVL树的航空客运订票系统【100012693】
06-12
《基于C++ AVL树的航空客运订票系统详解》 航空客运订票系统是现代航空公司运营中的关键组成部分，它能够高效地处理航班信息、预订和退票等业务。本项目以C++编程语言为基础，利用AVL树这一自平衡二叉搜索树的数据...
C++平衡Avl树实现.zip
08-20
总的来说，C++实现AVL树涉及到理解二叉搜索树、平衡树的概念，熟悉递归算法，掌握旋转操作的逻辑，以及编写相应的测试用例。通过这样的实现，我们可以创建一个高效的数据结构，用于处理大量数据的快速查找、插入和...
C++版AVL树课程设计源代码
11-04
该程序通过C++实现了AVL树的一些基础操作：1.编写AVL树判别程序，并判别一个二叉搜索树是否为AVL树；2.实现AVL树的ADT，包括其上的基本操作：结点的加入和删除；3.实现基本操作的动态演示(图形演示)；最重要的是，该...
手写AVL树(详解插入时的4种旋转)
qq_45928272的博客
06-03 380
二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接 近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)。 所以科学家对二叉搜索树采取平衡处理，实现出AVL树。 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 当这棵树是AVL树的时候，它的左右子树都是AVL树 且左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1) 如果一棵二叉搜索树的高度是平衡的，它就是AVL树。如果它有n
AVL树（平衡二叉树）
青萍之末的博客
05-21 2917
一、AVL树的特征   虽说二叉查找树是一种优秀的数据结构，能够大大降低数据查询的复杂度。但是，并不是说有情况下二叉树都能够达到快速查找的目的。   我们发现，如果按照[7,10,11,12,14,15,18]这样的顺序一个个元素进行插入的话就会出现右图所示的二叉树，这样的二叉树跟一个链表几乎是没有区别的，查找的效率一样，没有体现出二叉树的优势。出现这种原因是构建二叉树的过程中没有平衡节点...
AVL树详解
北川_的博客
03-09 1609
目录AVL树的概念AVL树节点的定义AVL树如何高度平衡？右单旋左单旋左右双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。 因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)， 即可降低树的高度，从而减少平均搜索长度。 AVL
数据结构学习笔记 6-1 手撕AVL树 与 LeetCode真题（Java）
How many ten years in the life time?
09-06 1867
AVL树就是平衡的二叉搜索树，本节的选题都是跟二叉搜索树相关的，只要把二叉搜索树理解透彻了，那么学习AVL树就会轻松许多了。二叉搜索树比较复杂的点在于删除，根据出度的不同对应不同的删除策略。AVL树就是在二叉搜索树上增加了平衡的机制，具体对应左旋和右旋LLLLLL型、LRLRLR型、RRRRRR型 和RLRLRL型，针对不同类型的失衡有不同类型的旋转策略。LeetCode面试题 04.09. 二叉搜索树序列hard只要父节点出现在子节点之前就可以。
将BST变平衡(手撕AVL树)
miracleon的博客
08-22 500
力扣1382 什么是平衡二叉树(AVL)——知乎 [平衡二叉树(博客园)] (https://www.cnblogs.com/huangxincheng/archive/2012/07/22/2603956.html) 强调，手撕AVL并不是最优解，只是通解，时间复杂度是nlog(n)。 利用二叉搜索树的性质，中序遍历输出，然后以中间为root，递归构造树，效率更高，算是本题的最优解。 提交时发现，必须初始化叶子节点高度为1，0也不行 public AVLNode(int val){ this
avl树的基本操作
LeetCode
05-10 370
#include&lt;cstdio&gt;#include&lt;algorithm&gt;#include&lt;queue&gt;using namespace std;struct node{    int v,height; //v为节点的权值,height为当前子树的高度    node *lchild,*rchild; //左右子树结点地址} *root;// 新建根节点node* ...
手撕AVL树-N*！！！
weixin_46571036的博客
08-15 115
二叉排序树的基础知识 名称：二叉排序树、二叉搜索树 性质： 1、左子树<根结点 2、右子树>根结点 用途：解决与排名相关的检索要求 构造二叉排序树： /* * @Author: mikey.peng * @Date: 2021-08-08 19:52:23 * @Last Modified by: mikey.peng * @Last Modified time: 2021-08-08 19:52:23 */ #include<iostream> #includ
算法和数据结构
qq_38415505的博客
10-26 403
数据结构 堆 长度为n的数组构建成最小堆的时间复杂度 B、B+树、红黑树 说一下B+树和二叉搜索树的区别？ 说一下二叉搜索树和AVL树、红黑树之间的差别 说下红黑树原理，红黑树你看伪代码的时候他有两坨比较一样的有没有注意过 哪些情况下用栈 知道哈希吗？二叉树比哈希牛逼在哪里？各自有什么优缺点，我就从查找和排序上个举了个例子。 哈希解决冲突有哪些机制。 一致性哈希的一致性是什么意...
非递归实现AVL树与线性表操作
"该资源是针对非线性数据结构，特别是AVL树的非递归实现的实验指导，包括线性表的双链表实现、树排序和银行账户管理系统的应用。实验旨在帮助在校大学生掌握数据结构的核心概念，并通过C++编程实践来提升技能。实验...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

清扰077

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值