＜数据结构＞AVL树详解

已于 2023-08-28 19:00:22 修改
阅读量427 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2023-08-28 18:59:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63246064/article/details/132541024
版权

目录

AVL是什么？

平衡因子

旋转

左单旋

右单旋

左右双旋

右左双旋

全部的代码

AVL树又叫平衡树(Balance_Tree)，笔者认为这个名字非常不错，中国嘛，就是在意阴阳平衡，之前小编还拿这个当过自己网络IP，哈哈哈。

AVL是什么？

本文适合有一点点数据结构基础的来看，简单的树形结构知道吧，也就是一堆根和结点的集合，那它有啥用呢？我们一般用树形结构来做什么呢？说这个之前，我们不妨先来看看其他的数据结构的作用

链表：它是链式结构，单向和双向两种结构，能做到简单的数据插入和删除，且效率不算低，时间复杂度 O(1)，查找数据时间复杂度 O(N)

栈：满足先入后出的特性，不支持查找

队列：满足先入先出的特性，不支持查找

顺序表：线性表结构，能做到简单的插入删除，效率相比链表低了些，时间复杂度O (N)，查找数据的时间复杂度 O(N)

上面列举的几个结构，我们将其相互对比一下，最理想的也就是插入可以O(1)，但是查找是O(N)，那如果我们还想要再优化呢，这里大家去了解一下二叉搜索树，很简单的一个用于数据搜索的树形结构，它的插入是O(1)，数据查询是有条件达到O(logN)的，但是由于没有任何的优化算法，所以搜索树可能会出现左右子树的高度差太大了，甚至数据都在一边的极端情况，这时的查找复杂度又变为了O(N)，我们这里介绍的AVL树就是在二叉搜索树的基础上进行了优化调整，结果是控制每一个根结点的左右子树的高度差不超过1

上面说所的高度差不超过1，也是AVL树的平衡由来

平衡因子

为了便于我们控制平衡的算法，我们引入一个平衡因子 bf 进来，并制定规则：新插入的结点在左子树 bf--，在右结点 bf++

template<class K, class V>
struct AVLTreeNode
{
	// 三叉链
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;

	std::pair<K, V> _kv; // 数据
	int _bf; // 平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_kv(kv),
		_bf(0)
	{

	}
};

这样我们可以直接通过平衡因子的数值来反映该结点是否已经平衡了。AVL树要保证的就是每一棵子树都是平衡的，最后总体也就平衡了。如果 bf == 0 说明左右子树高度相等，bf == 1 说明右子树比左子树高一层，bf == -1 说明左子树比右子树高一层，否则其他情况都是不符合平衡的

说到这，最重要的接口就是Insert插入接口的设计了

平衡树的数据都是(K，V)结构的，我们采用pair来放有效数据，我们将需要的数据传入接口时，我们第一步要做的就是找到我们待插入的位置，延续搜索二叉树的特点，为了方便后面left就是左子树，right就是右子树，root就是根结点，parent就是父节点

规定：left < root < right

直接和传入的kv值比较查询即可

		while (cur)
		{
			// 找到待插入叶子 规定：left < root < right
			parent = cur;
			if (cur->_kv.first < kv.first)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

找到后在判断该位置是parent的left还是right插入即可

// 找到后开始插入
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

正常插入后，便是关键的一步，更新控制平衡因子！

就和上面说的一样，从插入这里的parent开始逐步向上更新，插入的是left就是parent->_bf--，right就是++，之后在判断 parent->_bf 的值，如下

如果 bf == 0 说明左右子树高度相等，bf == 1 说明右子树比左子树高一层，bf == -1 说明左子树比右子树高一层，否则其他情况都是不符合平衡的，则需要做旋转的处理，下面的函数我们后续详细解释，这个是精髓！！！

// 更新平衡因子
        while (parent)
		{
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else if (cur == parent->_left)
			{
				parent->_bf--;
			}

			if (parent->_bf == 0)
			{
				break;
			}
			else if (abs(parent->_bf) == 1)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (abs(parent->_bf) == 2)
			{
				// 说明parent所在的子树已经不平衡了，需要旋转处理
				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);
			}
		}

上面代码的框架就完成了80%了，剩下的就只需要将其20%的旋转细节处理完就可以了，这里看到有左旋，右旋，左右旋转，右左旋转，是什么意思呢？我们看下图

 我们看到左边的cur插入后，8结点的 bf == 2了，不满足平衡了，我们做了一次旋转处理后，在不改变 left < root < right 这个条件的前提下，又让了 left 和 right 的高度差 == 0 了，这就是一次旋转处理，接下来我们只需要将所有的旋转情况完善即可。

旋转

左单旋

 左单旋处理的情况，图中见，parent的右子树的右子树插入结点后破坏了平衡，我们进行一次左单旋后，变成右边的样子，重新恢复平衡，左旋含义即将这里的30从左边上旋转到了左下来。

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

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

		parent->_parent = subR;
		subR->_left = parent;
		
		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			subR->_parent = pNode;

			if (parent == pNode->_left)
			{
				pNode->_left = subR;
			}
			else
			{
				pNode->_right = subR;
			}
		}

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

右单旋

和上面的左单旋情况类似

 右单旋的含义就是右上的60旋转到右下来了

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

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

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

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

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

左右双旋

 这里的情况稍微复杂了一点，左单旋和右单旋都是处理的要么是右边的增加，要么是左边的增加，双旋处理的是中间子树增加，这里中间子树的增加又可以分为两种情况，加在左子树和加在右子树

从这里的图中看出，现在处理的事加在左子树的情况，注意这里的左右子树是90结点的左右子树，图中也可以看出，60结点插入在它的left和right的处理情况相同，唯一的差别就是处理后，需要区别的处理一下平衡因子的更新

甚至我们可以想一个极端情况，下面看到依然是不影响的

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

		RotateL(subL);
		RotateR(parent);

		// 左子树 or 右子树
		if (bf == -1)
		{
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
		subLR->_bf = 0;
	}

右左双旋

和左右双旋类似，这里新结点是插入在了parent的右边中间

 我们根据图中的结构变化来处理结点之间的关系即可，先将90右旋，再将30左旋

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

		// 左子树 or 右子树
		if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			assert(false);
		}
		subRL->_bf = 0;
	}

全部的代码

#pragma once

#include <iostream>
#include <map>
#include <cassert>

using std::pair;
using namespace std;

/*
	1.定义AVL节点类型
	2.定义AVL树类型
*/

// AVLNode
template<class K, class V>
struct AVLTreeNode
{
	// 三叉链
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;

	std::pair<K, V> _kv; // 数据
	int _bf; // 平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_kv(kv),
		_bf(0)
	{

	}
};

// AVLTree
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 _root;
		}

		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			// 找到待插入叶子 规定：left < root < right
			parent = cur;
			if (cur->_kv.first < kv.first)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		// 找到后开始插入
		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 if (cur == parent->_left)
			{
				parent->_bf--;
			}

			if (parent->_bf == 0)
			{
				break;
			}
			else if (abs(parent->_bf) == 1)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (abs(parent->_bf) == 2)
			{
				// 说明parent所在的子树已经不平衡了，需要旋转处理
				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;
	}

	void InOrder()
	{
		_InOrder(_root);
		return;
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}

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

		cout << root->_kv.first << "-diff:" << diff << " bf:" << root->_bf << " " << endl;

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

		return abs(leftHT - rightHT) < 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;
	}

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

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

		parent->_parent = subR;
		subR->_left = parent;
		
		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			subR->_parent = pNode;

			if (parent == pNode->_left)
			{
				pNode->_left = subR;
			}
			else
			{
				pNode->_right = subR;
			}
		}

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

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

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

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

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

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

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

		RotateL(subL);
		RotateR(parent);

		// 左子树 or 右子树
		if (bf == -1)
		{
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
		subLR->_bf = 0;
	}

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

		// 左子树 or 右子树
		if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			assert(false);
		}
		subRL->_bf = 0;
	}

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

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

private:
	Node* _root = nullptr;
};

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

	t1.InOrder();

	cout << "IsBalance:" << t1.IsBalance() << endl;

	// 测试平衡因子是否异常
	int b[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	AVLTree<int, int> t2;
	for (auto e : b)
	{
		t2.Insert(make_pair(e, e));
	}


	t2.InOrder();

	cout << "IsBalance:" << t2.IsBalance() << endl;
}

绅士·永
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之二叉平衡树
jygqm的博客
06-16 2343
二叉平衡树（AVL树），是带有平衡条件的二叉树查找树，这个平衡条件必须要容易保持，且必须保证树的深度是O(logN).。这里的平衡条件是左右子树高度差最多差1的二查找树。如果插入一个节点后破坏了平衡条件，那么就要做一些操作去恢复AVL树， 这里的操作一般称为旋转。第一种情况是插入的节点在外面，即（左-左或右-右）、另一种是节点插在里面，即（左-右或右-左）， 对于第一种情况我们采用单旋转，第二种采...
【数据结构】平衡树 - treap
繁凡さん的博客
08-20 386
treap = tree + heap 树堆（treap：让BST尽量随机） 动态维护一个有序序列 对于一个大根堆： 最大值：一直往右走 最小值：一直往左走 treap实现操作 set实现 ①插入 insert ②删除（使其变成叶子节点） erase ③找前驱（中序遍历的前一个位置）/后继（中序遍历的后一个位置） lower_bound ④找最大/最小 begin(),end(); ⑤求某个值的排名 无 ⑥求排名是k的数是谁 无 ⑦比某个数小的最大值 ( 这个数可以不
数据结构-平衡树
HeartFireY的博客
06-07 385
数据结构-平衡树 ???? | Powered By HeartFireY | Balanced Tree ???? | 需要的前导知识：二叉搜索树(BST) 一、概念 平衡树是二叉搜索树和堆合并构成的数据结构，它满足以下性质： 空树是平衡树； 非空平衡树左右两个子树高度的绝对差不超过111； 非空平衡树左右子树均为平衡树 对一棵二叉搜索树进行查询/新增/删除等操作，所花的时间与树的高度hhh成比例，如果二叉搜索树退化为链，那么h=nh = nh=n，此时时间复杂度最差。因此让树尽可能的维持矮平的状态有
数据结构——平衡树
qq_41982346的博客
06-05 284
数据结构——平衡树
数据结构之平衡树(Treap)
long-long-ago
06-19 2万+
平衡树是二叉搜索树和堆合并构成的新数据结构，所以它的名字取了Tree和Heap各一半，叫做Treap。 堆和树的性质是冲突的，二叉搜索树满足左子树<根节点<右子树，而堆是满足根节点小于等于(或大于等于)左右儿子。因此在Treap的数据结构中，并不是以单一的键值作为节点的数据域。Treap每个节点的数据域包含2个值，key和weight。 key值，和原来的二叉搜索树一样，满足左子树<根节点<右子
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
数据结构之红黑树详解
12-31
它的统计性能要好于平衡二叉树（AVL树），因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的...
数据结构之伸展树详解
09-04
在实现伸展树时，通常会使用C++或其他编程语言的数据结构来表示节点，并定义旋转操作的函数。代码中会包含旋转的具体实现，如在给定的描述中提到的`Rotate(node *x, int d)`函数，用于执行左旋或右旋。 相比于传统...
java 树 查找_2-3 查找树及其Java实现
weixin_39606361的博客
02-12 285
2-3 查找树定义(来源：wiki)2–3树是一种树型数据结构，内部节点(存在子节点的节点)要么有2个孩子和1个数据元素，要么有3个孩子和2个数据元素，叶子节点没有孩子，并且有1个或2个数据元素。2个结点 定义如果一个内部节点拥有一个数据元素、两个子节点，则此节点为2节点。如果一个内部节点拥有两个数据元素、三个子节点，则此节点为3节点。当且仅当以下叙述中有一条成立时，T为2–3树：T为空。即T不包...
数据结构系列之平衡树（AVL构建法）
永不放弃的博客
06-16 776
本文详解介绍了基于AVL的平衡树的建立过程，主要涉及的操作有四种旋转操作、插入、删除、遍历等
数据结构--平衡树--普通平衡树
Berserker____的博客
06-12 421
普通平衡树 一般说“普通平衡树”， 应该指的就是最早发明的平衡二叉树 “AVL树”。AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis，他们在1962年的论文《An algorithm for the organization of information》中发表了它。 为什么发明了平衡树 当我们用二叉树维护信息的时候，要进行插入/删除操作。例如下面的一棵二叉树。 二叉树体现了一种二分的思想，因此查找信息的期望复杂度在 log级。 但是二叉树的形态受操作顺序的影响，例
数据结构-平衡二叉树
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
10-25 594
1.定义 平衡二叉树又称为AVL树，或者为空树，或者具有以下性质的二叉树： 它的左子树和右子树都是平衡二叉树，且左子树和右子树的高度之差的绝对值不超过1。 若将二叉树结点的平衡因子定义为该结点左子树的高度减去其右子树的高度，则平衡二叉树上所有结点的平衡因子只可能是-1、0、1。 只要树上有一个结点的平衡因子的绝对值大于1，则该二叉树就不平衡。 最小不平衡树：是指离插入结点最近且以平衡...
数据结构 - 平衡二叉树（C++）
热门推荐
了解➔熟悉➔掌握➔精通
02-22 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 平衡二叉树的定义 平衡二叉树（Balanced Binary Tree）是具有以下性质的二叉树：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 判断一棵二叉树是否平衡（C++） /* * Cr...
数据结构——平衡树之红黑树
zp的博客
10-31 704
一、2-3树 在了解什么是红黑树之前，首先需要补充一下什么是2-3树，因为它有助于我们对红黑树的理解，包括对B类树的理解。 2-3树可以有两个孩子或三个孩子，所以也就被称为2-3树，且2-3满足二分搜索树的基本性质。如左图中，a的左孩子值 &lt; a，a右孩子的值 &gt; a，在右图中可以存放两个元素b、c，该树有三个孩子，左孩子的值 &lt; b，b &lt; 中间孩子的值 &lt;...
数据结构-树、二叉树、查找树、平衡树
2.wa
02-22 509
专栏原创出处：github-源笔记文件 ，github-源码 ，欢迎 Star，转载请附上原文出处链接和本声明。 文章目录1. 树的概念2. 二叉树2.1 二叉树的遍历2.2 二叉树的类型二叉树相关算法参考 1. 树的概念 具有 n(n≥0)n(n\ge 0)n(n≥0) 个节点的有限集称为树。 当 n=0n = 0n=0 时称为空树； 当 n≥1n\ge 1n≥1 时，仅有一个特定的称为根...
数据结构 平衡树-2-3查找树
qq_35677589的博客
01-25 58
首先先理解2-3查找树（一种平衡树）的定义 2、对2-3查找树进行插入操作
【数据结构】图文详解Treap平衡树
qq_49688477的博客
07-27 1639
一、前言 FHQ平衡树是一种树形数据结构，它是对二叉查找树的一种优化方式，但是学习的过程是真的非常的…痛苦。 二、二叉查找树的概念 首先，我们称具有以下3个性质的树为二叉查找树（BST） 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 如图 在这张图中我们可以发现，在二叉查找树中，从根结点开始查找一个点的时间复杂度为logn级别，在我们想对树进行插入查找的时候都非常方便。 但是很遗憾，二叉查找树是有着它的缺陷的
数据结构系列之平衡树（数组构建法），经典好文
最新发布
2401_84097774的博客
04-06 766
分享一套阿里大牛整理的前端资料给大家，点击前端校招面试题精编解析大全即可免费下载分享一套阿里大牛整理的前端资料给大家，点击前端校招面试题精编解析大全即可免费下载。
平衡树
yiye2017zhangmu的博客
08-08 2万+
一.概念：    平衡树是二叉搜索树和堆合并构成的数据结构，它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 二.优势    对一棵查找树(search tree)进行查询/新增/删除 等动作, 所花的时间与树的高度h 成比例, 并不与树的容量 n 成比例。如果可以让树维持矮矮胖胖的好身材, 也就是让h维持在O(lg n)左右, 完成上述工作就很...
优化数据结构：AVL树与平衡二叉操作详解
线段树和树状数组是用于高效查询区间和范围操作的数据结构，它们在解决区间查询问题时表现出色，常用于求解RMQ（Range Minimum Query）和LCA（Least Common Ancestor）等问题。 高级数据结构的学习对于提升编程技巧...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

绅士·永

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

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

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

打赏作者

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

抵扣说明：

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

余额充值