【数据结构】AVL树的实现

最新推荐文章于 2025-05-20 22:15:23 发布
最新推荐文章于 2025-05-20 22:15:23 发布
阅读量1.1k 收藏 10
点赞数 16
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80541270/article/details/148062289
版权

文章目录

1. AVL 的概念

  • AVL树是最先发明的自平衡二叉查找树，AVL是一颗空树，或者具备下列性质的二叉搜索树：它的左右子树都是AV树，且左右子树的高度差的绝对值不超过1。AVL树是一颗高度平衡搜索二叉树，通过控制高度差去控制平衡。
  • AVL树得名于它的发明者G.M.Adelson-Velsky和E.M. Landis是两个前苏联的科学家，他们在1962年的论文《An algorithm for the organization of information》中发表了它。
  • AVL树实现这里我们引入一个平衡因子(balancefactor)的概念，每个结点都有一个平衡因子，任何结点的平衡因子等于右子树的高度减去左子树的高度，也就是说任何结点的平衡因子等于0/1/-1，AVL树并不是必须要平衡因子，但是有了平衡因子可以更方便我们去进行观察和控制树是否平衡，就像一个风向标一样。
  • AVL树整体结点数量和分布和完全二叉树类似，高度可以控制在logN，那么增删查改的效率也可以控制在O(logN），相比二叉搜索树有了本质的提升。

在这里插入图片描述
在这里插入图片描述

2. AVL 树的实现

2.1 AVL 树的结构

相比于二叉搜索树，AVL 因为要控制左右子树高度差，所以引入了 平衡因子，而为了更行平衡因子，它又引入了一个 父指针。

// 节点结构
template<class K, class V>
struct AVLTreeNode
{
	// 需要parent指针，后续更新平衡因⼦可以看到
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf; // balance factor
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{
	}
};

// AVL树
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	// ...
private:
	Node* _root = nullptr;
};

2.2 AVL 树的插入

2.2.1 AVL 树插入一个值的大致过程

  1. 插入一个值按二叉搜索树规则进行插入。
  2. 新增结点以后，只会影响祖先结点的高度，也就是可能会影响部分祖先结点的平衡因子，所以更新从新增结点->根结点路径上的平衡因子，实际中最坏情况下要更新到根，有些情况更新到中间就可以停止了，具体情况我们下面再详细分析。
  3. 更新平衡因子过程中没有出现问题，则插入结束
  4. 更新平衡因子过程中出现不平衡，对不平衡子树旋转，旋转后本质调平衡的同时，本质降低了子树的高度，不会再影响上一层，所以插入结束。

2.2.2 平衡因子更新

更新原则：

  • 平衡因子＝右子树高度-左子树高度
  • 只有子树高度变化才会影响当前结点平衡因子。
  • 插入结点，会增加高度，所以新增结点在parent的右子树，parent的平衡因子++，新增结点在parent的左子树，parent平衡因子–
  • parent所在子树的高度是否变化决定了是否会继续往上更新

更新停止条件：

  • 更新后parent的平衡因子等于0，更新中parent的平衡因子变化为-1->0或者1->0，说明更新前parent子树一边高一边低，新增的结点插入在低的那边，插入后parent所在的子树高度不变，不会影响parent的父亲结点的平衡因子，更新结束。
  • 更新后parent的平衡因子等于1或-1，更新前更新中parent的平衡因子变化为0->1或者0->-1，说明更新前parent子树两边一样高，新增的插入结点后，parent所在的子树一边高一边低，parent所在的子树符合平衡要求，但是高度增加了1，会影响parent的父亲结点的平衡因子，所以要继续向上更新。
  • 更新后parent的平衡因子等于2或-2，更新前更新中parent的平衡因子变化为1->2或者-1->-2，说明更新前parent子树一边高一边低，新增的插入结点在高的那边，parent所在的子树高的那边更高了，破坏了平衡，parent所在的子树不符合平衡要求，需要旋转处理，旋转的目标有两个：1、把parent子树旋转平衡。2、降低parent子树的高度，恢复到插入结点以前的高度。所以旋转后也不需要继续往上更新，插入结束。

更新到10结点，平衡因子为2，10所在的子树已经不平衡，需要旋转处理
在这里插入图片描述
更新到中间结点，3为根的子树高度不变，不会影响上一层，更新结束
在这里插入图片描述
最坏更新到根停止
在这里插入图片描述
插入其实就是在二叉搜索树的插入上增加了更新平衡因子机制，而更新平衡因子时可能需要旋转操作，旋转操作后面在讲。

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->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(kv);
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = 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);
			}
			else
			{
				assert(false);
			}
			
			break;
		}
		else
		{
			assert(false);
		}
	}
	return true;
}

2.3 旋转

2.3.1 旋转的原则

  1. 保持搜索树的规则
  2. 让旋转的树从不满足变平衡，其次降低旋转树的高度

旋转总共分为四种，左单旋/右单旋/左右双旋/右左双旋。

2.3.2 右单旋

触发条件

  • 失衡节点A的左子树高度 - 右子树高度 = 2（即平衡因子为-2）。
  • A的左孩子B的平衡因子为-1（即B的左子树更高，形成LL型失衡）。

操作步骤

  1. 提升左孩子B为新的根节点。
  2. 原根节点A成为B的右孩子。
  3. 处理B的右子树：如果B原本有右子树BR，将其作为A的新左子树。
  4. 更新平衡因子：旋转后，A和B的平衡因子均变为0。
失衡结构：
     A (BF=-2)
    /
   B (BF=-1)
  /
 C

右旋过程：
1. 将B提升为根，A成为B的右孩子：
       B
      / \
     C   A
2. 原B的右子树（假设为空）无需处理。
最终平衡因子：B(BF=0), A(BF=0)

原结构（LL失衡）：
      parent (bf=-2)
      /
    subL (bf=-1)
    /   \
   X   subLR

旋转后：
    subL (bf=0)
    /   \
   X   parent (bf=0)
        /
     subLR

代码：

	void RorateR(Node* parent)
	{
		// 1. 获取左孩子subL及其右子树subLR
		Node* subL = parent->_left;  // 保存左子树根节点subL
		Node* subLR = subL->_right;  // 保存subL的右子树

		// 2. 调整parent和subLR的父子关系
		parent->_left = subLR;		 // 将subLR挂到parent的左侧
		if (subLR)					 // 若subKR存在，更新它的父指针
			subLR->_parent = parent;

		// 3. 调整subL和parent的父子关系
		Node* pParent = parent->_parent; // 记录原parent的父节点（可能为空）
		subL->_right = parent;			 // 将parent作为subL的右孩子
		parent->_parent = subL;			 // 更新parent的父节点

		// 4. 将subL连接到原parent的父节点（整棵树的连接）
		if (parent == root)				 // 若parent是根节点
		{
			_root = subL;				 // 更新根节点为subL
			subL->_parent = nullptr;	 // 新根节点的父指针置空
		}
		else
		{
			if (pParent->_left == parent) // 判断原parent是左孩子还是右孩子
				pParent->_left = subL;    // 将subL挂到原祖父的左
			else
				pParent->_right = subL;   // 将subL挂到原祖父的右
			subL->_parent = pParent;	  // 更新subL的父指针
		}

		// 更新平衡因子
		subL->_bf = 0;
		parent->_bf = 0;
	}

2.3.3 左单旋

触发条件

  • 失衡节点A的平衡因子为+2。
  • A的右孩子B的平衡因子为+1（形成RR型失衡）。

操作步骤

  1. 提升右孩子B为新的根节点。
  2. 原根节点A成为B的左孩子。
  3. 处理B的左子树：如果B原本有左子树BL，将其作为A的新右子树。
  4. 更新平衡因子：A和B的平衡因子均变为0。
失衡结构：
   A (BF=+2)
    \
     B (BF=+1)
      \
       C

左旋过程：
1. 将B提升为根，A成为B的左孩子：
       B
      / \
     A   C
最终平衡因子：B(BF=0), A(BF=0)


原结构（LL失衡）：
      parent (bf=+2)
         \
        subR (bf=+1)
        /   \
     subRL   X
旋转后：
        subR (bf=0)
       /   \
  parent    X
     \
    subRL

代码就和右单旋刚好相反，不做过多解释：

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

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

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

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

2.3.4 左右双旋

为什么需要双旋转？

  • 单旋转无法解决之字型失衡：例如在LR失衡中，失衡路径是左→右，直接右旋会破坏结构，需先通过左旋将其转化为LL型。
  • 平衡因子动态调整：双旋转后需根据中间节点的原始平衡因子重新计算各节点的平衡因子。

先通过单旋调整成上面可以单旋的类型，再通过单旋解决问题。

触发条件

  • 失衡节点A的平衡因子为-2。
  • A的左孩子B的平衡因子为+1（形成LR型失衡，即B的右子树更高）。

操作步骤

  1. 先对B左旋（转化为LL型）：
    • 将B的右孩子C提升为A的新左孩子。
    • B成为C的左孩子，C的原左子树成为B的右子树。
  2. 再对A右旋：
    • 将C提升为根，A成为C的右孩子。
  3. 更新平衡因子：
    • 若C原平衡因子为0，则A和B均变为0。
    • 若C原平衡因子为+1，则A(BF=0), B(BF=-1), C(BF=0)。
    • 若C原平衡因子为-1，则A(BF=+1), B(BF=0), C(BF=0)。
初始失衡结构：
       A (BF=-2)
      /
     B (BF=+1)
      \
       C (BF=0)

步骤1：对B左旋后：
       A
      /
     C
    /
   B

步骤2：对A右旋后：
       C
      / \
     B   A
平衡因子：C(BF=0), B(BF=0), A(BF=0)

初始结构（LR失衡）
       parent (bf=-2)
      /
    subL (bf=+1)
       \
      subLR (bf=-1/0/+1)
      /   \
     CL   CR

旋转后结构
         subLR (bf=0)
        /      \
    subL       parent
    /  \       /   \
   CL   CR_L  CR_R  CR

	void RotateLR(Node* parent)
	{
		// 1. 获取相关节点
		Node* subL = parent->_left; // parent的左孩子
		Node* subLR = subL->_right; // subL的右孩子（subLR，即失衡的中间节点）
		int bf = subLR->_bf;		// 保存subLR的原始平衡因子

		// 2. 双旋操作
		RotateL(parent->_left);		// 先对subL进行左旋（将subLR提升为subL的位置）
		RotateR(parent);			// 再对parent进行右旋（将subLR提升为根）

		// 3. 根据subLR的原始平衡因子调整平衡因子
		if (bf == -1)				// subLR的左子树更高
		{
			subLR->_bf = 0;			// 新根subLR平衡因子归零
			subL->_bf = 0;			// 原左子树subL平衡因子归零
			parent->_bf = 1;		// 原根parent右子树更高（平衡因子+1）
		}
		else if (bf == 1)			// subLR的右子树更高
		{
			subLR->_bf = 0;			// 新根subLR平衡因子归零
			subL->_bf = -1;			// 原左子树subL左子树更高（平衡因子-1）
			parent->_bf = 0;		// 原根parent平衡因子归零
		}
		else if (bf == 0)			// subLR左右子树等高
		{
			subLR->_bf = 0;			// 所有相关节点平衡因子归零
			subL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

2.3.5 右左双选

触发条件

  • 失衡节点A的平衡因子为+2。
  • A的右孩子B的平衡因子为-1（形成RL型失衡，即B的左子树更高）。

操作步骤

  1. 先对B右旋（转化为RR型）：
    • 将B的左孩子C提升为A的新右孩子。
    • B成为C的右孩子，C的原右子树成为B的左子树。
  2. 再对A左旋：
    • 将C提升为根，A成为C的左孩子。
  3. 更新平衡因子：
    • 若C原平衡因子为0，则A和B均变为0。
    • 若C原平衡因子为+1，则A(BF=-1), B(BF=0), C(BF=0)。
    • 若C原平衡因子为-1，则A(BF=0), B(BF=+1), C(BF=0)。
初始失衡结构：
   A (BF=+2)
    \
     B (BF=-1)
    /
   C (BF=0)

步骤1：对B右旋后：
   A
    \
     C
      \
       B

步骤2：对A左旋后：
       C
      / \
     A   B
平衡因子：C(BF=0), A(BF=0), B(BF=0)

初始结构（RL失衡）
       parent (bf=+2)
         \
        subR (bf=-1)
        /
     subRL (bf= -1/0/+1)
     /   \
    CL   CR

旋转后结构
         subRL (bf=0)
        /      \
    parent     subR
    /   \      /   \
   CL  CR_L  CR_R  CR

和左右双旋相反：

	void RotateRL(Node* parent)
	{
		// 1. 获取相关节点
		Node* subR = parent->_right;
		Node* subRL = subR->_left;	// subR的左孩子（subRL，即失衡的中间节点）
		int bf = subRL->_bf;		// 保存subRL的原始平衡因子

		// 2. 双旋转操作
		RotateR(parent->_right);	// 先对subR进行右旋（将subRL提升为subR的位置）
		RotateL(parent);			// 再对parent进行左旋（将subRL提升为根）

		// 3. 根据subRL的原始平衡因子调整平衡因子
		if (bf == 0)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

2.4 AVL 树的查找

通过二叉搜索树的规则进行查找就是了，这个不难

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

2.5 AVL 树平衡检测

我们实现的AVL树是否合格，我们通过检查左右子树高度差的的程序进行反向验证，同时检查一下结点的平衡因子更新是否出现了问题。

这里简单提一下，因为 AVL 树是棵树，所以我们常见的遍历方式是通过递归调用，而这种 递归调用 直接暴露给用户显然不太合适，所以我们这里选择暴露一个公有接口，提供简洁的访问入口，隐藏内部实现细节，再通过私有辅助函数去完成内部实现细节。这种写法属于 包装器模式 的一种应用，有兴趣的自己去搜下。

class AVLTree
{
public:
	int Height()
	{
		return _Height(_root);
	}
	bool IsBalanceTree()
	{
		return _IsBalanceTree(_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 _IsBalanceTree(Node* root)
	{
		// 空树也是AVL树
		if (nullptr == root)
			return true;
		// 计算pRoot结点的平衡因子：即pRoot左右子树的高度差
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		int diff = rightHeight - leftHeight;

		// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
		// pRoot平衡因子的绝对值超过1，则一定不是AVL树
		if (abs(diff) >= 2)
		{
			cout << root->_kv.first << "高度差异常" << endl;
			return false;
		}

		if (root->_bf != diff)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
数据结构 - AVL树
TPON的博客
11-10 880
AVL树 - 平衡二叉搜索树
数据结构avl树实现
03-18
AVL树是数据结构中的一个重要组成部分，它通过保持树的平衡来优化查找、插入和删除操作的性能。理解和掌握AVL树的平衡条件、旋转操作以及插入和删除的处理方法，对于深入理解数据结构和算法具有重要意义。在实际应用...
数据结构——AVL树
未知陨落的博客
11-16 2467
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查 找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度
数据结构：AVL树
decade777555的博客
03-07 1625
两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
数据结构 —— AVL树
hedhjd的博客
10-30 2027
目录1. AVL的概念2.AVL树的结构3.AVL树的插入3.1 平衡因子更新4. 旋转4.1 旋转的原则 4.2 右单旋4.2.1 右单旋代码实现4.3 左单旋4.3.1 左单旋代码实现4.4 左右双旋4.4.1 左右双旋代码实现4.5 右左双旋​编辑 4.5.1 右左双旋代码实现5. AVL树的判断6. AVL树的查找 图1 图2图3图4图5 图6 图7 图8 图9 完结撒花~
数据结构—AVL树
Menior_的博客
12-10 840
按照平衡因子的规则，如果新节点插入到了父节点的左侧，那么父节点的平衡因子-1，如果新节点插入到了父节点的右侧，那么父节点的平衡因子+1；以上，便是新增节点的父节点平衡因子可能的变化情况。在调整失衡的AVL树时，我们需要频繁的访问父节点，所以在AVL树中我们需要使用三叉链，因此AVL树的节点除了包含左右子节点的指针，还需要一个指向父节点的指针。AVL树的删除可以使用二叉搜索树的方式，先用二叉搜索树的方式来对目标节点进行删除，再判断是否失衡，如果失衡则进入旋转操作，旋转后得到的新AVL树就是删除后的AVL树。
【数据结构】AVL树
Hello_World_213的博客
11-07 1598
数据结构 -- AVL树详解与代码实现: 更新平衡因子+四种旋转, 检验AVL树, 以及AVL树的效率
数据结构：AVL树（C++实现）
2301_79171011的博客
07-27 1061
本文延续前文二叉搜索树，开启平衡二叉搜索树的篇章。在这一篇章中，我们将重点关注AVL树，这是一种严格平衡的二叉搜索树。AVL树通过精巧的平衡机制，确保了树的高度始终保持在对数级别，从而大大提升了查找、插入和删除操作的性能。本文将详细介绍AVL树的原理、平衡调整方法以及性能分析。通过对AVL树的学习，我们不仅深入理解了平衡二叉搜索树的原理和操作，还掌握了如何通过旋转来维护树的平衡性。这一过程加深了我们对平衡二叉树重要性的认识。
数据结构——AVL树的实现
2301_81390458的博客
01-20 3913
Hello，大家好，这一篇博客我们来讲解一下数据结构中的AVL树这一部分的内容，AVL树属于是数据结构的一部分，顾名思义，AVL树是一棵特殊的搜索二叉树，我们接下来要讲的这篇博客是建立在了解搜索二叉树这个知识点的基础之上的，因此，我在这里建议大家可以先去看看我之前写过的那片有关搜索二叉树内容的博客，为了方便大家寻找，链接就放到下面了：搜索二叉树，效率的进一步upgrate！-CSDN博客Hello，大家好，我们关于C++的大部分语法知识就可以宣告结束了，不知道聪明的你有没有掌握扎实呢？
【数据结构】AVL树（万字超详细 附动图）
Eristic0618的博客
04-23 9342
本篇文章围绕数据结构中的AVL树展开讲解，包含AVL树的插入、旋转、验证等内容，万字讲解搭配自制动图
【数据结构】AVLTree实现详解
EWIAW_ilove的博客
06-08 1557
在二叉搜索树的博客中，我们提到了，当插入的数据有序或者接近有序的时候，二叉搜索树会退化成单支树，导致其效率变低，所以为了解决这种情况，于是我们提出了AVLTree，即二叉平衡搜索树。如下图就是一棵二叉搜索树退化成的单支树。那么AVLTree又是如何实现使二叉树搜索树不会退化成单支树的呢，它又是如何保证效率的呢？因为AVLTree严格的要求左右子树的高度差不能大于1，且每一棵子树也一样。如下图所示。
数据结构_Python实现_AVL树_学习笔记库_1741867885.zip
03-15
Python实现的AVL树则是用Python语言编写的数据结构，它保持了树的平衡状态，使得基本的动态集合操作如查找、插入、删除的时间复杂度都是O(log n)，从而克服了普通的二叉搜索树在最坏情况下可能退化成链表，导致操作...
华科数据结构AVL树课设
03-11
在这个【课程设计】中，学生被要求基于AVL树实现一个【Set集合】。Set集合是一种不包含重复元素的数据结构，支持插入、删除和查询等基本操作。在AVL树上实现Set集合，可以利用AVL树的特性来快速完成这些操作，比如...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种...
Redis——底层数据结构
2401_83176717的博客
05-16 1539
Redis采用了链式哈希（拉链法）来解决哈希冲突，这与Java中的hashMap是相似的。哈希表的底层其实是数组，通过计算对象的哈希值对数组长度取余来确定索引位置，可以在O1的时间获取数据。
Python的collections模块：数据结构的百宝箱
最新发布
kymppcds的博客
05-20 701
Counter用于统计可迭代对象中元素出现的频次。#统计次数#输出为：#使用update函数添加另一个可迭代对象，继续统计次数#输出为UserDict是创建自定义字典类的基类。raise NotImplementedError("删除操作不被允许")# 尝试删除键会引发错误继承UserDict并覆盖方法，可定制符合需求的字典类。类似UserDict，UserList用于创建自定义列表类。raise ValueError("只能添加整数")# 尝试添加非整数会引发错误。
嵌入式开发学习（第二阶段 C语言基础）
qq_58814618的博客
05-16 1496
内容提要：冒泡排序、二维数组
数据结构day3
c6lala的博客
05-17 377
gcc -g main.c linklist.c // 对两个.c文件进行编译,生成 a.out 文件gdb a.out //调试可执行文件 a.outb linklist.c:36 // 在该.c文件第 36 行设置断点r // 运行程序,但会在断点前停下n //执行下一步。
算法与数据结构：位运算与快速幂
Cachel Wood的博客
05-20 724
本文介绍了位运算和快速幂算法。位运算是基于二进制的运算，包括与、或、异或、取反、左移和右移六种操作，适用于计算机中的二进制数据处理。快速幂算法则是一种高效的指数运算方法，通过将指数转化为二进制形式，减少乘法次数，从而将时间复杂度从O(x)降低到O(log(x))。文章通过具体例子和代码展示了如何实现快速幂算法，强调了其在计算大指数时的效率优势。
深入浅出AVL树的数据结构实现
这使得AVL树在处理动态数据集时更为高效。 ### AVL树的平衡因子 平衡因子是决定AVL树平衡的关键因素。对于AVL树中的任何一个节点，其平衡因子是其左子树的高度减去右子树的高度。在AVL树中，节点的平衡因子只可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值