AVL树深度解析

已于 2024-03-30 10:29:39 修改
阅读量1.1k 收藏 19
点赞数 37
分类专栏： C嘎嘎 文章标签： c++ 数据结构
于 2024-03-29 21:32:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_75172965/article/details/137155553
版权

目录

一.   AVL树的概念

二.   AVL树节点的定义

三.   AVL树的基本操作

3.1   插入操作：

3.1.1   parent->_pf = 0

3.1.2   abs(parent->_pf) = 1

3.1.3   abs(parent->_pf) = 2

3.1.3.1        parent->_pf = 2 && cur->_pf = 1  

3.1.3.2        parent->_pf = -2 && cur->_pf =- 1

3.1.3.3        parent->_pf = -2 && cur->_pf = 1

3.1.3.4        parent->_pf = 2 && cur->_pf = -1

四.   总体代码

一.   AVL树的概念

我们上一篇博客讲了，二叉搜索树在极端情况下会退化为单支树的情况（具体可以看上一篇博客：http://t.csdnimg.cn/o7PiL）。那我们该如何解决这种问题呢？

诶，还真有这种方法，是由著名的两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年提出的。如果让左右子树的高度差的绝对值不超过1，那我们就可以避免这种单支树的情况。

那我们将具有以下特征的二叉搜索树叫做AVL树：

  1. 左右子树的高度差（这里简称平衡因子）的绝对值不超过1
  2. 左右子树都是AVL树

 

 如果一棵树是高度平衡的，那它就是AVL树，如果这棵树有n个节点，那我们能把这棵树的高度维持在log2n，查找的时间复杂度可以维持在O(log2n)。

二.    AVL树节点的定义

我们用代码来刻画这个定义：

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _pf;//平衡因子
	pair<K, V> _kv;
	AVLTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_pf(0)
		,_kv(kv)
	{}
};

可以看见，我们引进了平衡因子这个变量，来显示左右子树的高度差。

特别说明：此处平衡因子是右边减去左边。

三.   AVL树的基本操作

我们这里着重讲解AVL树的插入操作，其他操作与普通的二叉搜索树是一样的。

3.1   插入操作：

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 (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first>kv.first)
		{
			parent->_left = cur;
		}
		else if(parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_pf--;
			}
			else if (cur == parent->_right)
			{
				parent->_pf++;
			}
			if (parent->_pf == 0)
			{
				break;
			}
			else if (parent->_pf == 1 || parent->_pf == -1)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else if (parent->_pf == 2 || parent->_pf == -2)
			{
				//旋转处理
				if (parent->_pf == 2 && cur->_pf == 1)
				{
					RotaleL(parent);
				}
				else if (parent->_pf == -2 && cur->_pf ==- 1)
				{
					RotaleR(parent);
				}
				else if (parent->_pf == -2 && cur->_pf == 1)
				{
					RotaleLR(parent);
				}
				else
				{
					RotaleRL(parent);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

我们依次来解析需要特殊处理的情况：

3.1.1   parent->_pf = 0

当父节点的平衡因子为0时，证明左右子树是平衡的，不需要再做处理，直接跳出循环。

if (parent->_pf == 0)
{
	break;
}

3.1.2   abs(parent->_pf) = 1

当父节点的平衡因子的绝对值为1时，证明此父节点下的子树是平衡的，但是，由于我们前面改变了父节点的平衡因子，可能导致父节点的祖宗节点不平衡，所以我们要向上迭代，再次进行判断。

else if (parent->_pf == 1 || parent->_pf == -1)
{
	cur = cur->_parent;
	parent = parent->_parent;
}

3.1.3   abs(parent->_pf) = 2

当父节点的平衡因子绝对值为2时，我们为了保证树的平衡，需要进行一些旋转操作。此类情况比较复杂，又细分为以下几种情况：

3.1.3.1        parent->_pf = 2 && cur->_pf = 1  

当父节点的平衡因子为2，而当前节点平衡因子为1时，是在当前节点是父节点的右子节点，并且插入节点是当前节点的右子节点发生的。

此时我们要进行左单旋：

if (parent->_pf == 2 && cur->_pf == 1)
{
	RotaleL(parent);
}

void RotaleL(Node* parent)
{
	totalSize++;
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	parent->_right = subRL;
	subR->_left = parent;
	if (subRL)
	{
		subRL->_parent = parent;
	}
	Node* ppnode = parent->_parent;
	parent->_parent = subR;
	if (parent == _root)
	{
		_root = subR;
		subR->_parent == nullptr;
	}
	else
	{
		if (parent == ppnode->_left)
		{
			ppnode->_left = subR;
		}
		else if (parent == ppnode->_right)
		{
			ppnode->_right = subR;
		}
		subR->_parent = ppnode;
	}
	parent->_pf = 0;
	subR->_pf = 0;
}

 总结来说，此情况就是让当前节点的左子树变为父节点的右子树，而当前节点的左子树变为父节点，再改变当前节点和父节点的父节点指向并更新平衡因子即可。

3.1.3.2        parent->_pf = -2 && cur->_pf =- 1

当父节点的平衡因子为-2，而当前节点平衡因子为-1时，是在当前节点是父节点的左子节点，并且插入节点是当前节点的左子节点发生的。

此时我们要进行右单旋：

else if (parent->_pf == -2 && cur->_pf ==- 1)
{
	RotaleR(parent);
}

void RotaleR(Node* parent)
{
	totalSize++;
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	parent->_left = subLR;
	if (subLR)
	{
		subLR->_parent = parent;
	}
	subL->_right = parent;
	Node* ppnode = parent->_parent;
	parent->_parent = subL;
	if (parent == _root)
	{
		_root=subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (ppnode->_left == parent)
		{
			ppnode->_left = subL;
		}
		else if (ppnode->_right == parent)
		{
			ppnode->_right = subL;
		}
		subL->_parent = ppnode;
	}
	subL->_pf = 0;
	parent->_pf = 0;
}

总结来说，此情况就是让当前节点的右子树变为父节点的左子树，而当前节点的右子树变为父节点，再改变当前节点和父节点的父节点指向并更新平衡因子即可。

3.1.3.3        parent->_pf = -2 && cur->_pf = 1

 当父节点的平衡因子为-2，而当前节点平衡因子为1时，是在当前节点是父节点的左子节点，并且插入节点是当前节点的右子节点发生的。

 

此情况比较复杂，单一的旋转已经不能满足树的平衡了，我们此时要先左旋再右旋：

else if (parent->_pf == -2 && cur->_pf == 1)
{
	RotaleLR(parent);
}

void RotaleLR(Node* parent)
{
	totalSize++;
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int pf = subLR->_pf;
	RotaleL(parent->_left);
	RotaleR(parent);
	if (pf == 1)
	{
		subLR->_pf = 0;
		subL->_pf = -1;
		parent->_pf = 0;
	}
	else if (pf == -1)
	{
		subL->_pf = 0;
		subLR->_pf = 0;
		parent->_pf = 1;
	}
	else if (pf == 0)
	{
		subL->_pf = 0;
		subLR->_pf = 0;
		parent->_pf = 0;
	}
}

总结来说，可以复用前面的左旋与右旋函数，但是与前面不同的是需要分情况处理平衡因子。

3.1.3.4        parent->_pf = 2 && cur->_pf = -1

当父节点的平衡因子为2，而当前节点平衡因子为-1时，是在当前节点是父节点的右子节点，并且插入节点是当前节点的左子节点发生的。

此情况同样单一的旋转已经不能满足树的平衡了，我们此时要先右旋再左旋： 

else
{
	RotaleRL(parent);
}

void RotaleRL(Node* parent)
{
	totalSize++;
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int pf = subRL->_pf;
	RotaleR(parent->_right);
	RotaleL(parent);
	if (pf == 1)
	{
		subRL->_pf = 0;
		subR->_pf = 0;
		parent->_pf = -1;
	}
	else if (pf == -1)
	{
		subR->_pf = 1;
		subRL->_pf = 0;
		parent->_pf = 0;
	}
	else if (pf == 0)
	{
		subR->_pf = 0;
		subRL->_pf = 0;
		parent->_pf = 0;
	}
}

总结来说，可以复用前面的右旋与左旋函数，但是与前面同样不同的是需要分情况处理平衡因子。

四.   总体代码

整合一下代码，如下：

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _pf;//平衡因子
	pair<K, V> _kv;
	AVLTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_pf(0)
		,_kv(kv)
	{}
};
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 (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first>kv.first)
		{
			parent->_left = cur;
		}
		else if(parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_pf--;
			}
			else if (cur == parent->_right)
			{
				parent->_pf++;
			}
			if (parent->_pf == 0)
			{
				break;
			}
			else if (parent->_pf == 1 || parent->_pf == -1)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else if (parent->_pf == 2 || parent->_pf == -2)
			{
				//旋转处理
				if (parent->_pf == 2 && cur->_pf == 1)
				{
					RotaleL(parent);
				}
				else if (parent->_pf == -2 && cur->_pf ==- 1)
				{
					RotaleR(parent);
				}
				else if (parent->_pf == -2 && cur->_pf == 1)
				{
					RotaleLR(parent);
				}
				else
				{
					RotaleRL(parent);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}
	void RotaleL(Node* parent)
	{
		totalSize++;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		subR->_left = parent;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		parent->_parent = subR;
		if (parent == _root)
		{
			_root = subR;
			subR->_parent == nullptr;
		}
		else
		{
			if (parent == ppnode->_left)
			{
				ppnode->_left = subR;
			}
			else if (parent == ppnode->_right)
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
		parent->_pf = 0;
		subR->_pf = 0;
	}
	void RotaleR(Node* parent)
	{
		totalSize++;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		subL->_right = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subL;
		if (parent == _root)
		{
			_root=subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else if (ppnode->_right == parent)
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
		subL->_pf = 0;
		parent->_pf = 0;
	}
	void RotaleLR(Node* parent)
	{
		totalSize++;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int pf = subLR->_pf;
		RotaleL(parent->_left);
		RotaleR(parent);
		if (pf == 1)
		{
			subLR->_pf = 0;
			subL->_pf = -1;
			parent->_pf = 0;
		}
		else if (pf == -1)
		{
			subL->_pf = 0;
			subLR->_pf = 0;
			parent->_pf = 1;
		}
		else if (pf == 0)
		{
			subL->_pf = 0;
			subLR->_pf = 0;
			parent->_pf = 0;
		}
	}
	void RotaleRL(Node* parent)
	{
		totalSize++;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int pf = subRL->_pf;
		RotaleR(parent->_right);
		RotaleL(parent);
		if (pf == 1)
		{
			subRL->_pf = 0;
			subR->_pf = 0;
			parent->_pf = -1;
		}
		else if (pf == -1)
		{
			subR->_pf = 1;
			subRL->_pf = 0;
			parent->_pf = 0;
		}
		else if (pf == 0)
		{
			subR->_pf = 0;
			subRL->_pf = 0;
			parent->_pf = 0;
		}
	}
	void _Inorder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_kv.first << "[" << root->_pf << "]" << endl;
		_Inorder(root->_right);
	}
	void Inorder()
	{
		_Inorder(_root);
	}
	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftheight = _Height(root->_left);
		int rightheight = _Height(root->_right);
		return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
	}
	int Height()
	{
		return _Height(_root);
	}
	//初始版本
	/*bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int leftheight = _Height(root->_left);
		int rightheight = _Height(root->_right);
		if (abs(leftheight - rightheight) >= 2)
		{
			cout << root->_kv.first << "不平衡" << endl;
			return false;
		}
		else if ((rightheight - leftheight) != root->_pf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
		return _IsBalance(root->_left) && _IsBalance(root->_right);
	}*/
	bool _IsBalance(Node* root,int& height)
	{
		if (root == nullptr)
		{
			height = 0;
			return true;
		}
		int leftheight = 0, rightheight = 0;
		if (!_IsBalance(root->_left, leftheight)
			||!_IsBalance(root->_right, rightheight))
		{
			return false;
		}
		if (abs(rightheight - leftheight) >= 2)
		{
			cout << root->_kv.first << "不平衡" << endl;
			return false;
		}
		else if ((rightheight - leftheight) != root->_pf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
		height = leftheight > rightheight ? leftright + 1 : rightheight + 1;
		return true;
	}
	bool IsBalance()
	{
		int height = 0;
		return _IsBalance(_root,height);
	}
	size_t _size(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		return _size(root->_left) + _size(root->_right) + 1;
	}
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
	size_t size()
	{
		return _size(_root);
	}
	int GettotalSize()
	{
		return totalSize;
	}
private:
	Node* _root = nullptr;
	int totalSize = 0;
};

 总结

好了，到这里今天的知识就讲完了，大家有错误一点要在评论指出，我怕我一人搁这瞎bb，没人告诉我错误就寄了。

祝大家越来越好，不用关注我（疯狂暗示）

小灵蛇
关注
  • 37
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构之AVL树详解
12-26
1. 概述 AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下都是O（log n），增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。本文介绍了AVL树的设计思想和基本操作。 2. 基本术语 有四种种情况可能导致二叉查找树不平衡，分别为： （1）LL：插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因子由1变为2 （2）RR：插入一个新节点到根节点的右子树（Right
avl.rar_AVL树
09-19
基本的avl树，实现构造插入和删除节点的功能
AVL.rar_AVL树
09-24
自己写的数据结构的AVL树的算法，大二的时候写的，写的不好请不要见怪
深度解析红黑树
weixin_43274704的博客
08-01 2176
前言 红黑树是计算机科学中最难理解的数据结构之一，本文将带大家从认识红黑树的前世今生开始，探寻红黑树的结构和原理。 二叉查找树 二叉查找树的定义 二叉查找树是一种特殊的二叉树，其改善了二叉树结点查找的效率，二叉查找树具有以下性质： 对于任意一个节点n： 1、其左子树下的每个后代节点的值都小于节点n的值。 2、其右子树下的每个后代节点的值都大于节点n的值。 3、左右子树也均为二叉查找树。 所谓节点 n 的子树，可以将其看作是以节点 n 为根节点的树。子树的所有节点都是节点 n 的后代，而子树的根则是节点 n
详解AVL树（平衡二叉树）
热门推荐
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
C语言-AVL树
2301_79349959的博客
02-02 741
当插入节点在“外侧”时（即左-左或右-右的情况），进行所谓的单旋转操作。在保留二叉搜索树特性的同时，又加上了平衡条件，即每个节点的左右子树的高度最多差1。《数据结构与算法分析》一书中认为AVL树的删除操作较为复杂，更加推荐使用懒惰删除，即保留节点在树中，但是加以标记。不过值得注意的是，代码中的Height函数单独出来写是有必要的，因为我们要处理空树的情况。总体上插入函数的思路与二叉搜索树的插入函数思路相似，不过多了对树高导致不平衡的条件的讨论。在有了以上对旋转的讨论之后，完成节点的插入操作就不再是难事。
AVL树小结
JK_spc的博客
03-18 348
引言： 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algor
数据结构与算法学习笔记七--二叉树(C++)
我叫柱子哥
04-23 607
在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。根节点（Root）：树中的唯一顶层节点，没有父节点。
【C】 初识C语言
努力学习C/C++
04-21 763
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
我的博客
04-22 595
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
C++——初识模板
qq_74245477的博客
04-22 885
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
【C++风云录】精益求精：探索C++开发中的性能优化艺术
记录我的学习历程
04-21 1066
本文将介绍几个在C++开发中常用的性能分析工具和性能优化工具集，包括PerfTools、gperftools、Valgrind、Intel VTune、PAPI以及Boost.Profile。通过深入了解这些工具的功能和用途，读者可以更好地理解如何利用它们来提高代码的执行效率和资源利用率。
c++ GetStdHandle(STD_OUTPUT_HANDLE)
m0_74811974的博客
04-20 303
114514
C语言：贪吃蛇游戏（万字解读超详细）
2301_80655639的博客
04-20 1050
贪吃蛇这个游戏应该我们小时候都玩过吧我相信能够点进这个博客的应该都很熟悉这个游戏了如果对这个游戏不熟悉的可以网上查查怎么玩，这样才能对这个游戏有个清晰的认知该篇博客需要拥有C语言基础（对指针熟悉、会链表的使用）下面我们需要先学习一些C语言之外的东西认真坚持看完，我相信你一定能完成这个接近500行的C语言贪吃蛇项目该类型内部封装了两个成员，一个x，一个y，代表坐标我们可以将我们的控制台理解为一个平面坐标图横向正方向是x轴正方向，竖向负方向是y轴正方向。
C++中的抽象类
hh121386的博客
04-23 182
C++中的抽象类
掉落回弹问题（C语言）
m0_67184754的博客
04-22 349
【代码】掉落回弹问题（C语言）
CSAPP | Lab2-Bomb Lab详细解析
最新发布
wangs29的博客
04-24 1247
邪恶的邪恶博士在我们班的机器上安放了大量的“二元炸弹”。二进制炸弹是一个由一系列阶段组成的程序。每个阶段都要求你在 stdin 上键入一个特定的字符串。如果你键入了正确的字符串，那么这个阶段就会被拆除，炸弹就会进入下一个阶段。否则，炸弹会通过打印“ BOOM 然后终止。当每个阶段都被拆除时，炸弹就会被拆除。我们要处理的炸弹太多了，所以我们给每个学生一个炸弹去拆除。你们的任务，你们别无选择，只能接受，就是在due date前拆除炸弹。祝你好运，欢迎加入拆弹小组！
项目——C++协程库
qq_44736340的博客
04-20 86
1。
红黑树对比avl树有点
08-06
红黑树和AVL树都是自平衡的二叉搜索树，它们在维护树的平衡性方面有一些不同之处。 1. 平衡条件：AVL树要求每个节点的左右子树高度差不能超过1，而红黑树则有一组规则来保证树的平衡性。 2. 平衡调整：在插入或...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值