数据结构篇九：AVL树

最新推荐文章于 2024-05-20 12:46:49 发布
最新推荐文章于 2024-05-20 12:46:49 发布
阅读量973 收藏 24
点赞数 33
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62321047/article/details/136093489
版权

文章目录

前言

  在二叉搜索树中我们发现这种情况下查询效率依旧很低下：
在这里插入图片描述
  如果插入的顺序有序，那么就会变成成单支树，二叉搜索树的性能就失去了，而AVL树和红黑树就是为了解决这个问题而发明的。本章主要讲解的是AVL树，下一篇文章将会讲解红黑树。

1. AVL树的概念

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

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1）（平衡因子：某一结点的右子树的高度减左子树的高度）
    在这里插入图片描述
      如果一棵二叉搜索树是高度平衡的，它就是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树的解决方法其实是将树平衡因子超过1的树进行旋转，我们来看个例子：
    在这里插入图片描述
      这样就将一个平衡因子为了2的树变成了平衡因子为0的树，如此就完美的解决了单支树的问题。

2. AVL树节点的定义

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	int _bf;

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

  AVL树我们采用的是三叉链，相比较二叉链多存储了父亲节点，它会更好的帮助我们进行调整节点的操作。

3. AVL树的插入

  AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

  1. 按照二叉搜索树的方式插入新节点
  2. 调整节点的平衡因子
  1. 先按照二叉搜索树的规则将节点插入到AVL树中
  2. 新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否破坏了AVL树的平衡性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，此时以parent为根的树的高度增加，需要继续向上更新
  3. 如果parent的平衡因子为正负2，则parent的平衡因子违反平衡树的性质，需要对其进行旋转处理
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->_right;
			}
			else if(kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (cur->_kv.first < parent->_kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
			
			// 更新后检测双亲的平衡因子
			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				// 插入前双亲的平衡因子是0，插入后双亲的平衡因为为1 或者 -1 ，说明以双亲为根的二叉树的高度增加了一层，因此需要继续向上调整
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 双亲的平衡因子为正负2，违反了AVL树的平衡性，需要对以pParent为根的树进行旋转处理
				//…………
			}
			
		}

		return true;
	}

  调整一共分为四种情况，分别为右单旋、左单旋、右左单旋，左右单旋，我们分别来看。

3.1 新节点插入较高左子树的左侧—左左：右单旋

在这里插入图片描述

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

  1. 10节点的右孩子可能存在，也可能不存在
  2. 20可能是根节点，也可能是子树
    如果是根节点，旋转完成后，要更新根节点
    如果是子树，可能是某个节点的左子树，也可能是右子树

  a、b、c分别代表着各种情况，高度为0（也就是为空），高度为1，（为一个节点），高度为2（见图，可以为图中的任意一种），高度为3……等等。
在这里插入图片描述
  此处是画出了一个抽象图来讲解，可以映射为各种各样的情况。注意：我们是每插入一个节点就会进行平衡，因此a、b、c一定也为AVL树。
  旋转方式：我们将平衡因子为正负2的节点命名为parent，它的左子树命名为subL，subL的右子树命名为subLR，旋转时只需要调整这个几个节点就可以了。
在这里插入图片描述

  旋转就是以平衡因子为正负2的节点为基础进行的。将subLR链接到parent的左，再将parent链接到subL的右。

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

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

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

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

  但是subLR有可能为空，也就是当a、b、c高度为0时，subLR就会出现为空的情况，因此在使用时需要判断一下。
在这里插入图片描述
  但是要注意：我们使用的是三叉链，在进行链接时是需要进行相互链接的，尤其是需要注意parent，如果它不是根节点的话，说明parent的上面还有节点，因此在链接时不能把此处的链接给忘记了。总结一共存在三处链接：第一处是subLR链接到parent的左，第二处链接是将parent链接到subL的右，第三处链接是将subL链接到parent的父亲节点。
  旋转完成后还需要调整平衡因子，根据我们画出的图可以看出，在这种调整情况下，最后的平衡因子都变成了0。
在这里插入图片描述

3.2 新节点插入较高右子树的右侧—右右：左单旋

  左单旋与右单旋相差无几，仅仅只是调换了一下方向：
在这里插入图片描述
  具体情况与右单旋一模一样，在此处我就不进行详细讲解了。

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

		Node* ppNode = parent->_parent;

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

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

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

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

在这里插入图片描述

  在这种情况下，我们发现对节点20无论是左单旋还是右单旋都无法减少平衡因子，因此就出现了双旋的情况，我们先对节点10进行左单旋。
在这里插入图片描述

  将其变成了只有左边高，这样就转化成了右单旋的问题。
在这里插入图片描述

  再对节点20进行右单旋，如此下来我们就发现它们的平衡因子减小了。
在这里插入图片描述

  左右双旋我们可以直接复用前面的代码就可以了，但是需要注意平衡因子的调节，新插入节点的位置可能是subLR，也可能是subLR的左，也可能是subLR的右，插入位置不同，平衡因子的调节就不同，大家可以自行画图来观察。

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 = subL->_bf = subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = subLR->_bf = 0;
		}
		else if(bf = -1)
		{
			parent->_bf = 1;
			subLR->_bf = subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

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

  具体的过程与左右双旋情况一致，我这里找了一份图，大家对左右双旋理解透彻了相信对于右左双旋也不在话下，我就偷个懒不做详细解释了。
在这里插入图片描述
  这里的平衡因子的调节同样与插入位置有关，可以多画几种情况来观察。

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

		int bf = subRL->_bf;

		RotateR(subR);
		RotateL(parent);

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

总结：
假如以parent为根的子树不平衡，即parent的平衡因子为2或者-2，分以下情况考虑

  1. parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR

当subR的平衡因子为1时，执行左单旋
当subR的平衡因子为-1时，执行右左双旋

  1. parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL

当subL的平衡因子为-1是，执行右单旋
当subL的平衡因子为1时，执行左右双旋

  旋转完成后，原parent为根的子树个高度降低，已经平衡，不需要再向上更新。

4. AVL树的验证

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

  1. 验证其为二叉搜索树

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

  1. 验证其为平衡树

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

4.1 验证其为二叉搜索树

  使用中序进行遍历即可。

void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
void _InOrder(Node* root)
{
	if (root == nullptr)
		return;

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

4.2 验证其为平衡树

  因此还需要写一个计算高度的函数来辅助检查，相信有了前面二叉树的学习，这部分对大家构不成威胁。

int _Hight(Node* _root)
{
	if (_root == nullptr)
		return 0;

	int LeftHight = _Hight(_root->_left);
	int RightHight = _Hight(_root->_right);

	return LeftHight > RightHight ? LeftHight + 1 : RightHight + 1;
}
bool _IsBalance(Node* _root)
{
	if (_root == nullptr)
		return true;

	int LeftHight = _Hight(_root->_left);
	int RightHight = _Hight(_root->_right);
	if (RightHight - LeftHight != _root->_bf)
	{
		cout << _root->_kv.first << "平衡因子异常:" << _root->_bf<< endl;
		return false;
	}

	return abs(LeftHight - RightHight) < 2
		&& _IsBalance(_root->_left)
		&& _IsBalance(_root->_right);
}

bool IsBalance()
{
	return _IsBalance(_root);
}

5. AVL树的删除

  因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。
  删除的情况更多也更为复杂，具体实现大家们可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

6. AVL树的性能

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

7. 代码实现

7.1 AVL.h

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

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	int _bf;

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

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 true;
		}

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

		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (cur->_kv.first < parent->_kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		//平衡因子
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				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);
				}
				// 1、旋转让这颗子树平衡了
				// 2、旋转降低了这颗子树的高度，恢复到跟插入前一样的高度，所以对上一层没有影响，不用继续更新
				break;
			}
			else
			{
				assert(false);
			}
		}

		return true;
	}

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

		Node* ppNode = parent->_parent;

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

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

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

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

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

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

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

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

		int bf = subRL->_bf;

		RotateR(subR);
		RotateL(parent);

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

	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 = subL->_bf = subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = subLR->_bf = 0;
		}
		else if(bf = -1)
		{
			parent->_bf = 1;
			subLR->_bf = subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	int _Hight(Node* _root)
	{
		if (_root == nullptr)
			return 0;

		int LeftHight = _Hight(_root->_left);
		int RightHight = _Hight(_root->_right);

		return LeftHight > RightHight ? LeftHight + 1 : RightHight + 1;
	}
	bool _IsBalance(Node* _root)
	{
		if (_root == nullptr)
			return true;

		int LeftHight = _Hight(_root->_left);
		int RightHight = _Hight(_root->_right);
		if (RightHight - LeftHight != _root->_bf)
		{
			cout << _root->_kv.first << "平衡因子异常:" << _root->_bf<< endl;
			return false;
		}

		return abs(LeftHight - RightHight) < 2
			&& _IsBalance(_root->_left)
			&& _IsBalance(_root->_right);
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

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

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

	Node* _root = nullptr;
};

7.2 Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"AVL.h"

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

	t.InOrder();
	cout << t.IsBalance() << endl;
}


void Test2()
{
	const int N = 100;
	vector<int> v;
	v.reserve(N);
	srand(time(0));

	for (int i = 0; i < N; i++)
	{
		v.push_back(rand());
	}

	AVLTree<int, int> t;
	for (auto e : v)
	{
		t.insert(make_pair(e, e));
		cout << "insert:" << e << "->" << t.IsBalance() << endl;
	}

	cout << t.IsBalance() << endl;
}

int main()
{
	//Test1();
	Test2();
	return 0;
}

8. 总结

  AVL树最主要的是如何进行旋转，此部分比较难以理解，大家可以通过多画图来反复进行学习。希望大家都能有所收获。
  如果大家发现有什么错误的地方，可以私信或者评论区指出喔。我会继续深入学习C++，希望能与大家共同进步，那么本期就到此结束，让我们下期再见！！觉得不错可以点个赞以示鼓励！！

不如小布.
关注
  • 33
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
avlTree:通用AVL树数据结构
06-18
这是第一个被发明的数据结构。 在AVL树中，任何节点的两个子子树的高度最多相差1； 如果在任何时候它们相差超过 1，则进行重新平衡以恢复此属性。 查找、插入和删除在平均和最坏情况下都需要 O(log n) 时间，其中 n...
数据结构(C++) : AVL树 实现篇
weixin_57761086的博客
10-08 2861
在二叉搜索树的基础上学习AVL树，通过大量图片学习AVL树的重点：左单旋，右单旋，左右双旋，右左双旋。同时写出验证函数，验证是否是AVL树
数据结构与算法：AVL树 旋转图解及Java实现
u014165620的博客
09-08 3762
版权声明：本文为博主原创文章，转载请注明出处，https://blog.csdn.net/u014165620/article/details/82492099 一、简介 AVL树是带有平衡条件的二叉查找树(Binary Search Tree)，在理解AVL树之前，需要对二叉查找树有所了解。 名词解释 树高度(height)：根节点为root的树的高度(height)是从root到其...
数据结构：树(Tree)【详解】
热门推荐
UniqueUnit的博客
02-26 14万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
数据结构：AVL树的实现和全部图解
海绵宝宝de派小星的博客
11-06 2538
AVL树的模拟实现
【数据结构与算法】第四篇：AVL树
qq_61571098的博客
08-25 488
这个概念很简单，就是节点左子树高度减去节点右子树的高度，如果差值的绝对值小于等于1,就是平衡的，反之就是失衡的。),能够很好的解决链表O(n)的复杂度，但是二叉搜索树仍然有很大的提升空间，比如说如果我们为二叉搜索树添加元素，但是我们添加的元素都是有规律的从小到大或者从大到小就会使其退化为链表。AvL树就是一种二叉搜索树的改良的树，它继承与二叉搜索树，而且节点类型新增了高度属性，最重要的是能实现自平衡功能，保证了代码的运行效率。具体代码细节可以移步代码仓库----->◼ 让p成为这棵子树的根节点。
数据结构(python) —— 【28: AVL树】
土豆同学的博客
10-22 609
AVL树 上一篇博客说到二叉搜索树的效率在最坏的情况下可能十分偏斜: 数据结构(python) —— 【27: 二叉搜索树】 而AVL树是对二叉搜索树的优化，今天就来说说AVL树！ 1. 概念 AVL树: AVL树是一棵自平衡的二叉搜索树。 AVL树具有以下性质: 根的左右子树的高度之差的绝对值不能超过1 根的左右子树都是平衡二叉树 其中高度之差我们用**balance factor(平衡因子)**来进行解释。平衡因子的正负号表示左右子树哪边的深度大，可以自己定义。这里我定义了左子树深度>右子树
Java数据结构与算法：AVL树
weixin_44626980的博客
01-25 336
AVL树是一种自平衡的二叉搜索树，它的命名来自于它的发明者G.M. Adelson-Velsky和E.M. Landis。在AVL树中，任何节点的两个子树的高度最多相差1。当在AVL树中插入或删除节点时，系统会通过旋转操作来保持树的平衡性。
瑞_数据结构与算法_AVL树
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
01-29 1099
本文章为瑞_系列专栏之《数据结构与算法》的AVL树篇，AVL 树是一种自平衡二叉搜索树，AVL树是用于存储有序数据的一种重要数据结构，它是二叉搜索树的一种改进和扩展。它不仅能够提高搜索、插入和删除操作的效率，而且还能够确保树的深度始终保持在 O(log n) 的水平
数据结构与算法:树 AVL平衡二叉排序树 (九)
高级开发者进阶ing... QaQ
07-08 268
工具:IDEA本系列介绍的是数据结构: 树这是第九篇目前计划一共有12篇:敬请期待吧~~高光时刻:添加情况分析:删除情况分析:在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树AVL树特点:一张图搞懂: 这里隐藏了三个方法是因为上一篇:二叉排序树(BST)已经说过了,就不重复介绍了,代码很简单,有需要的话翻过去看看吧~ 添加结点和上一篇讲的也一模一样但是如果真这样写,那不就成了BST树了么,先来分析情况,然后再看代码假设当前树结构是这样的,在没添加12之前,这是一颗AVL树但是一旦添
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
数据结构课程设计（AVL树实现图书管理系统）
02-01
数据结构课程设计（AVL树实现图书管理系统）
数据结构中时间复杂度的介绍
gygkhd的博客
05-17 757
在计算机科学领域，特别是在数据结构和算法的研究中，时间复杂度是一个非常关键的概念。它表示一个算法执行完成所需要的计算工作量。了解时间复杂度有助于预测程序运行的速度和效率，这对于优化程序和解决大规模数据处理问题尤为重要。时间复杂度通常用大O符号（O-notation）来表示，它描述了算法性能与输入数据之间的关系。大O符号忽略了常数和低阶项，只关注程序执行时间随输入数据规模增长的变化趋势。例如，时间复杂度为O(n)的算法表示执行时间与输入数据的规模成线性关系。
java常见算法
qq_24099547的博客
05-17 183
要求待查询的序列是有序数列, 每个取中间位置的值与目标值进行比较。
数据结构总结与练习题
最新发布
关注收藏，可以私信解决问题！
05-20 232
数据结构：数组、链表、栈、队列、哈希表、树、图。算法：排序（冒泡排序、快速排序、归并排序）、搜索算法、动态规划、贪心算法、图算法。操作系统：进程管理、内存管理、文件系统、输入/输出管理。计算机网络：网络层协议（IP、ICMP）、传输层协议（TCP、UDP）、应用层协议（HTTP、FTP、DNS）。编程语言：基础语法、控制结构、数据类型、面向对象编程、函数式编程。知识点数组：固定大小的连续内存空间。链表：由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。
【数据结构】堆（Heep）
SWsunlight的博客
05-17 1077
堆、堆的实现
数据结构_栈在括号匹配中的应用_代码
Hooray11的博客
05-17 245
【代码】数据结构_栈在括号匹配中的应用_代码。
数据结构二叉搜索树avl树
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左...AVL树则是一种自平衡的二叉搜索树，它保证任何节点的左右子树高度差不超过1，因此能够保证树的查找、插入、删除等操作的时间复杂度为O(logN)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不如小布.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值