C++中的AVL树（附模拟实现）

于 2024-05-12 00:28:02 发布
阅读量846 收藏 25
点赞数 20
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hh121386/article/details/138733132
版权

在上一篇文章中，我们对map/multimap/set/multiset进行了简单的认识，这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。

一、AVL树的概念

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

二、AVL树节点的定义

template<class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& data = T())
		: _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）调整节点的平衡因子

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

// 在AVL树中插入值为data的节点
bool Insert(const T& data)
{
    //1. 先按照二叉搜索树的规则将节点插入到AVL树中
	if (_pRoot == nullptr)
	{
		_pRoot = new Node(data);
		return true;
	}
	Node* parent = nullptr;
	Node* cur = _pRoot;
	while (cur)
	{
		if (cur->_data < data)
		{
			parent = cur;
			cur = cur->_pRight;
		}
		else if (cur->_data > data)
		{
			parent = cur;
			cur = cur->_pLeft;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(data);
	if (parent->_data < data)
	{
		parent->_pRight = cur;
	}
	else
	{
		parent->_pLeft = cur;
	}
	cur->_pParent = parent;
	//更新平衡因子
	while (parent)
	{
		if (cur == parent->_pLeft)
		{
			parent->_bf--;
		}
		else
		{
			parent->_bf++;
		}
		if (parent->_bf == 0)
		{
			break;
		}
		else if (parent->_bf == 1 || parent->_bf == -1)
		{
			cur = parent;
			parent = parent->_pParent;
		}
		else if (parent->_bf == 2 || 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);
			}
			break;
		}
	}
	return true;
}

四、AVL树的旋转

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

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

上图在插入前，AVL树是平衡的，新节点插入到30的左子树(注意：此处不是左孩子)中，30左子树增加了一层，导致以60为根的二叉树不平衡，要让60平衡，只能将60左子树的高度减少一层，右子树增加一层，即将左子树往上提，这样60转下来，因为60比30大，只能将其放在30的右子树，而如果30有右子树，右子树根的值一定大于30，小于60，只能将其放在60的左子树，旋转完成后，更新节点的平衡因子即可。在旋转过程中，有以下几种情况需要考虑：
（1）30节点的右孩子可能存在，也可能不存在
（2）60可能是根节点，也可能是子树
如果是根节点，旋转完成后，要更新根节点
如果是子树，可能是某个节点的左子树，也可能是右子树
 

// 右单旋
void RotateR(Node* pParent)
{
	Node* subl = pParent->_pLeft;
	Node* sublr = subl->_pRight;
	pParent->_pLeft = sublr;
	if (sublr)
	{
		sublr->_pParent = pParent;
	}
	subl->_pRight = pParent;
	Node* ppNode = pParent->_pParent;
	pParent->_pParent = subl;
	if (pParent == _pRoot)
	{
		_pRoot = subl;
		subl->_pParent = nullptr;
	}
	else
	{
		if (ppNode->_pLeft == pParent)
		{
			ppNode->_pLeft = subl;
		}
		else
		{
			ppNode->_pRight = subl;
		}
		subl->_pParent = ppNode;
	}
	pParent->_bf = subl->_bf = 0;
}

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

与右单旋相似

// 左单旋
void RotateL(Node* pParent)
{
	Node* subr = pParent->_pRight;
	Node* subrl = subr->_pLeft;
	pParent->_pRight = subrl;
	if (subrl)
	{
		subrl->_pParent = pParent;
	}
	subr->_pLeft = pParent;
	Node* ppNode = pParent->_pParent;
	pParent->_pParent = subr;
	if (pParent == _pRoot)
	{
		_pRoot = subr;
		subr->_pParent = nullptr;
	}
	else
	{
		if (ppNode->_pRight == pParent)
		{
			ppNode->_pRight = subr;
		}
		else
		{
			ppNode->_pLeft = subr;
		}
		subr->_pParent = ppNode;
	}
	pParent->_bf = subr->_bf = 0;
}

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

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

// 左右双旋
void RotateLR(Node* pParent) 
{
	Node* subl = pParent->_pLeft;
	Node* sublr = subl->_pRight;
	int bf = sublr->_bf;
	RotateL(subl);
	RotateR(pParent);

	sublr->_bf = 0;
	if (bf == -1)
	{
		subl->_bf = 0;
		pParent->_bf = 1;
	}
	else if (bf == 1)
	{
		subl->_bf = -1;
		pParent->_bf = 0;
	}
	else
	{
		subl->_bf = 0;
		pParent->_bf = 0;
	}
}

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

参考右左双旋

// 右左双旋
void RotateRL(Node* pParent)
{
	Node* subr = pParent->_pRight;
	Node* subrl = subr->_pLeft;
	int bf = subrl->_bf;
	RotateR(subr);
	RotateL(pParent);

	subrl->_bf = 0;
	if (bf == 1)
	{
		subr->_bf = 0;
		pParent->_bf = -1;
	}
	else if (bf == -1)
	{
		pParent->_bf = 0;
		subr->_bf = 1;
	}
	else
	{
		pParent->_bf = 0;
		subr->_bf = 0;
	}
}

5.总结

假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑
(1)pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
当pSubR的平衡因子为1时，执行左单旋
当pSubR的平衡因子为-1时，执行右左双旋
(2)pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL
当pSubL的平衡因子为-1是，执行右单旋
当pSubL的平衡因子为1时，执行左右双旋
旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。

五、AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：
（1）验证其为二叉搜索树
如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
（2）验证其为平衡树
每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
节点的平衡因子是否计算正确

public:
    // AVL树的验证
	bool IsAVLTree()
	{
		return _IsAVLTree(_pRoot);
	}

private:
	// 根据AVL树的概念验证pRoot是否为有效的AVL树
	bool _IsAVLTree(Node* pRoot)
	{
		if (pRoot == nullptr)
		{
			return true;
		}
		int left = _Height(pRoot->_pLeft);
		int right = _Height(pRoot->_pRight);
		return (abs(right - left) < 2) && _IsAVLTree(pRoot->_pLeft) && _IsAVLTree(pRoot->_pRight);
	}
	size_t _Height(Node* pRoot)
	{
		if (pRoot == nullptr)
		{
			return 0;
		}
		int left = _Height(pRoot->_pLeft) + 1;
		int right = _Height(pRoot->_pRight) + 1;
		return left > right ? left : right;
	}

六、中序遍历

public:
	void Inorder()
	{
		_Inorder(_pRoot);
		cout << endl;
	}
private:
	void _Inorder(Node* pRoot)
	{
		if (pRoot == nullptr)
		{
			return;
		}
		_Inorder(pRoot->_pLeft);
		cout << pRoot->_data << " ";
		_Inorder(pRoot->_pRight);
	}

七、全部代码

#pragma once
#include <assert.h>
#include <iostream>
using namespace std;
template<class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& data = T())
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _bf(0)
	{}

	AVLTreeNode<T>* _pLeft;
	AVLTreeNode<T>* _pRight;
	AVLTreeNode<T>* _pParent;
	T _data;
	int _bf;   // 节点的平衡因子
};


// AVL: 二叉搜索树 + 平衡因子的限制
template<class T>
class AVLTree
{
	typedef AVLTreeNode<T> Node;
public:
	AVLTree()
		: _pRoot(nullptr)
	{}

	// 在AVL树中插入值为data的节点
	bool Insert(const T& data)
	{
		if (_pRoot == nullptr)
		{
			_pRoot = new Node(data);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _pRoot;
		while (cur)
		{
			if (cur->_data < data)
			{
				parent = cur;
				cur = cur->_pRight;
			}
			else if (cur->_data > data)
			{
				parent = cur;
				cur = cur->_pLeft;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(data);
		if (parent->_data < data)
		{
			parent->_pRight = cur;
		}
		else
		{
			parent->_pLeft = cur;
		}
		cur->_pParent = parent;
		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_pLeft)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_pParent;
			}
			else if (parent->_bf == 2 || 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);
				}
				break;
			}
		}
		return true;
	}

	// AVL树的验证
	bool IsAVLTree()
	{
		return _IsAVLTree(_pRoot);
	}

	void Inorder()
	{
		_Inorder(_pRoot);
		cout << endl;
	}
private:
	// 根据AVL树的概念验证pRoot是否为有效的AVL树
	bool _IsAVLTree(Node* pRoot)
	{
		if (pRoot == nullptr)
		{
			return true;
		}
		int left = _Height(pRoot->_pLeft);
		int right = _Height(pRoot->_pRight);
		return (abs(right - left) < 2) && _IsAVLTree(pRoot->_pLeft) && _IsAVLTree(pRoot->_pRight);
	}
	size_t _Height(Node* pRoot)
	{
		if (pRoot == nullptr)
		{
			return 0;
		}
		int left = _Height(pRoot->_pLeft) + 1;
		int right = _Height(pRoot->_pRight) + 1;
		return left > right ? left : right;
	}
	void _Inorder(Node* pRoot)
	{
		if (pRoot == nullptr)
		{
			return;
		}
		_Inorder(pRoot->_pLeft);
		cout << pRoot->_data << " ";
		_Inorder(pRoot->_pRight);
	}
	// 右单旋
	void RotateR(Node* pParent)
	{
		Node* subl = pParent->_pLeft;
		Node* sublr = subl->_pRight;
		pParent->_pLeft = sublr;
		if (sublr)
		{
			sublr->_pParent = pParent;
		}
		subl->_pRight = pParent;
		Node* ppNode = pParent->_pParent;
		pParent->_pParent = subl;
		if (pParent == _pRoot)
		{
			_pRoot = subl;
			subl->_pParent = nullptr;
		}
		else
		{
			if (ppNode->_pLeft == pParent)
			{
				ppNode->_pLeft = subl;
			}
			else
			{
				ppNode->_pRight = subl;
			}
			subl->_pParent = ppNode;
		}
		pParent->_bf = subl->_bf = 0;
	}
	// 左单旋
	void RotateL(Node* pParent)
	{
		Node* subr = pParent->_pRight;
		Node* subrl = subr->_pLeft;
		pParent->_pRight = subrl;
		if (subrl)
		{
			subrl->_pParent = pParent;
		}
		subr->_pLeft = pParent;
		Node* ppNode = pParent->_pParent;
		pParent->_pParent = subr;
		if (pParent == _pRoot)
		{
			_pRoot = subr;
			subr->_pParent = nullptr;
		}
		else
		{
			if (ppNode->_pRight == pParent)
			{
				ppNode->_pRight = subr;
			}
			else
			{
				ppNode->_pLeft = subr;
			}
			subr->_pParent = ppNode;
		}
		pParent->_bf = subr->_bf = 0;
	}
	// 右左双旋
	void RotateRL(Node* pParent)
	{
		Node* subr = pParent->_pRight;
		Node* subrl = subr->_pLeft;
		int bf = subrl->_bf;
		RotateR(subr);
		RotateL(pParent);

		subrl->_bf = 0;
		if (bf == 1)
		{
			subr->_bf = 0;
			pParent->_bf = -1;
		}
		else if (bf == -1)
		{
			pParent->_bf = 0;
			subr->_bf = 1;
		}
		else
		{
			pParent->_bf = 0;
			subr->_bf = 0;
		}
	}
	// 左右双旋
	void RotateLR(Node* pParent) 
	{
		Node* subl = pParent->_pLeft;
		Node* sublr = subl->_pRight;
		int bf = sublr->_bf;
		RotateL(subl);
		RotateR(pParent);

		sublr->_bf = 0;
		if (bf == -1)
		{
			subl->_bf = 0;
			pParent->_bf = 1;
		}
		else if (bf == 1)
		{
			subl->_bf = -1;
			pParent->_bf = 0;
		}
		else
		{
			subl->_bf = 0;
			pParent->_bf = 0;
		}
	}

private:
	Node* _pRoot;
};

八、测试

#include"AVLtree.h"
#include <vector>
void TestAVLTree()
{
	int a1[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	int a2[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	cout << "=================test1==================" << endl;
	AVLTree<int> t1;
	for (auto e : a1)
	{
		t1.Insert({ e});

		cout << "Insert:" << e << "->" << t1.IsAVLTree() << endl;
	}
	t1.Inorder();
	cout << t1.IsAVLTree() << endl;


	cout << "=================test1==================" << endl;
	AVLTree<int> t2;
	for (auto e : a2)
	{
		t1.Insert({ e });

		cout << "Insert:" << e << "->" << t1.IsAVLTree() << endl;
	}
	t2.Inorder();
	cout << t2.IsAVLTree() << endl;
}

int main()
{
	TestAVLTree();
	return 0;
}

九、AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即log2 N。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。
 

hh121386
关注
专栏目录
AVL树（高度平衡的二叉搜索树）
wjw1993year的博客
10-31 2403
AVL树（高度平衡的二叉搜索树） AVL树全称是平衡二叉搜索树，相比于红黑树，它是一种高度平衡的二叉搜索树，所有节点的左右子树高度差不超过1。 树结点 /** * parent 父节点 * left 左子树 * right 右子树 * height 高度，叶子结点高度为1 */ class TreeNode { int key; // 结点值、键值 TreeNode parent; TreeNode left; TreeNode right; i
【C/C++】AVL树的特点及模拟实现
Yfan133的博客
02-08 283
文章目录AVL树的特点AVL插入后的四种场景代码实现 AVL树的特点 二叉搜索树可以使查找的效率提升到log2nlog_2nlog2​n，但如果数据基本有序那么二叉搜索树会退化成单枝树，查找效率相当于在顺序表中搜索数据，效率低。两种平衡二叉搜索树解决了这个问题：AVL树和红黑树 AVL树特点： 每个节点的左右子树高度差的绝对值不超过1，即降低了树的高度，从而降低平均搜索时间 空树也是AVL树，AVL树的每颗子树都是AVL树 因此AVL树每进行一次插入删除操作都要保证树的平衡 AVL插入后的四种场景
二叉搜索树
星光之子的博客
03-30 826
二叉搜索树概述在二叉搜索树中实现搜索、插入、删除操作总结高度平衡的二叉搜索树为什么需要用到高度平衡的二叉搜索树?如何实现一个高度平衡的二叉搜索树?高度平衡的二叉搜索树的实际应用 概述 二叉搜索树（BST）是二叉树的一种特殊表示形式，它满足如下特性： 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值 每个节点中的值必须小于（或等于）存储在其右子树中的任何值 验证一个树是否是二叉搜索树：值得注意的是，对于二叉搜索树，可以通过 中序遍历 得到一个 递增的有序序列。因此，中序遍历是二叉搜索树中最常用的
高度平衡二叉搜索树（AVL树）
最新发布
bang___bang_的博客
07-20 524
本文详解AVL树的插入操作，分为2种情况：不旋转和旋转；旋转又细分4个情况:左单璇、右单旋、左右双旋、右左双旋。文章图文并茂，详细讲解实现操作和代码实现。不要从轮子重新造起，要站在巨人的肩膀上！深究原理和实现细节是绝对有帮助的！
高度平衡二叉搜索树（AVLTree）
qq_49613557的博客
11-15 3744
高度平衡搜索二叉树（AVLTree） 目录AVL树的概念AVL树节点的定义AVL树的插入AVL树的旋转右单旋左单旋左右双旋右左双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，
构建平衡二叉树
李晓洁 廊坊师范学院信息技术提高班 12期
12-22 1461
我们对二叉树，二叉排序树的构建过程都很清楚，也知道二叉平衡树的概念，但是如何根据一个序列来构建平衡二叉树呢? 我们是通过在一棵平衡二叉树中依次插入元素(按照二叉排序树的方式)，若出现不平衡，则要根据新插入的结点与最低不平衡结点的位置关系进行相应的调整。分为LL型、RR型、LR型和RL型4种类型，各调整方法如下(下面用A表示最低不平衡结点)：
C++实现AVL树
everthing willl be ok
03-13 260
一、AVL树概念 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 二、导致AVL树不平衡的几种情况 （1）LL：插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因...
模拟实现AVLTree超详解（C++）
m0_67430750的博客
05-09 898
模拟实现AVLTree万字详解，包括了KV模型和K模型。同时封装了正反迭代器（const和非const）。
平衡搜索树--AVL树的实现
sinat_40408114的博客
08-23 240
平衡搜索树 在原来的二叉搜索树我们提到，如果对普通的二叉搜索树连续有序地插入会导致二叉搜索树退化成链表，操作复杂的从O(log N)退化到O(N)。而AVL树和红黑树这些平衡二叉树就是避免这种最坏情况的出现，对左右孩子子树高度差大于2时进行重新调整，让搜索树始终保持一个健康的状态，保证相关操作都在O(log N)。同时关于STL，哈希表<unordered_map>(原为<has...
模拟实现二叉搜索树超详解（C++）
m0_67430750的博客
05-06 756
模拟实现二叉搜索树，包括了递归和非递归两种版本。
zupushu.rar_家族树 c_族谱_族谱c++_族谱c++二叉树_树族谱
09-19
在这个项目中，“zupushu.rar_家族树 c_族谱_族谱c++_族谱c++二叉树_树族谱” 提供了用C和C++编程语言实现家族族谱查询的源代码，主要关注同辈和子女的查询功能。 首先，让我们深入了解家族树和二叉树的基础知识。...
AVL树/高度平衡二叉搜索树
m0_61780496的博客
03-25 435
AVL树/高度平衡二叉搜索树的底层实现，定义AVL树节点，插入场景要考虑4种情况：左单旋、右单旋、左右旋、右左旋，性能分析
高度平衡的二叉搜索树-----AVL树
z_xiao_xue的博客
09-22 1159
AVL树是高度平衡的二叉搜索树，它能保持二叉树的高度平衡，尽可能降低二叉树的高度，减少数的平均搜索长度 AVL树的几个特点： 1.左右子树高度绝对值不超过1 2.树的每左右子树都是AVL树 3.每个节点的平衡因子是-1，0，1(平衡因子 = 右子树高度-左子树高度) 一棵AVL树有N个节点，其高度可以保持在log2N,插入/删除/查找的复杂度也在log2N(log2N就是以2为底N的对数
AVL树----高度平衡的二叉搜索树
csdn_edition的博客
01-19 552
AVL树的定义： 一颗AVL树或者是一颗空树，或者是一颗具有下列性质的二叉搜索树：它的左子树和右子树都是一颗AVL树，并且左子树和右子树的高度之差的绝对值不超过1。 我们来对AVL树进行结构的设计： typedef struct AVLNode { AVLNode* leftchild;//左孩子 AVLNode* rightchild;//有孩子 AVLNode* parent;//双亲 int data;//数据域 }AVLNode; typedef struct { AVLNode* hea
数据结构进阶—AVL树(高度平衡二叉搜索树)
冯同学的博客
05-17 717
1、AVL树的基本概念1.1 性质1.2 适用场景2、AVL树的插入实现2.1 平衡因子的调节2.2 四种旋转情况2.2.1 右单旋(RR型)2.2.2 左单旋(LL型)2.2.3 左右单旋(LR型)2.2.4 右左单旋(RL型)3、整体代码及验证3.1 代码3.2 验证
【数据结构】AVL树（高度平衡的二叉搜索树）
weixin_60053402的博客
12-23 554
AVL树（高度平衡的二叉搜索树）的创建，First，Next，Last，Prev，遍历，查找，删除等函数的实现
【二叉搜索树】(四) 高度平衡的二叉搜索树
闻韶
08-16 831
LeetCode - 探索卡片 - 二叉搜索树 - 附录 - 高度平衡的二叉搜索树
二叉树合集（六）：高度平衡的二叉搜索树简介(图文解析）
Viper的程序员修炼手册
06-25 3041
高度平衡的二叉搜索树简介 在这篇文章中，我们将帮助你理解高度平衡的二叉搜索树的基本概念。 什么是一个高度平衡的二叉搜索树? 树结构中的常见用语: 节点的深度 - 从树的根节点到该节点的边数 节点的高度 - 该节点和叶子之间最长路径上的边数 树的高度 - 其根节点的高度 一个高度平衡的二叉搜索树（平衡二叉搜索树）是在插入和删除任何节点之后，可以自动保持其高度最小。也就是说，有*N个节点的平衡二叉搜索树，它的高度是logN*。并且，每个节点的两个子树的高度不会相差超过1。 为什么是logN呢?
冰冰学习笔记：平衡二叉搜索树
bingbing_bang的博客
11-14 504
AVL树的旋转 红黑树的调整，变色加旋转 红黑树的迭代器实现 map和set的封装
C++实现数据结构：二叉搜索树与AVL树的构建与操作
"数据结构用C++描述，包含二叉搜索树、AVL搜索树、B-树和散列及冲突解决的理论与实践题目解答" 在数据结构中，C++是一种常用的语言来实现各种数据结构。本资料主要关注的是二叉搜索树、AVL树、B-树以及散列表等概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值