C++AVL树

原创 已于 2025-10-19 14:52:30 修改 · 1k 阅读 · 12 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#数据结构 #c++
于 2025-10-17 21:20:38 首次发布

目录

1、AVL树的概念

2、AVL树的基本操作

2.1创建一个节点

2.2AVL树的插入

2.2.1按照二叉搜索树的方式插入一个新的节点

2.2.2调整节点的平衡因子

2.2.3旋转

2.2.3.1左单旋

2.2.3.2右单旋

2.2.3.3左右双旋

2.2.3.4右左双旋

2.2.3.5总结

3、检查是否为AVL树

4、总代码

1、AVL树的概念

AVL树又被称为平衡二叉搜索书，它是俄罗斯的两位数学家G.M. Adelson-Velsky 和 E.M. Landis名字的缩写。

搜索二叉树虽然可以缩短查找的效率，但如果当一组数据有序或接近有序时，这会导致搜索二叉树退化成单支树，查找的效率就会相当于在顺序表中查找的效率，效率低下。AVL树的出现就是为了解决这一问题：当向二叉树中插入一个新节点后，要保证该树中每个节点的左右子树的高度差不超过1，这就可以降低树的高度，从而减少搜索长度。

AVL树本质上是一棵二叉搜索树，但它还具有以下性质：

  • 它的左右子树都是AVL树
  • 左右子树的最大高度差（简称平衡因子，右子树的最大高度-左子树的最大高度）不超过1（-1/0/1）

2、AVL树的基本操作

2.1创建一个节点

由于AVL树的底层是一棵二叉搜索树，因此AVL树的节点内存储的变量与普通二叉搜索数的变量基本相似，但是由于该树要构成一颗三叉链，因此内部要存储一个父节点的指针。为了平衡因子计算的方便，可以在该节点中加入一个整形用来存储平衡因子，但这并不是必须的

template<class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& val)
		:_left(nullptr), _right(nullptr)
		, _parent(nullptr), _val(val), _bf(0) //一个新节点左右都为空，故平衡因子初始化为0
	{ }
	AVLTreeNode* _left; //节点的左孩子
	AVLTreeNode* _right; //节点的右孩子
	AVLTreeNode* _parent; //节点的父亲

	T _val;
	int _bf; //该节点的平衡因子
};

2.2AVL树的插入

AVL树的插入就是在二叉搜索树插入的基础上引入了平衡因子，因此AVL树的插入可以分为两部分：

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

2.2.1按照二叉搜索树的方式插入一个新的节点

	bool insert(const T& val)
	{
		if (_root == nullptr)
		{
			_root = new Node(val);
			return true;
		}

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

		while (cur) //直到cur == nullptr循环结束
		{
			if (val > cur->_val)
			{
				parent = cur;
				cur = cur->_right；
			}
			else if (val < cur->_val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else //val == cur->_val，插入失败
			{
				return false;
			}
		}
		cur = new Node(val);
		if (cur->_val > parent->_val)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;
	}

2.2.2调整节点的平衡因子

插入新节点后可能会导致其父节点的平衡因子发生改变，在插入新节点前，父节点的平衡因子有以下三种情况：-1/0/1，插入新节点后，父节点的平衡因子变化有两种方式：

  1. 插入的节点位于父节点的左边，父节点的平衡因子-1
  2. 插入的节点位于父节点的右边，父节点的平衡因子+1

插入新节点后会导致其父节点的平衡因子有以下几种情况：-2/-1/0/1/2

  1. 如果此时父节点的平衡因子为0，这说明在插入新节点前父节点的平衡因子为1或-1，插入后被调整为0，这表明该树的高度没有改变，且满足AVL树的性质，因此不需要进行调整
  2. 如果此时父节点的平衡因子为-1或1，这说明在插入新节点前父节点的平衡因子为0，插入后被调整为-1或1，这说明树的高度发生了改变，因此需要继续向上更新平衡因子，直到平衡因子再次为0或更新至根节点
  3. 如果此时父节点的平衡因子为-2或2，这说明在插入新节点前父节点的平衡因子为-1或1，插入后被调整为-2或2，这说明树的高度发生了改变，且由于该树不符合AVL树的性质，因此需要对其进行旋转处理

2.2.3旋转

AVL树的旋转分为单旋和双旋，单旋被分为左单旋和右单旋，双旋被分为左右双旋和右左双旋

2.2.3.1左单旋

从上图中我们可以看到，当在c这棵树中插入节点时，c的高度变成了h+1，此时60这个节点的平衡因子变为1，故需要向上传递，30的平衡因子就会变成2，这时就会导致这棵树不符合AVL树的性质，因此会触发旋转，由于高的一侧位于树的右边所以要进行左单旋。左单旋就是使60这个节点变为这棵树根节点，30的右子树的指针指向60的左子树b，60的左子树的指针指向30这个节点，这样就完成了一次左单旋，旋转结束后要记得更新平衡因子。

在节点30的右节点的右子树上插入新的节点，我们成这种情况叫做右右型，要用到左旋转

在旋转过程中要考虑一下几个事项：

  1. 60的左孩子可能存在，也可能不存在，因此在调整指针指向时要特别注意_parent指针
  2. 30可能是根节点，也可能是一棵子树。如果是根节点，在旋转结束后要及时更新根节点的指向；如果是一棵子树，就要判断这棵子树是在左子树还是在右子树
//if (parent->_bf == 2 && cur->_bf == 1) //新节点位于右节点的右子树
//{
//    RotateL(parent);
//}

void RotateL(Node* parent)
{
	Node* subr = parent->_right;
	Node* subrl = subr->_left;
	Node* pparent = parent->_parent;

	parent->_right = subrl;
	if (subrl)
		subrl->_parent = parent;
	subr->_left = parent;
	parent->_parent = subr;

	if (_root == parent)
	{
		_root = subr;
		subr->_parent = nullptr;
	}
	else
	{
		if (pparent->_left == parent)
		{
			pparent->_left = subr;
		}
		else
		{
			pparent->_right = subr;
		}
		subr->_parent = pparent;
	}
	parent->_bf = subr->_bf = 0;
}
2.2.3.2右单旋

从上图中我们可以看到，当在a这棵树中插入节点时，a的高度变成了h+1，此时30这个节点的平衡因子变为-1，故需要向上传递，60的平衡因子就会变成-2，这时就会导致这棵树不符合AVL树的性质，因此会触发旋转，由于高的一侧位于树的左边所以要进行右单旋。右单旋就是使30这个节点变为这棵树根节点，60的左子树的指针指向30的右子树b，30的右子树的指针指向60这个节点，这样就完成了一次右单旋，旋转结束后要记得更新平衡因子。

在节点60的左节点的左子树上插入新的节点，我们成这种情况叫做左左型，要用到右旋转

在旋转过程中要考虑一下几个事项：

  1. 30的右孩子可能存在，也可能不存在，因此在调整指针指向时要特别注意_parent指针
  2. 60可能是根节点，也可能是一棵子树。如果是根节点，在旋转结束后要及时更新根节点的指向；如果是一棵子树，就要判断这棵子树是在左子树还是在右子树
//else if (parent->_bf == -2 && cur->_bf == -1)
//{
//	  RotateR(parent);
//}
void RotateR(Node* parent)
{
	Node* subl = parent->_left;
	Node* sublr = subl->_right;
	Node* pparent = parent->_parent;

	parent->_left = sublr;
	if (sublr)
		sublr->_parent = parent;
	subl->_right = parent;
	parent->_parent = subl;

	if (_root == parent)
	{
		_root = subl;
		subl->_parent = nullptr;
	}
	else
	{
    	if (pparent->_left == parent)
		{
			pparent->_left = subl;
		}
		else
		{
			pparent->_right = subl;
		}
		subl->_parent = pparent;
	}
	parent->_bf = subl->_bf = 0;
}
2.2.3.3左右双旋

从上图我们可以看到在90这个节点的左节点的右子树上插入一个新节点导致90的平衡因子为2，因此这里我们就需要进行旋转，但是我们发现只进行一次右旋无法使这棵树符合AVL树的性质，因此我们这里就需要对这棵树进行双旋处理。这里一共分成两步进行：

  1. 以30为中心进行左旋，这样使60的左树接到了30的右边，这就使得这棵树符合左旋的条件，即相当于在90的左节点的左子树上插入了一个节点，这里我们就进行第二步
  2. 以60为中心进行右旋，详细步骤可以看上面

在节点90的左节点的右子树上插入一个新节点，我们将这种情况称为左右型，因此我们需要进行左右双旋

在旋转前，需要保存60这个节点的平衡因子，因为旋转结束后，需要根据该平衡因子去调整其他节点的平衡因子

void RotateLR(Node* parent)
{
	Node* subl = parent->_left;
	Node* sublr = subl->_right;

	int bf = sublr->_bf;
	RotateL(subl);
	RotateR(parent);

	if (bf == 1)
	{
		parent->_bf == 0;
		sublr->_bf = 0;
		subl->_bf = -1;
	}
	else if (bf == -1)
	{
		parent->_bf == 1;
		sublr->_bf = 0;
		subl->_bf = 0;
	}
	else if (bf == 0)
	{
		parent->_bf = sublr->_bf = subl->_bf = 0;
	}
	else
	{
		assert(false);
	}
}
2.2.3.4右左双旋

从上图我们可以看到在30这个节点的右节点的左子树上插入一个新节点导致30的平衡因子为2，因此这里我们就需要进行旋转，但是我们发现只进行一次左旋无法使这棵树符合AVL树的性质，因此我们这里就需要对这棵树进行双旋处理。这里一共分成两步进行：

  1. 以90为中心进行左旋，这样使60的右树接到了90的左边，这就使得这棵树符合右旋的条件，即相当于在30的右节点的右子树上插入了一个节点，这里我们就进行第二步
  2. 以30为中心进行左旋，详细步骤可以看上面

在节点30的右节点的左子树上插入一个新节点，我们将这种情况称为右左型，因此我们需要进行右左双旋

在旋转前，需要保存60这个节点的平衡因子，因为旋转结束后，需要根据该平衡因子去调整其他节点的平衡因子

void RotateRL(Node* parent)
{
	Node* subr = parent->_right;
	Node* subrl = subr->_left;

	int bf = subrl->_bf;
	RotateR(subr);
	RotateL(parent);

	if (bf == 1)
	{
		parent->_bf == -1;
		subrl->_bf = 0;
		subr->_bf = 0;
	}
	else if (bf == -1)
	{
		parent->_bf == 0;
		subrl->_bf = 0;
		subr->_bf = 1;
	}
	else if (bf == 0)
	{
		parent->_bf = subrl->_bf = subr->_bf = 0;
	}
	else
	{
		assert(false);
	}
}
2.2.3.5总结
插入位置状态操作
父节点的左节点的左子树左左型右旋
父节点的左节点的右子树左右型左右旋
父节点的右节点的右子树右右型左旋
父节点的右节点的左子树右左型右左旋

3、检查是否为AVL树

检查一棵树是否为AVL树不能直接去查它的平衡因子，这是因为你不确定平衡因子是否正确，且这棵树不一定存储了平衡因子。因此，要去检查这棵树是否为AVL树可以通过计算这棵树左子树和右子树高度的差值进行检验。

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;
}
bool _IsBalance(Node* root)
{
	if (root == nullptr)
	{
		return true;
	}
	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);

	if (rightHeight - leftHeight != root->_bf)
	{
		cout << "平衡因子异常" << endl;
		return false;
	}
	return abs(rightHeight - leftHeight) < 2
		&& _IsBalance(root->_left) && _IsBalance(root->_right); //每棵子树同样需要是AVL树
}

4、总代码

template<class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& val)
		:_left(nullptr), _right(nullptr)
		, _parent(nullptr), _val(val), _bf(0)
	{
	}
	AVLTreeNode* _left; //节点的左孩子
	AVLTreeNode* _right; //节点的右孩子
	AVLTreeNode* _parent; //节点的父亲

	T _val;
	int _bf; //该节点的平衡因子
};

template<class T>
class AVLTree
{
	typedef AVLTreeNode<T> Node;
public:
	AVLTree()
		:_root(nullptr)
	{
	}
	bool insert(const T& val)
	{
		if (_root == nullptr)
		{
			_root = new Node(val);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) //直到cur == nullptr循环结束
		{
			if (val > cur->_val)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (val < cur->_val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else //val == cur->_val，插入失败
			{
				return false;
			}
		}
		cur = new Node(val);
		if (cur->_val > parent->_val)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		while (parent)
		{
			if (parent->_left == cur)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			if (parent->_bf == 0) //bf为0，该树高度不变，不需要调整
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1) //bf为1或-1，该树高度改变，继续向上调整
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2) //bf为2或-2，该树高度改变，触发旋转
			{
				if (parent->_bf == 2 && cur->_bf == 1) //右右型
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1) //左左型
				{
					RotateR(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1) //左右型
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1) // 右左型
				{
					RotateRL(parent);
				}
				else //不属于以上则说明平衡因子异常
				{
					assert(false);
				}
				break; //旋转结束后，这棵树符合AVL树性质，结束循环

			}
			else //走到这里说明树的平衡因子异常，超出范围，该树的平衡因子调整错误，对代码重新检查
			{
				assert(false);
			}
		}
		return true;
	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	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;
	}
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		if (rightHeight - leftHeight != root->_bf)
		{
			cout << "平衡因子异常" << endl;
			return false;
		}
		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left) && _IsBalance(root->_right);
	}
	void RotateRL(Node* parent)
	{
		Node* subr = parent->_right;
		Node* subrl = subr->_left;

		int bf = subrl->_bf;
		RotateR(subr);
		RotateL(parent);

		if (bf == 1)
		{
			parent->_bf = -1;
			subrl->_bf = 0;
			subr->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subrl->_bf = 0;
			subr->_bf = 1;
		}
		else if (bf == 0)
		{
			parent->_bf = subrl->_bf = subr->_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 == 1)
		{
			parent->_bf = 0;
			sublr->_bf = 0;
			subl->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			sublr->_bf = 0;
			subl->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = sublr->_bf = subl->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateR(Node* parent)
	{
		Node* subl = parent->_left;
		Node* sublr = subl->_right;
		Node* pparent = parent->_parent;

		parent->_left = sublr;
		if (sublr)
			sublr->_parent = parent;
		subl->_right = parent;
		parent->_parent = subl;

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

	void RotateL(Node* parent)
	{
		Node* subr = parent->_right;
		Node* subrl = subr->_left;

		parent->_right = subrl;
		subr->_left = parent;

		Node* pparent = parent->_parent;
		parent->_parent = subr;

		if (subrl)
			subrl->_parent = parent;

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

	Node* _root;
};
平衡二叉搜索树之 AVL 树的模拟实现【C++】
2301_80058734的博客
10-05 2006
我上一篇文章提到的普通二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。AVL树就可以解决上述问题，让搜索树的查找效率在任何情况下都能稳定是O(logN)保证每个结点的左右子树高度之差的绝对值不超过1这样就能保证树中的节点分布接近满二叉树，高度非常接近logN【N为树中节点的个数】，进而让一次查找的效率为O(logN)为什么是保证每个结点的左右子树高度之差的绝对值不超过1，而不是保证左右子树高度一样呢？
C++——AVL树
二哈的博客
10-12 1610
AVL树的简介
C++：AVL树
hy____123的博客
09-08 4241
AVL。
【C++】AVL树
hsy1603914691的博客
05-05 2486
大家都愿意盲从，好像世界上最安全的事就是让自己消失在多数之中。 
【C++】AVL树实现
x_p96484685433的博客
05-11 1787
本文详细介绍了AVL树的概念、实现及其自平衡机制。AVL树是一种自平衡二叉搜索树，通过控制左右子树的高度差来保证查找效率。文章首先介绍了AVL树的基本概念和平衡因子的作用，接着详细讲解了AVL树的插入操作，包括平衡因子的更新和四种旋转操作（右单旋、左单旋、左右双旋、右左双旋）的实现。此外，文章还介绍了AVL树的查找、平衡检测和删除操作，并通过代码示例展示了如何实现这些功能。
Python 优雅解析 Excel：从原生行列到强类型对象的三层数据结构演进
asdzx67的博客
06-15 325
对于数据结构固定、业务逻辑复杂的 Excel 场景，字典结构的弱类型特性会带来类型混乱、无代码提示、无法封装业务逻辑等问题。定义业务实体类，将每行 Excel 数据映射为实体对象，实现强类型约束、自动代码补全、自定义数据校验和业务方法封装。从「二维列表数字索引」到「字典语义取值」，再到「自定义对象强类型封装」，三层数据结构的迭代，本质是代码从「机器思维」向「业务思维」的升级。简单场景无需过度设计，通用场景优先字典列表，工程化复杂场景首选自定义实体对象。
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 262
超详细的Floyd算法教程，一看就懂！
多线程编程（一）
m0_62591054的博客
06-16 203
编译时：需加上 -lpthread，链接上对应的线程支持库。
【C++ 排序算法】十大经典排序算法原理深度解析
最新发布
CHHH_HHH的博客
06-20 223
本文系统介绍了多种排序算法，分为比较排序和非比较排序两大类。重点讲解了插入排序（直接插入、希尔排序）、选择排序（直接选择、堆排序）、交换排序（冒泡、快速排序）和归并排序的原理、代码实现及性能分析，包括时间复杂度、空间复杂度和稳定性。特别对快速排序的Hoare法和前后指针法进行了详细说明，并提出了三数取中和小规模数据使用插入排序的优化策略。最后总结了各算法的关键特性对比表，指出不同算法在不同场景下的适用性。非比较排序部分简要介绍了计数排序的思想和应用限制。
算法与数据结构---二叉搜索树(BST)
MzKyle的博客
06-17 1372
二叉搜索树（BST）是一种基于二叉树的有序数据结构，核心特性是左子树节点值小于根节点，右子树节点值大于根节点。本文系统介绍了BST的核心概念与操作实现： 基本定义：BST通过"左小右大"的规则维护有序性，所有操作复杂度为O(h)，h为树高。平衡时h≈log₂n，退化为链表时h=n。 关键操作： 查找：根据值比较选择左右子树路径 插入：在适当位置创建新节点 删除：处理三种情况（无子节点、单子节点、双子节点），最复杂的是用中序前驱/后继替代被删节点 重要特性：中序遍历BST会得到有序序列，这是BST的核心性质。
Python 五大核心数据结构完全指南：列表(List)、字符串(String)、元组(Tuple)、集合(Set)、字典(Dictionary)
小赵的博客
06-15 307
本文系统梳理了 Python 五大核心数据结构——列表、字符串、元组、集合、字典，涵盖各自定义特点、索引切片规则及常用操作方法。列表有序可变，字符串不可变但支持索引，元组不可修改，集合无序去重，字典存储键值对。通过对比表格总结适用场景，助力读者稳固编程基础，提升数据处理能力。
从kubectl学Visitor模式：如何优雅处理多态数据结构的遍历
java_cj的专栏
06-15 283
kubectl的Visitor模式解析 本文通过配置同步工具开发中的实际问题，引出了Visitor设计模式的应用场景。该模式的核心思想是将数据结构与操作逻辑解耦，使新增操作无需修改原有代码。 在kubectl源码中，Visitor模式被巧妙用于处理多种数据源（文件/HTTP/Git等）： 统一接口：定义Visitor接口和Info数据结构，屏蔽底层差异 多态实现：FileVisitor处理文件，URLVisitor处理HTTP请求，统一委托给StreamVisitor解析 扩展性：新增数据源只需实现Visi
【C++】数据结构之图的基本概念
L_0907的博客
06-17 266
本文系统介绍了并查集和图两种重要数据结构。并查集部分详细阐述了其基本概念、逻辑结构（森林表示）与物理存储（数组实现），重点讲解了路径压缩和按秩合并两种优化策略，并通过省份数量、等式方程等LeetCode题目展示了实际应用。图结构部分明确定义按秩合并顶点、边、有向/无向图等核心概念，比较了邻接矩阵和邻接表两种存储方式的优劣，给出了完整的C++实现代码。全文通过理论讲解结合代码实践，为后续学习图的遍历、最小生成树等算法奠定了坚实基础。
数据结构 图（概念篇）
youren_7715的博客
06-14 772
图（Graph）是由顶点（Vertex）边（Edge）组成的非线性数据结构，用于表示实体（顶点）及其关系（边）。数学上表示为 ( G = (V, E) )，其中 ( V ) 是顶点集合，( E ) 是边集合。
C/C++ 数据结构（九）深搜广搜
2301_80252792的博客
06-17 565
本文系统介绍了迷宫寻路算法的核心实现方法。重点分析了深度优先搜索(DFS)和广度优先搜索(BFS)两种算法，分别基于栈和队列实现。DFS采用"一条路走到底"的策略，适用于快速找到可行路径；BFS通过分层扩散确保找到最短路径。文章详细展示了两种算法的代码实现，包括迷宫表示、移动方向处理、越界判断等关键环节。同时探讨了路径记录、拾取所有金币等拓展场景，并比较了两种算法在时间复杂度、空间复杂度和适用场景上的差异。最后简要提及了A*算法等进阶内容，为游戏开发和路径规划提供了实用指导。
C/C++ 数据结构（四）链表与STL容器
2301_80252792的博客
06-13 549
本文系统梳理了C++链表与STL容器的核心知识点：1. 链表设计：对比带头/不带头结点的实现差异，；2. STL容器：详解vector/list/forward_list的底层结构、特性差异及选型策略；3. 迭代器机制：阐释其指针封装本质、遍历方式及不同容器的失效规则；4. 关键组件：包括仿函数实现自定义排序、模板类的类型约束要求、C++11的emplace优化等；5. 实践要求：提出手写带头尾结点的双向链表模板类，需封装迭代器并处理深拷贝问题。
数据结构-栈和队列
2301_79176091的博客
06-14 271
本文介绍了栈和队列这两种线性表结构的定义、实现及应用。栈遵循后进先出(LIFO)原则，可使用数组或链表实现，动态栈通过扩容支持高效操作。队列遵循先进先出(FIFO)原则，通常用链表实现更优，包含初始化、入队、出队等基本操作。此外还介绍了循环队列的概念及实现方法，包括判空判满逻辑和环形结构处理。最后提供了栈和队列的常见面试题及概念选择题，涵盖括号匹配、相互实现等典型问题。文章通过代码示例详细说明了各种操作的实现原理，包括动态扩容、环形索引计算等关键技术点。
数据结构 | 八大排序
2403_84469788的博客
06-14 233
在日常编程刷题、程序开发的过程中，排序是我们最高频使用的基础算法之一。我们经常会直接调用语言库自带的排序函数快速实现数据排序，但绝大多数人都只知其用、不知其理。看似简单的排序操作，背后蕴含着循环迭代、分治递归、贪心、分组增量、堆结构、桶分配等多种核心算法思想。八大经典排序算法是数据结构的重中之重，也是面试、算法学习的核心考点。本文将系统性梳理八大排序算法的整体分类、核心原理与执行思路，帮助大家建立完整的排序算法知识体系，清晰区分不同排序的特性与适用场景。在排序算法的选择上，总结了三个关键点：第一，
我的数据结构1
ChaoZiLL的博客
06-17 274
首先将数组的数据全部进行异或(^)操作，得到一个值a，再将该值与取负(原码取反+1)，得到(-a),将a与(-a)进行与(&)运算得到key值，key值就意味着该组数据中可以从右往左边数第几位为1，在使用key值作为分组的桥梁，是的同一组内的不同值再进行一次异或(^)操作，最后留下来的数就是需要的答案了；礼盒中除了一款撞色搭配的袜子，每种颜色的袜子均有两只。第一种：使用计数排序的思路从而找出缺失的数，但这样的空间复杂度是O(N)，因为要遍历数组，时间复杂度也是O(N)；的所有整数，但其中缺了一个。
2026.6.10 数据结构 二叉树
RH231211的博客
06-14 213
/5.如果是栈S1不空，栈S2空，则此时需要将栈S1里面的节点依次取出打印，并顺。//6.如果是栈S2不空，栈S1空，则此时需要将栈S2里面的节点依次取出打印，并顺。//5.如果是栈S1不空，栈S2空，则此时需要将栈S1里面的节点依次取出打印，并顺。//6.如果是栈S2不空，栈S1空，则此时需要将栈S2里面的节点依次取出打印，并顺。// 带着将取出处理的每一个节点的两个孩子都按照”先右再左”的顺序进行判定，如。// 带着将取出处理的每一个节点的两个孩子都按照”先右再左”的顺序进行判定，如。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值