AVL树---平衡二叉查找树

原创 于 2025-09-15 07:00:00 发布 · 866 阅读 · 20 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#经验分享 #学习方法

文章目录

一、概念

若二叉查找树的左右不均衡（eg：左边的值很多，右边的高度很小，会导致查找效率低下），因此出现了平衡树。每一棵平衡树的左子树和右子树的高度差不超过1或者-1。

平衡树需要引入一个平衡因子的概念，每个结点都有一个平衡因子，任何结点的平衡因子=右子树的高度-左子树的高度（右 - 左），即任何结点的平衡因子等于 0 / -1 / 1 （AVL树并不是必须要有平衡因子，而是有了平衡因子的话就可以更方便我们去观察和控制树是否平衡，就像一个风向标一样）

  1. AVL树就接近完全二叉树了，高度为logN，增删查改的效率就为logN

二、AVL树的实现

1. 基本框架

#pragma once
template<class K, class V>
//平衡树结点的结构体
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;  //balance factor
	//构造函数
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		, _parent(nullptr)  //AVL树中还需要有一个_parent指针，指向当前节点的父节点，后续进行更新平衡因子这一操作时我们就会用到
		,_bf(0)
	{}
};

//平衡树的结构体
template<class K,class V>
struct AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
private:
	Node* _root = nullptr;
};

2. AVL树的插入

回顾一下搜索树的插入：从根结点开始比较，x比这个值大，往右走；小则往左走，直至没有值再可以比较。

插入

  1. 先进行插入操作：插入一个值按二叉搜索树的规则去进行插入操作。
#pragma once
#include<utility>
#include<stdio.h>
template<class K, class V>
//平衡树结点的结构体
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;  //balance factor
	//构造函数
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		, _parent(nullptr)  //AVL树中还需要有一个_parent指针，指向当前节点的父节点，后续进行更新平衡因子这一操作时我们就会用到
		,_bf(0)
	{}
};

//平衡树的结构体
template<class K,class V>
struct AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		//到这里说明根结点不为空
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		//循环已经结束，此时parent是最后一个合适的结点，cur为空
		cur = new Node(kv);
		if (cur->_kv.first > parent->_kv.first)
			parent->_right = cur;
		else {
			parent->_left = cur;
		}
		cur->_parent = parent;
		//在插入之后，开始更新平衡因子
	}
private:
	Node* _root = nullptr;
};

更新

  1. 更新平衡因子：插入结点以后，可能会影响部分祖先结点的平衡因子，所以需要更新的平衡因子是从当前这个（新增结点到根结点）路径上的平衡因子，实际中最坏的情况下是必须要更新到根，有些情况就只需要更新到中间就可以停止了。

1.> 平衡因子=右子树的高度-左子树的高度。
2.> 只有子树高度变化才会影响当前节点的平衡因子。(二叉树的高度是指从根结点到最远叶子结点的最长路径上的节点数量,换言之，二叉树的高度就是二叉树的层数。)

3.>插入一个节点，若新增结点在A的右子树上时，A的平衡因子++，新增结点在A的左子树上时，A的平衡因子--。

4.> A所在子树的高度,是否变化决定了是否会继续往上更新。

  • 如何判断高度是否变化呢？

首先要知晓：在插入之前，平衡因子是符合要求的：0，1，-1.更新之后，可能会不符合要求。

（1）更新后结点A的平衡因子是1或-1，说明更新前结点A的平衡因子为0，在A的右子树插入结点那A的_bf会变为1，在左子树插入结点_bf变为-1。【 _bf为0，说明这个结点的左右子树的高度一样，此时插入一个结点，无论插入在左还是右，势必会造成高度一边高，一边低，高度也一定会改变】A这棵二叉树的高度变了，那(以A为根结点)的树的高度也会变，所以需要继续向上更新_bf。

（2）更新后如果A的平衡因子等于0，说明更新前A的平衡因子为1或-1，就可以知道更新前A的子树是一边高一边低，新增的结点被插入在低的那边，插入后A所在的子树的高度不会变，不会影响A的父结点的左/右子树的高度，所以不会影响A的父结点的平衡因子，因此，更新结束。

（3）更新后A的平衡因子是2或-2，更新前平衡因子为1或-1，说明更新前以A为根结点的树的子树一边高一边低，新插入的那个节点被插在高的那边，这样就会使A所在的子树高的那边会变得更高，进而破坏了平衡，因而A所在的子树就会不符合平衡的要求，需要进行旋转处理，旋转的目标有2个：1.把parent子树旋转平衡。2.降低parent子树的高度。所以旋转后也不需要进行往上更新，插入结束。

先跟着思路写代码（新插入的结点叫cur，cur的父结点叫parent）

  • 若cur是parent的右孩子，parent的_bf加加；若cur是parent的左孩子，parent的_bf减减
  • 若加加减减之后，parent的_bf是0，则不继续向上更新_bf；parent的_bf是1或-1，则继续向上更新_bf；parent的_bf是2或-2，则进行旋转即可

需要思考一下，如果一直更新_bf，肯定是到根结点就停了，怎么判断到根了呢？此时的cur是根结点，那parent就为空了（根结点没有父亲结点），所以while(parnet)

//在插入之后，开始更新平衡因子
while (parent)
{
	if (parent->_left == cur)
		parent->_bf--;
	else if (parent->_right == cur)
		parent->_bf++;
	if (parent->_bf == 0)
		break;
	else if (parent->_bf == 1 || parent->_bf == -1)
	{
		cur = parent;
		parent = parent->_parent;
	}
	else if (parent->_bf == 2 || parent->_bf == -2)
	{
		//旋转
	}
	else  //防止真的不正常，大于2或小于-2
	{
		assert(false);
	}
}

判断

  1. 判断平衡因子是否符合要求：更新平衡因子后，平衡因子符合0/-1/1，就说明插入结束。

旋转

  1. 平衡因子不符合要求则进行旋转：更新平衡因子过程中出现不平衡，对不平衡子树进行旋转操作，旋转这一步操作本质上是降低了子树的高度，不会再影响上一层，所以插入结束。

旋转的原则：

  1. 旋转结束之后，这棵树仍然是搜索树，可以按序搜索
  2. 不平衡变为平衡树，同时降低高度

左边高：右旋
右边高：左旋

提前总结：

在接下来的例子中，会发现分别在a，b，c三个部分进行新增结点。

  • 在a的左子树新增结点，构成的是一条直线（蓝色，黄色，以及a的左，构成了直线），直线的话使用单旋即可。在c的右子树上新增结点，同样是直线

如果是直线的话，那就说明长的部分不仅是当前parent的左，还是根结点的左(不仅是当前parent的右，还是根结点的右)。如果是折线，那就是parent的左，根的右（或者parent的右，根的左）

在写代码的时候，如何判断它们是直线还是折线呢？（这将决定使用单旋还是双旋）。直线，parent的左高，根的左高，那右-左肯定是负数（两个平衡因子都是负数后者右高两个都是整数），所以直线(parent和根的_bf)是同号，折线是异号

  • 在a的右子树新增结点，会发现构成的是折线（蓝，黄，a的右），不能使用单旋就完成旋转。
右单旋

右单旋是对根结点进行旋转。（没到根就旋转了，不算）

第一个图是最初始的状态，且a,b,c,三棵子树的高度不定，有可能是0，1，2，3，4…等等
在这里插入图片描述
在这里插入图片描述
（有一种左边太高了，将根结点往右下方压的感觉）
旋转时左边高：平衡因子为-2
写代码时，只需要注意旋转的时候谁的孩子结点/父结点变了，注意指向。以及注意各个指标：_parent,_left,_right;

void RotateR(Node* root)  //右旋
{
	//先将需要修改的结点找出来
	Node* rootl = root->_left;
	Node* rootlr = rootl->_right;  //有为空的风险
	//有可能root并不是真正的根结点，而是某个子树的根结点，所以有可能存在root->_parent,也将这个结点存储下来
	Node* proot = root->_parent;

	//修改
	root->_left = rootlr;
	root->_parent = rootl;
	rootl->_right = root;

	//不可以直接写rootlr->_parent = root;有可能rootlr为空
	if (rootlr != nullptr)
		rootlr->_parent = root;

	//那修改之后，根节点是谁呢？分为两种情况，一种root为根，一种不为根
	if (proot == nullptr)
	{   //代表root为根
		_root = rootl;
		rootl->_parent = nullptr;
	}
	else  //真正的根不是root
	{
		rootl->_parent = proot;
		if (proot->_left == root)
			proot->_left = rootl;
		if (proot->_right == root)
			proot->_right = rootl;
	}
	root->_bf = 0;
	rootl->_bf = 0;
}
左单旋

结合以上理解：左单旋就是将这棵子树往左下方压。（右边太高，需要向左边压）

左单旋：用于右边纯粹的高【即：当前parent和根的右/左，而不是一个右，一个左】（在下图中，新增结点的那棵树是15的右，也是10的右）
在这里插入图片描述
把10往左下压，15成为新的根结点。那10的右是谁呢？需要找一个比10大的。
15成为根之后，有10，b，a这三棵树(二叉树只有左右孩子)，将b舍弃，同时b这棵树干好大于10小于15，刚好可以作为10的右子树。

15的左子树需要满足：比15小（10以及它的左子树满足，所以可以成为15的左子树。）

b这棵子树已经满足，每一个值都比15小，但它们是10的右子树，所以肯定大于10.（10<15的左子树<15），b可以成为10的右子树。

void RotateL(Node* root)
{
	Node* rootr = root->_right;
	Node* rootrl = rootr->_left;
	Node* proot = root->_parent;

	root->_parent = rootr;
	root->_right = rootrl;
	rootr->_left = root;
	if (proot == nullptr)
	{
		_root = rootr;
		rootr->_parent = nullptr;
	}
	else
	{
		rootr->_parent = proot;
		if (proot->_left == root)
			proot->_left = rootr;
		if (proot->_right == root)
			proot->_right = rootr;
	}

	if (rootrl != = nullptr)
		rootrl->_parent = root;
	root->_bf = 0;
	rootr->_bf = 0;
}
左右双旋

在这里插入图片描述
在b新增结点，(蓝色，黄色，和b子树，构成了折线)，需要使用双旋。

可以将b分开，
在这里插入图片描述

共有三种插入情况：（我们需要记录rootlr插入后(旋转前)的平衡因子，判断插入的位置）若插入之后_bf是1，说明在右边插入的，即f；插入之后_bf是-1，说明在e插入的

（1）在b的子树插入之后，rootlr的平衡因子是0
在这里插入图片描述

（2）在b新增结点：在它的左子树e插入（先对小的左，再对大的右）,subLR的平衡因子为-1
在这里插入图片描述
（3）在b新增结点：在它的右子树f插入（先对小的左，再对大的右）,subLR的平衡因子为1
在这里插入图片描述
由图我们可以看到，其实对于左右双旋来说，插在e还是f点对结果的影响就是subL与parent的平衡因子不同，旋转的步骤是一模一样的。

所以我们不管是插入在e还是f，对于左边双旋的步骤都为：1.左旋subL 2.右旋parent 3.记录subLR旋转前的平衡因子，判断插入的位置，根据插入的位置来更新平衡因子

代码：需要哪几个变量呢？左右双旋就是先左单旋，再右单旋，直接调用之前的函数即可，只需要传参即可，参数是当前旋转的子树的根，这便是双旋需要的变量。（parent和subL），但是我们还需要利用subLR的平衡因子判断插入位置，所以它也是变量

void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf;
	//先左再右
	RotateL(subL);
	RotateR(subL);
	//两个单旋之后开始修改平衡因子
	if (bf == 0)  //例图一
	{
		parent->_bf = 0;
		subL->_bf = 0;
		subLR->_bf = 0;
	}
	else 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
	{
		assert(false);
	}
}
右左双旋

在这里插入图片描述

void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	//仍然是保存一个根结点
	Node* proot = parent->_parent;
	int bf = subRL->_bf;

	//右左双旋
	RotateR(subR);
	RotateL(parent);

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

查找

AVL树的查找与搜索二叉树的搜索无异。（AVL树是以搜索二叉树为底，然后加入了平衡因子而已）

查找的话是给k来查找，所以函数的参数是const K& key

Node* AVLFind(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (key > cur->_kv.first)
			cur = cur->_right;
		else if (key < cur->_kv.first)
			cur = cur->_left;
		else
			return cur;
	}
	return nullptr;
}

高度&&个数&&中序遍历

void _InOrder(Node* root)   //中序遍历：左根右
{
	//先写递归的结束条件
	if (root == nullptr)
		return;
	else
	{
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}
}
int _Height(Node* root)
{
	if (root == nullptr)
		return 0;
	int leftcount = _Height(root->_left);
	int rightcount = _Height(root->_right);
	return leftcount > rightcount ? leftcount + 1 : rightcount + 1;
}
int _Size(Node* root)
{
	if (root == nullptr)
		return 0;
	return _Size(root->_left) + _Size(root->_right) + 1;
}

全部代码

#pragma once
#include<iostream>
#include<utility>
#include<stdio.h>
#include<assert.h>
#include <utility>   

using namespace std;

template<class K, class V>
//平衡树结点的结构体
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;  //balance factor
	//构造函数
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		, _parent(nullptr)  //AVL树中还需要有一个_parent指针，指向当前节点的父节点，后续进行更新平衡因子这一操作时我们就会用到
		,_bf(0)
	{}
};

//平衡树的结构体
template<class K,class V>
struct AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		//到这里说明根结点不为空
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		//循环已经结束，此时parent是最后一个合适的结点，cur为空
		cur = new Node(kv);
		if (cur->_kv.first > parent->_kv.first)
			parent->_right = cur;
		else {
			parent->_left = cur;
		}
		cur->_parent = parent;
		//在插入之后，开始更新平衡因子
		while (parent)
		{
			if (parent->_left == cur)
				parent->_bf--;
			else if (parent->_right == cur)
				parent->_bf++;
			if (parent->_bf == 0)
				break;
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			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);
			}
			else  //防止真的不正常，大于2或小于-2
			{
				assert(false);
			}
		}
		return true;
	}
	int Size()
	{
		return _size(_root);
	}
	int Height()
	{
		return _Height(_root);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
	void RotateR(Node* root)  //右旋
	{
		//先将需要修改的结点找出来
		Node* rootl = root->_left;
		Node* rootlr = rootl->_right;  //有为空的风险
		//有可能root并不是真正的根结点，而是某个子树的根结点，所以有可能存在root->_parent,也将这个结点存储下来
		Node* proot = root->_parent;

		//修改
		root->_left = rootlr;
		root->_parent = rootl;
		rootl->_right = root;

		//不可以直接写rootlr->_parent = root;
		//因为a,b,c的h可能为0，所以rootlr有可能为空
		if (rootlr != nullptr)
			rootlr->_parent = root;

		//那修改之后，根节点是谁呢？分为两种情况，一种root为根，一种不为根
		if (proot == nullptr)
		{   //代表root为根
			_root = rootl;
			rootl->_parent = nullptr;
		}
		else  //真正的根不是root
		{
			rootl->_parent = proot;
			if (proot->_left == root)
				proot->_left = rootl;
			if (proot->_right == root)
				proot->_right = rootl;
		}
		root->_bf = 0;
		rootl->_bf = 0;
	}
	void RotateL(Node* root)
	{
		Node* rootr = root->_right;
		Node* rootrl = rootr->_left;
		Node* proot = root->_parent;

		root->_parent = rootr;
		root->_right = rootrl;
		rootr->_left = root;
		if (proot == nullptr)
		{
			_root = rootr;
			rootr->_parent = nullptr;
		}
		else
		{
			rootr->_parent = proot;
			if (proot->_left == root)
				proot->_left = rootr;
			if (proot->_right == root)
				proot->_right = rootr;
		}

		if (rootrl != nullptr)
			rootrl->_parent = root;
		root->_bf = 0;
		rootr->_bf = 0;
	}
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;
		//先左再右
		RotateL(subL);
		RotateR(parent);
		//两个单旋之后开始修改平衡因子
		if (bf == 0)  //例图一
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else 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
		{
			assert(false);
		}
	}
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		//仍然是保存一个根结点
		Node* proot = parent->_parent;
		int bf = subRL->_bf;

		//右左双旋
		RotateR(subR);
		RotateL(parent);

		if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else
			assert(false);
	}
	Node* AVLFind(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_kv.first)
				cur = cur->_right;
			else if (key < cur->_kv.first)
				cur = cur->_left;
			else
				return cur;
		}
		return nullptr;
	}
	void _InOrder(Node* root)   //中序遍历：左根右
	{
		//先写递归的结束条件
		if (root == nullptr)
			return;
		else
		{
			_InOrder(root->_left);
			cout << root->_kv.first << ":" << root->_kv.second << endl;
			_InOrder(root->_right);
		}
	}
	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftcount = _Height(root->_left);
		int rightcount = _Height(root->_right);
		return leftcount > rightcount ? leftcount + 1 : rightcount + 1;
	}
	int _Size(Node* root)
	{
		if (root == nullptr)
			return 0;
		return _Size(root->_left) + _Size(root->_right) + 1;
	}
	
};

测试用例：
在这里插入图片描述

【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2961
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
平衡二叉树平衡因子_数据结构：平衡二叉树
weixin_39530557的博客
01-28 1万+
1.基本概念　 平衡二叉树(AVL树)，或为空树,或为如下性质的二叉排序树:左右子树深度之差的绝对值不超过1;左右子树仍然为平衡二叉树.　　平衡因子BF=左子树深度-右子树深度.　　平衡二叉树每个结点的平衡因子只能是1，0，-1。若其绝对值超过1，则该二叉排序树就是不平衡的。　　如图所示为平衡树和非平衡树示意图：2.平衡二叉树的算法思想若向平衡二叉树中插入一个新结点后破坏了平衡二叉树...
数据结构 —— 图解AVL树(平衡二叉树)
热门推荐
猎人在吃肉
07-28 5万+
文章目录1、AVL树(平衡二叉树)的定义1.1、平衡因子2、AVL树的作用：3、AVL树的基本操作3.1、插入—— 左左型的右旋：3.1.1、右旋的具体步骤：3.1.2、右旋的动画演示：3.1.3、右旋示例：3.2、插入——右右型的左旋：3.2.1、左旋的具体步骤：3.2.2、动画演示：3.2.3、左旋举例：3.3、插入——左右型的左右旋 ( 即先左后右)：3.3.1、左右旋的两次旋转步骤：3.3...
详解AVL树（平衡二叉树）
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
【C++进阶】：AVL树(平衡因子)
m0_73790767的博客
09-09 888
主要关于平衡树的旋转
平衡二叉树——AVl树
qq_34434522的博客
10-05 920
从插入节点的父节点开始，逐级向上检查每个祖先节点的平衡因子（Balance Factor, BF），即左子树高度减去右子树高度（BF = height(left) - height(right)），或者相反。AVL树是一种二叉搜索树，意味着每个节点都有一个键值，左子树的所有节点值小于该节点的值，右子树的所有节点值大于该节点的值。AVL树在插入或删除节点时，通过旋转操作来保持树的平衡，以确保所有基本操作的时间复杂度为 O(log n)。节点的高度是其左子树和右子树高度的最大值加一。
数据结构:AVL树详解(平衡二叉树)
机会是给有准备的人
11-11 6120
假如以 parent 为根的子树不平衡，即 parent 的平衡因子为2或者-2，分以下情况考虑parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL当subL的平衡因子为-1是，执行右单旋当subL的平衡因子为1时，执行左右双旋。
c代码-平衡二叉查找树 --AVL树
07-16
其中，AVL树是最早被提出的自平衡二叉查找树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。AVL树的关键特性是任何节点的两个子树的高度差不超过1，这保证了树的平衡性，从而提高了查询效率。...
二分搜索树-二叉查找树 .docx
03-13
二分搜索树，又称二叉查找树或有序二叉树，是一种特殊类型的二叉树，其每个节点都遵循以下规则： 1. 节点的左子树仅包含键值小于该节点的节点。 2. 节点的右子树仅包含键值大于该节点的节点。 3. 左右子树同样也是...
2023-03-25 AVL平衡树
lsgwr的博客
03-24 263
对任意一个节点，其左子树和右子树的高度差不能超过1平衡二叉树的高度和节点数量之间的关系也是O(logn)的平衡二叉树某个节点的高度值=max(左子树高度值，右子树高度值)+ 1。+1时因为父亲节点比子节点高一层。叶子节点的高度值认为是1，左右子树为空高度认为是0。在下图中用黑色表示平衡二叉树某个节点的平衡因子=左子树高度-右子树高度值，子树为空平衡因子认为是0在下图中用蓝色表示加入新节点后，沿着新节点的插入的置向上维护平衡性进行旋转的时机是在add中当更新节点高度和平衡因子后。
AVL树平衡因子详解
Travelerwz的博客
08-11 2万+
AVL树就是平衡二叉树，左子树和右子树的高度之差绝对值不超过1。 而且规定，平衡二叉树的每个节点的平衡因子只能是-1 ，1 ，0； 按照公式   平衡因子 = 右子树的高度 - 左子树的高度 -1 ： 表示左子树比右子树高 1  : 表示右子树比左子树高 0 ： 表示左子树和右子树等高 但是很多人都知道公式，但却有时候不知道怎么去看一个平衡二叉树。 接下来我为大家详
AVL树（平衡二叉搜索树）
2301_81265915的博客
08-16 3281
int _bf;, _bf(0), _kv(kv){}某节点的左子树与右子树的高度(深度)差即为该节点的平衡因子（BF,Balance Factor），平衡二叉树中不存在平衡因子大于 1或小于-1的节点。在一棵平衡二叉树中，节点的平衡因子只能取 0 、1 或者 -1 ，分别对应着左右子树等高，左子树比较高，右子树比较高。
数据结构（五)——AVL树（平衡二叉搜索树)
最新发布
f040731_007的博客
04-10 1113
前面我们在数据结构中介绍了二叉搜索树，其中提到了二叉搜索树的缺陷：极端情况下时间复杂度会坍缩成O(N)，如何解决它不够稳定这个问题呢？我们发现，只要让二叉树成为一个满二叉树，就可以很好的控制它在查找的过程中的时间复杂度为O(logN)，接下来就让我们一起来学习平衡二叉树当中的AVL树吧。据结构（四）——二叉搜索树的实现（C++版）int _bf;
avl树 c语言 平衡因子,数据结构之AVL树详解
weixin_32734545的博客
05-24 589
1. 概述AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下都是O(log n)，增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。本文介绍了AVL树的设计思想和基本操作。2. 基本术语有四种种情况可能...
平衡二叉树（AVL）详解
H_Q_Li的博客
04-04 4349
平衡二叉树（AVL） 1、为什么会出现平衡二叉树 平衡二叉树（Balanced Binary Tree），又称AVL树，指的是左子树上的所有节点的值都比根节点的值小，而右子树上的所有节点的值都比根节点的值大，且左子树与右子树的高度差最大为1。 平衡二叉树性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 知道了平衡二叉树的概念之后，我们来聊聊为什么会...
平衡二叉搜索树--AVL详解剖析
qzt__l0ve的博客
07-16 980
平衡二叉搜索树--AVL树关于概念、作用、源码实现等操作。以及对左旋、右旋、左右旋、右左旋的代码讲解和图画讲解
平衡二叉树（AVL树）
Xpccccc的博客
03-27 2960
平衡二叉树（AVL树）
高阶数据结构 —— AVL树(平衡搜索树)
lyzzs222的博客
10-14 1251
AVL树的实现，画图+代码，逻辑明明白白的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值