AVL树详解 原理+实现 C++

最新推荐文章于 2024-05-06 09:32:13 发布
最新推荐文章于 2024-05-06 09:32:13 发布
阅读量1.1k 收藏 6
点赞数 4
分类专栏： 数据结构 文章标签： C/C++ Java 数据结构 编程语言 Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/juggte/article/details/122119970
版权

AVL Tree

AVL树是由G. M. Adelson-Velsky和E. M. Landis 在1962年发明， 是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

目录

Tips

二叉搜索树(BST)

对于普通的二叉搜索树（BST)，增加或删除节点都可能使其退化成链表，时间复杂度就是O(N)，AVL在BST的基础上维护了树的平衡，通过树的旋转保持整棵树趋向于一颗满二叉树，使其高度保持在 O(logN)

在这里插入图片描述

BST改进

添加节点12，此时这颗树并不平衡。

在这里插入图片描述
中序遍历依旧是有序的，但保持了树的平衡，本质上其实是为了减少树的高度
在这里插入图片描述


添加导致的失衡

AVL添加节点前都是平衡的，添加节点最坏情况可能会导致其祖先节点都失衡（父节点不会失衡）。

在这里插入图片描述


右旋 LL

红色节点为新增节点，添加后此时子树是失衡的，通过以下步骤恢复平衡。

  1. g.left = p.right
  2. p.right = g
  3. 使p成为新的根

注意旋转后需要维护高度和parent的指向。
在这里插入图片描述
旋转后子树依旧是有序的
在这里插入图片描述

旋转后根节点往上的其他节点并不会失衡，因为添加新节点前AVL永远是平衡的，旋转后子树的高度并不会发生改变，所以添加节点只需要一次的旋转，而删除可能需要 logN 次旋转。


左旋 RR

和LL情况相反

  1. g.right = p.left
  2. p.left = g
  3. 使p成为新的根

注意旋转后需要维护高度和parent的指向。
在这里插入图片描述

也依旧有序。


左旋+右旋 LR


需要进行两次旋转，向对p进行右旋，将n旋转上来，再对g进行左旋，此时n成为新的根节点

注意维护高度和parent指向
在这里插入图片描述

子树恢复平衡，也依旧有序。


右旋+左旋 RL

和LR差不多，也是通过旋转想办法将n成为根节点。

注意维护高度和parent指向
在这里插入图片描述
子树恢复平衡，也依旧有序。


添加后的操作 C++

void afterAdd(Node* cur)
	{
		//从新增节点的父节点往上
		while ((cur = cur->_parent) != nullptr)
		{
			if (cur->isBalance())	//平衡情况下更新高度信息。
				cur->reHight();
			else {					//只需要一次旋转就可以恢复平衡。
				maintain(cur);		//调整子树恢复平衡
				break;
			}

		}
	}

添加代码 C++

bool put(const K& key, const V& value)
	{
		if (!_root) {
			_root = new Node(key, value);
			_size++;
			return true;
		}

		Node* cur = _root;
		while (cur)	
		{
			if (cur->_key < key)	//大往右
			{
				if (cur->_right)	//新节点都为叶子节点
					cur = cur->_right;
				else {
					Node* newNode = new Node(key, value);
					cur->_right = newNode;
					newNode->_parent = cur;

					afterAdd(newNode); //添加后一路往上更新高度和维持平衡
					_size++;
					return true;
				}
			}
			else if (cur->_key > key)	//小往右
			{
				if (cur->_left)
					cur = cur->_left;
				else {
					Node* newNode = new Node(key, value);
					cur->_left = newNode;
					newNode->_parent = cur;

					afterAdd(newNode); //添加后一路往上更新高度和维持平衡
					_size++;
					return true;
				}
			}
			else {		//存在直接更新value
				cur->_value = value;
				return true;
			}

		}//end of while

		return true;
	}

删除导致的失衡


删除节点可能导致其父节点，或往上的祖先节点失衡（只会存在一个失衡）。

我们通过旋转可以让失衡的子树恢复了平衡，但可能导致更高层次的节点发生失衡，最坏情况下，每次旋转可能导致所有祖先节点都失衡，最坏logN次的旋转调整。

在这里插入图片描述


删除代码 C++

	bool remove(const K& key)
	{
		if (empty())	return false;
		//只有根节点
		if (_root->_key == key && size() == 1) {
			_size = 0;
			delete _root, _root = nullptr;
			return true;
		}

		Node* cur = _root;
		bool find = false;
		while (cur)
		{
			if (cur->_key < key)
				cur = cur->_right;
			else if (cur->_key > key)
				cur = cur->_left;
			else {
				find = true;
				break;
			}

		}//end of while

		//没找到直接返回
		if (!find) {
			return false;
		}

		if (cur->_left && cur->_right)	//度为2
		{
			Node* prev = cur->_left;	//找到前驱节点
			while (prev && prev->_right)
				prev = prev->_right;

			cur->_key = prev->_key, cur->_value = prev->_value;
			cur = prev;
		}

		if (cur->_left || cur->_right)	//度为1情况
		{
			Node* parent = cur->_parent;
			Node* child = cur->_left ? cur->_left : cur->_right;

			parent->_left == cur ? parent->_left = child : parent->_right = child;
			child->_parent = parent;

			afterRemove(cur);
		}
		else {		//度为0的情况

			Node* parent = cur->_parent;
			parent->_left == cur ? parent->_left = nullptr : parent->_right = nullptr;

			afterRemove(cur);
		}

		_size--;
		delete cur;
		return true;
	}



完整代码 C++

#include <iostream>
#include <cmath>
#include <queue>
#include <cassert>
using namespace std;

template<class K, class V>
class AVL {

public:
	struct Node {
		Node(const K& key, const V& value) :
			_key(key), _value(value), _parent(nullptr), _left(nullptr), _right(nullptr) {}

		Node* tallerChild()
		{
			size_t left = this->_left->hight();
			size_t right = this->_right->hight();

			return left < right
				? this->_right
				: this->_left;
		}

		size_t hight()
		{
			return !this ? 0 : this->_hight;
		}

		bool isBalance()
		{
			int left = this->_left->hight();
			int right = this->_right->hight();

			return fabs(left - right) < 2 ? true : false;
		}

		void reHight()
		{
			int left = this->_left->hight();
			int right = this->_right->hight();
			this->_hight = left > right ? left + 1 : right + 1;
		}

		K _key;
		V _value;
		Node* _parent;
		Node* _left;
		Node* _right;
		size_t _hight = 1;
	};

public:

	bool put(const K& key, const V& value)
	{
		if (!_root) {
			_root = new Node(key, value);
			_size++;
			return true;
		}

		Node* cur = _root;
		while (cur)	
		{
			if (cur->_key < key)	//大往右
			{
				if (cur->_right)	//新节点都为叶子节点
					cur = cur->_right;
				else {
					Node* newNode = new Node(key, value);
					cur->_right = newNode;
					newNode->_parent = cur;

					afterAdd(newNode); //添加后一路往上更新高度和维持平衡
					_size++;
					return true;
				}
			}
			else if (cur->_key > key)	//小往右
			{
				if (cur->_left)
					cur = cur->_left;
				else {
					Node* newNode = new Node(key, value);
					cur->_left = newNode;
					newNode->_parent = cur;

					afterAdd(newNode); //添加后一路往上更新高度和维持平衡
					_size++;
					return true;
				}
			}
			else {		//存在直接更新value
				cur->_value = value;
				return true;
			}

		}//end of while

		return true;
	}


	bool remove(const K& key)
	{
		if (empty())	return false;
		//只有根节点
		if (_root->_key == key && size() == 1) {
			_size = 0;
			delete _root, _root = nullptr;
			return true;
		}

		Node* cur = _root;
		bool find = false;
		while (cur)
		{
			if (cur->_key < key)
				cur = cur->_right;
			else if (cur->_key > key)
				cur = cur->_left;
			else {
				find = true;
				break;
			}

		}//end of while

		//没找到直接返回
		if (!find) {
			return false;
		}

		if (cur->_left && cur->_right)	//度为2
		{
			Node* prev = cur->_left;	//找到前驱节点
			while (prev && prev->_right)
				prev = prev->_right;

			cur->_key = prev->_key, cur->_value = prev->_value;
			cur = prev;
		}

		if (cur->_left || cur->_right)	//度为1情况
		{
			Node* parent = cur->_parent;
			Node* child = cur->_left ? cur->_left : cur->_right;

			parent->_left == cur ? parent->_left = child : parent->_right = child;
			child->_parent = parent;

			afterRemove(cur);
		}
		else {		//度为0的情况

			Node* parent = cur->_parent;
			parent->_left == cur ? parent->_left = nullptr : parent->_right = nullptr;

			afterRemove(cur);
		}

		_size--;
		delete cur;
		return true;
	}

	void afterRemove(Node* cur) {

		while ((cur = cur->_parent) != nullptr)
		{
			if (cur->isBalance())
				cur->reHight();
			else {
				maintain(cur);
			}

		}
	}
	void afterAdd(Node* cur)
	{
		while ((cur = cur->_parent) != nullptr)
		{
			if (cur->isBalance())
				cur->reHight();
			else {
				maintain(cur);
				break;
			}

		}
	}
	bool contains(const K& key)
	{
		if (empty())	return false;

		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
				cur = cur->_left;
			else if (cur->_key < key)
				cur = cur->_right;
			else
				return true;
		}

		return false;
	}
	void maintain(Node* grand)
	{
		if (!grand)	return;

		Node* parent = grand->tallerChild();
		Node* node = parent ? parent->tallerChild() : nullptr;

		if (parent && node && parent == grand->_left)
		{
			if (node == parent->_left)	//LL
				right_rotate(grand);
			else {						//LR
				left_rotate(parent);
				right_rotate(grand);
			}
		}
		else if (parent && node && parent == grand->_right)
		{
			if (node == parent->_right)	//RR
				left_rotate(grand);
			else {						//RL
				right_rotate(parent);
				left_rotate(grand);
			}
		}

	}
	void left_rotate(Node* cur)
	{
		Node* parent = cur->_parent;
		bool isRoot = (cur == _root) ? true : false;

		Node* R = cur->_right;
		cur->_parent = R;
		cur->_right = R->_left;

		if (cur->_right)
			cur->_right->_parent = cur;

		R->_left = cur;
		cur->reHight();

		R->reHight();

		if (isRoot) {
			_root = R;
			_root->_parent = nullptr;
		}
		else {
			parent->_left == cur ? parent->_left = R : parent->_right = R;
			R->_parent = parent;
		}

	}
	void right_rotate(Node* cur)
	{
		Node* parent = cur->_parent;
		bool isRoot = (cur == _root) ? true : false;

		Node* L = cur->_left;
		cur->_parent = L;
		cur->_left = L->_right;

		if (cur->_left)
			cur->_left->_parent = cur;


		L->_right = cur;
		cur->reHight();

		L->reHight();

		if (isRoot) {
			_root = L;
			_root->_parent = nullptr;
		}
		else {
			parent->_left == cur ? parent->_left = L : parent->_right = L;
			L->_parent = parent;
		}
	}



	size_t size()
	{
		return _size;
	}

	bool empty()
	{
		return _root == nullptr;
	}

	//private:
	Node* _root = nullptr;
	size_t _size = 0;
};
necesse
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
AVL树（平衡二叉树）的底层原理以及实现
荣耀与梦想来日方长
03-11 1152
前言 Wiki:在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是{\displaystyle O(\log {n})} 。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL 树得名于它的发明者G. M. Adelson-Velsky和Evgenii Landis，他们在1962年的论文《An algorithm for the org...
[ 数据结构 - C++] AVL树原理及实现
CSDN博客
09-26 999
平衡二叉搜索树-- AVL树 C++实现
[数据结构]——浅谈AVL树原理与简易实现
lucky52529的博客
04-21 856
AVL树 相信学过数据结构的同学对于二叉搜索(排序)树一定不陌生，二叉搜索树是一颗左子节点比根节点小，右子节点比根大且他的子树也满足这种规则的一颗二叉树。二叉搜索树从名字上就知道他是用来进行数据的搜索的，理论上来讲他的搜索效率是log(n),但是事实上在某些极端情况下他好像显得并不那么有效。现在对空树插入一个有序的数列，你会发现他成为了一个单只树，最坏的搜索情况居然退化为o(n)。 其实会发生这...
数据结构&&AVL树原理、插入操作详解及实现
sp_programmer的专栏
12-08 5500
AVL树原理、插入数据原理、实现。
AVL树的原理及代码实现
qq_39747794的博客
11-02 1140
前言 如果你还没有学习过二叉查找树，那么请你先去看看二叉查找树，因为AVL树便是从二叉查找树进化而来的，不看的话你无法理解AVL树。 链接：二叉查找树的原理及实现 如果你已经学习了二叉查找树，你会觉得二叉查找树性能在各方面都很好，就只有一丢丢的小毛病，那就是当数据非常坑时，二叉查找树退化成了一条单链表，这样各种操作的时间复杂度都变为O(n)了，怎么办呢，今天所要学习的AVL树便以其惊艳四座的...
AVL树的c++实现
08-03
利用模板类以及智能指针shared_ptr写的关于AVL树的基本实现
AVL树 C++ 实现
03-05
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
avl树VisualC++6.0实现
05-07
数据结构中的avl树 c++的具体实现 实现思想是先对输入的数据进行排序，然后进行处理 主要是对北大上机的
AVLTree:AVL 树的 C++ 实现
07-01
AVL树AVL 树的 C++ 实现
AVL树原理与实现
Mute4ll 's Blog
07-08 139
数据结构 数据结构 = 结构定义 + 结构操作 树形结构： 节点：集合 边：关系 二叉排序树 性质 1、左子树 < 根结点 2、右子树 > 根结点 用途 解决与排名相关的检索需求 插入操作 从根结点出发，比较待插入节点与当前节点的大小，若待插入节点小于当前节点则当前节点转移到其左孩子，否则转移到右孩子。直到找到一个空闲的叶节点位置插入。 删除操作 删除出度为0的节点： 直接删除即可 删除出度为1的节点： 该结点的父节点直接连接到该结点的子节点，即前后节点连接 删除出度为
AVL树原理思想及其实现
sunjunior的专栏
07-05 727
AVL树，一种平衡搜索二叉树，是BST(Binary Search Tree)二叉查找树的一种，实际上是在BST搜索树上增加了平衡条件，所谓的平衡条件指的是树中的每个结点的左孩子与右孩子的高度之差不大于1。既然是一种BST树，那么它肯定满足BST的一般性质。在计算机科学领域，二叉搜索树(BST),有时也称作有序的或者排序好的二叉树，是一种特殊类型的容器。它允许快速的查找，增加，删除结点，可以被用作
AVL树的实现（图文详解）
AllenSquirrel
05-19 4132
AVL树的实现
AVL树原理详解与实现（附代码）
张凯
08-15 1万+
上一篇文章讲了二叉搜索树，但是它会在极端情况下退化为链表，造成查找时间复杂度退化为O(N)O(N)O(N)，那么怎样才能让它不退化为链表呢？这篇文章告诉你，快来看看把！ 文章目录1. 平衡二叉树的定义2. AVL树的调整3. AVL树的实现4. 完整代码，带测试程序 1. 平衡二叉树的定义 平衡说的是树的高度平衡，平衡二叉树可以这么定义： 一颗空树 如果不是空树，那么它的左子树和右子树都是平衡二叉树，且左右子树的高度差绝对值不超过1 树的高度怎么定义？ 如果是空树，高度为0 如果不是空树，那高度就.
高级数据结构与算法 | AVL树 （高度平衡树）
凌桓丶的博客
06-28 3459
文章目录AVL树实现思路数据结构查找平衡因子旋转右旋左旋右左双旋左右双旋插入删除AVL树的验证中序遍历平衡判断AVL树的性能完整代码实现 AVL树 AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis AVL树其实就是在二叉搜索树的基础上，引入了平衡因子的概念，通过旋转来调整平衡因子，使得二叉树始
AVL树 平衡二叉树 简介及实现原理
新手村
01-31 1031
平衡二叉树 平衡树是计算机科学中的一类数据结构。 平衡树是计算机科学中的一类改进的二叉查找树。在这里，平衡指所有叶子的深度趋于平衡，更广义的是指在树上所有可能查找的均摊复杂度偏低。 AVL树 AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或
AVL树原理理解：旋转与平衡
angrypop的博客
09-14 1541
二叉查找树原理理解：进阶与平衡 1.大危机 假如要构建BST的数组本身是严格递增的… 查找树会退化成一条链，构造将毫无意义。 2.平衡
AVL树的旋转图解和简单实现
热门推荐
喵了个呜的博客
07-07 4万+
AVL树是带有平衡条件的查找二叉树。这个平衡条件要容易保持，而且他要保证树的深度为O(logN) 原文地址：http://blog.csdn.net/qq_25806863/article/details/74755131 平衡条件 一个最理想的平衡条件是左右两个子树的高度完全相等，但只有节点数量为2^n-1的树才满足这个条件（n是层数，2层要3个，3层要7个）。这个条件太严格，不好用。...
数据结构之单链表之环形链表
最新发布
zxybf_的博客
05-06 105
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。
用c++实现avl树的插入和删除
05-02
下面是C语言实现的AVL树插入和删除操作： AVL树插入操作： ```c // AVL树节点定义 struct AVLNode { int key; int height; struct AVLNode* left; struct AVLNode* right; }; // 计算节点高度 int height...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

necesse

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

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

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

打赏作者

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

抵扣说明：

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

余额充值