C++进阶-AVL树（map和set）

最新推荐文章于 2024-08-28 14:35:43 发布
最新推荐文章于 2024-08-28 14:35:43 发布
阅读量921 收藏 25
点赞数 10
分类专栏： C++进阶 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64423718/article/details/140591360
版权

1.AVL树

4.1.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)

4.1.2 AVL树节点的定义

AVL树节点的定义:

// 节点类
template<class K,class V>
struct AVLTreeNode
{
	//K _key;// 节点数据
	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),
		_bf(0),
		_kv(kv)
	{}
};

4.1.3 AVL树的插入

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

  • 1.按照二叉搜索树的方式插入新节点
  • 2.调整节点的平衡因子

插入的规则要求：

  1. 按照搜索树规则插入
  2. 更新插入节点的祖先节点的平衡因子
  • a.插入父亲的左边，父亲的平衡因子–
  • b.插入父亲的右边，父亲的平衡因子++
  • c.更新后父亲的平衡因子 == 0，父亲所在子树高度不变，不再继续往上更新，插入结束
  • d.更新后父亲的平衡因子 == 1 or -1，父亲所在子树高度变了，继续往上更新
  • e.更新后父亲的平衡因子 == 2 or -2，父亲所在子树已经不平衡了，需要旋转处理
    更新中不可能出现其他值，插入之前树是AVL树，平衡因子要么是1 -1 0，++ --最多就是c/d/e三种情况

插入（insert）方法
bool Insert(const pair<K,V>& kv)
1.先按照搜索树规则插入：
先判断是否为空，之后比较数据，小于节点数据则走左子树，大于走右子树，等于则错误（不能冗余）
找到插入位置，则判断左孩子还是右孩子

// 判断是否为空
if (_root == nullptr)
{
	// 插入的节点就时根节点
	_root = new Node(kv);
	return true;

}

//1.按照搜索树规则插入

// _root不为空时，要从根节点开始向下查询
// 记录父亲节点
Node* parent = nullptr;
Node* cur = _root;


// 循环结束条件，查找到叶子节点
while (cur)
{
	// kv的first小于cur的first，查找左子数
	// 反之，查找右子树
	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;
	}
}

// 找到插入的位置时
cur = new Node(kv);

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

// 更新平衡因子
// ...
  1. 更新插入节点的祖先节点的平衡因子
    a.插入父亲的左边，父亲的平衡因子–
    b.插入父亲的右边，父亲的平衡因子++
// 插入完成后
// 更新平衡因子
// 2.更新插入节点的祖先节点的平衡因子
// 由下向上更新
// 这棵树的平衡因子定义为 平衡因子 = 右子树高度 - 左子树高度
// 由下往上改平衡因子
while (parent)
{
	// a.插入父亲的左边，父亲的平衡因子--
	if (cur == parent->_left)
	{
		parent->_bf--;
	}
	else// b.插入父亲的右边，父亲的平衡因子++
	{
		parent->_bf++;
	}



// 此处先省略
//...

}

c.更新后父亲的平衡因子 == 0，父亲所在子树高度不变，不再继续往上更新，插入结束
d.更新后父亲的平衡因子 == 1 or -1，父亲所在子树高度变了，继续往上更新
在上面的省略处写

// 	c.更新后父亲的平衡因子 == 0，父亲所在子树高度不变，不再继续往上更新，插入结束
if (parent->_bf == 0) // 1 -1 -> 0
{
	// 更新完毕
	break;
}
// d.更新后父亲的平衡因子 == 1 or -1，父亲所在子 树高度变了，继续往上更新
else if (parent->_bf == 1 || parent->_bf == -1) // 0 -> 1 -1
{
	// 继续往上更新
	// 往上更新，将父亲给cur
	cur = parent;
	parent = parent->_parent;
}
// 	e.更新后父亲的平衡因子 == 2 or -2，父亲所在子树已经不平衡了，需要旋转处理
else if (parent->_bf == -2 || parent->_bf == 2) // 1 -1 -> 2 -2
{
//...
}

e.更新后父亲的平衡因子 == 2 or -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);
}

插入方法的代码总和

bool Insert(const pair<K,V>& kv)
{
	// 判断是否为空
	if (_root == nullptr)
	{
		// 插入的节点就时根节点
		_root = new Node(kv);
		return true;

	}

	//1.按照搜索树规则插入


	// _root不为空时，要从根节点开始向下查询
	// 记录父亲节点
	Node* parent = nullptr;
	Node* cur = _root;


	// 循环结束条件，查找到叶子节点
	while (cur)
	{
		// kv的first小于cur的first，查找左子数
		// 反之，查找右子树
		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;
		}
	}
	 

	// 找到插入的位置时
	cur = new Node(kv);

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


	// 插入完成后
	// 更新平衡因子
	// 2.更新插入节点的祖先节点的平衡因子
	// 由下向上更新
	// 这棵树的平衡因子定义为 平衡因子 = 右子树高度 - 左子树高度

	// 由下往上改平衡因子
	while (parent)
	{
		// a.插入父亲的左边，父亲的平衡因子--
		if (cur == parent->_left)
		{
			parent->_bf--;
		}
		else// b.插入父亲的右边，父亲的平衡因子++
		{
			parent->_bf++;
		}
		


		// 	c.更新后父亲的平衡因子 == 0，父亲所在子树高度不变，不再继续往上更新，插入结束
		if (parent->_bf == 0) // 1 -1 -> 0
		{
			// 更新完毕
			break;
		}
		// d.更新后父亲的平衡因子 == 1 or -1，父亲所在子 树高度变了，继续往上更新
		else if (parent->_bf == 1 || parent->_bf == -1) // 0 -> 1 -1
		{
			// 继续往上更新
			// 往上更新，将父亲给cur
			cur = parent;
			parent = parent->_parent;
		}
		// 	e.更新后父亲的平衡因子 == 2 or -2，父亲所在子树已经不平衡了，需要旋转处理
		else if (parent->_bf == -2 || parent->_bf == 2) // 1 -1 -> 2 -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;

}

4.1.4 AVL树的旋转

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

  1. 新节点插入较高左子树的左侧—左左：右单旋
    在这里插入图片描述
// 旋转只有看parent的节点
// 右单旋
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;


	parent->_left = subLR;
	// 每个节点的父亲也要记得修改
	if (subLR != nullptr)
	{
		subLR->_parent = parent;
	}
	
	Node* ppNode = parent->_parent;
	subL->_right = parent;
	parent->_parent = subL;


	// 更新平衡因子
	// 注意两个关键情况：
	// 1.parent为根节点
	// 2.parent是第二层的节点

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

		subL->_parent = ppNode;
	}

	// 更新平衡因子
	parent->_bf = subL->_bf = 0;
}
  1. 新节点插入较高右子树的右侧—右右：左单旋
// 左单旋
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

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

	Node* ppNode = parent->_parent;
	
	subR->_left = parent;
	parent->_parent = subR;


	// 更新平衡因子
	// 注意两个关键情况：
	// 1.parent为根节点
	// 2.parent是第二层的节点
	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;
}
  1. 新节点插入较高左子树的右侧—左右：先左单旋再右单旋
    这里面又分为三种情况：

a.60自己就是新增
在这里插入图片描述

b.b插入时，引发的旋转
在这里插入图片描述

c.c插入时，引发的旋转
在这里插入图片描述

// 左右单旋
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	int bf = subLR->_bf;// 记录一下平衡因子

	// 先进行左单旋,在进行右单旋
	RotateL(subL);
	RotateR(parent);

	//更新平衡因子三种情况
	// 1.60自己就是新增
	if (bf == 0)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 0;
	}
	// 2.60的平衡因子为-1，b插入
	else if (bf == -1)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 1;
	}
	// 3.60的平衡因子为1，c插入
	else if (bf == 1)
	{
		subLR->_bf = 0;
		subL->_bf = -1;
		parent->_bf = 0;
	}
	else
	{
		assert(false);
	}
}
  1. 新节点插入较高右子树的左侧—右左：先右单旋再左单旋
    a.60自己就是新增
    在这里插入图片描述

b.b插入时，引发的旋转
在这里插入图片描述

c.c插入时，引发的旋转
在这里插入图片描述

// 右左单旋
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

	// 记录平衡因子
	int bf = subRL->_bf;

	// 先右旋，在左旋
	RotateR(subR);
	RotateL(parent);

	subRL->_bf = 0;
	// 更新平衡因子三种情况
	// 1.60自己就是新增
	if (bf == 0)
	{
		subR->_bf = 0;
		parent->_bf = 0;
	}
	// 2.60的平衡因子为-1，b插入
	else if (bf == -1)
	{
		subR->_bf = 1;
		parent->_bf = 0;
	}
	// 3.60的平衡因子为1，c插入
	else if (bf == 1)
	{
		subR->_bf = 0;
		parent->_bf = -1;
	}
	else
	{
		assert(false);
	}
}

4.1.5 AVL树的验证

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

    1. 验证其为二叉搜索树
      如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
    1. 验证其为平衡树
      每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
      节点的平衡因子是否计算正确

4.1.6 AVL树的删除(了解)

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

	// 中序输出
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	// 判断平衡
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	//计算高度
	int Height()
	{
		return _Height(_root);
	}
	// 节点数量
	int Size()
	{
		return _Size(_root);
	}
	
private:
	 
	// 计算节点个数基本
	int _Size(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		return _Size(root->_left) + _Size(root->_right) + 1;
	}

	// 计算高度基本
	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		return max(_Height(root->_left), _Height(root->_right)) + 1;
	}


	// 判断平衡基本
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}

		int leftHight = _Height(root->_left);
		int rightHight = _Height(root->_right);

		// 不平衡
		if (abs(rightHight - leftHight) >= 2)
		{
			return false;
		}

		// 顺便检查一下平衡因子是否正确
		if (rightHight - leftHight != root->_bf)
		{
			cout << root->_kv.first << endl;
			return false;
		}

		// 判断左子树和右子树是否平衡
		return _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}
	
	// 中序输出基本
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	}

4.1.7 AVL树的性能

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

bingo691
关注
  • 10
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++进阶-红黑树（map和set）
weixin_64423718的博客
07-26 948
/ 枚举RED,BLACK// 节点类// 父亲节点// 左孩子节点// 右孩子节点// 节点数据// 节点颜色// 构造函数, _kv(kv){}
C++进阶--红黑树模拟实现STL中的map和set
sushang的博客
01-15 1245
因此，上层容器map需要向底层红黑树提供一个仿函数，用于获取T当中的键值Key，这样一来，当底层红黑树当中需要比较两个结点的键值时，就可以通过这个仿函数来获取T当中的键值了。但是对于底层红黑树来说，它并不知道上层容器是map还是set，因此需要进行两个结点键值的比较时，底层红黑树都会通过传入的仿函数来获取键值Key，进而进行两个结点键值的比较。这样一来，当底层红黑树需要进行两个结点之间的键值的比较时，都会通过传入的仿函数来获取相应结点的键值，然后再进行比较。
C++ -- 红黑树封装set和map
m0_46343224的博客
05-17 484
图片理解红黑树插入实现以及测试，使用红黑树封装set和map，用图像调用关系说明封装难点
C++进阶 —— AVL树
fen_0108的博客
08-14 1382
AVL树的节点内容包括：1、左右节点的地址；2、平衡因子；3、自身存储的数据；4、父节点的地址。int _bf;// 平衡因子:_kv(kv), _bf(0){}private:public://强制让编译器生成构造函数~AVLTree()private:return;
【C++】-- AVL树详解
局部变量和全局变量
08-31 2453
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： (1)它的左右子树都是AVL树 (2)左右子树高度之差(简称平衡因子=右子树高度-左子树高度)的绝对值不超过1(-1/0/1)
【C++】红黑树 --- map/set 底层
YoungMLet的博客
11-13 1260
了解 map/set 底层红黑树的插入！使用红黑树封装 map/set ！
DS进阶：AVL树和红黑树
weixin_51142926的博客
04-24 2097
二叉搜索树（BST）虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。 而AVL树的平衡太过严格，导致维护效率很低，因此红黑树应运而生！！
C++-----AVL树的模拟实现
拾至名瑰的博客
10-04 422
上篇文章我们了解到了map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。正文开始！！！//该节点的左孩子 AVLTreeNode < K , V > * _right;
c++ - 第16节 - map和set
qq_45113223的博客
12-10 1135
翻译：1.set是按照一定次序存储元素的容器2.在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。3.在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。4.set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。5.set在底层是用二叉搜索树(红黑树)实现的。
STL AVL map/set library-开源
04-26
STL AVL map/set库是一个开源项目，旨在提供一个与g++兼容的C++标准模板库（STL）实现，但其内部数据结构采用AVL树而非传统的Red-Black树。这个选择是为了提供更快的查找、插入和删除操作，因为AVL树在平衡方面有着...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2676
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3014
红黑树详解
C++ AVL树
weixin_53946312的博客
01-27 1166
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
最新发布
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 492
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C++ 重载运算符和重载函数
lly202406的博客
08-25 1008
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1793
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
C++的内存模型
qhu1600417010的博客
08-28 798
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 505
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
探索搜索树：二叉、AVL、红黑与B-树的原理与应用
在实际应用中，搜索树被广泛用于关联数组的实现，如C++ STL中的set、multiset、map和multimap。例如，在Linux内核中，红黑树用于管理虚拟内存的区间分配。红黑树的平衡性和高效的查找操作使得它成为这类场景的理想...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值