数据结构：AVL？撕就完了

最新推荐文章于 2024-09-03 20:29:47 发布
最新推荐文章于 2024-09-03 20:29:47 发布
阅读量187 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mlgseminent/article/details/121505043
版权
本文详细介绍了AVL树的数据结构，包括Node结点定义，通过BST实现的insert和remove方法，以及关键的calBalance和rotate函数。着重展示了如何通过迭代方式处理插入和删除操作，以及如何通过旋转保持树的平衡特性。
摘要由CSDN通过智能技术生成

写一棵AVL

一、Node结点定义

可以自行设计
自己在这里仅增加了一项——平衡因子的记录，用于旋转时判断类型

public class Node {
	int val;
	int balance; // 左子树高 - 右子树高
	Node left;
	Node right;
	
	public Node(int val) {
		this.val = val;
	}
	
	public Node(int val, Node left, Node right) {
		this.val = val;
		this.left = left;
		this.right = right;
	}
}

二、逐步实现AVL

先定义一个类，定义出root结点，
此外，还定义了个保护结点，由于AVL旋转后根结点可能改变，root结点为其左儿子
以及一个HashSet用以O(1)判断防重，空间换时间

public class MyAVL {
	Node root;
	private Node protect; // 由于AVL需要旋转，则设置一个保护结点
	private static final int protectVal = 0; 
	private HashSet<Integer> set;

	public MyAVL(int rootVal) {
		this.root = new Node(rootVal);
		this.protect = new Node(protectVal, this.root, null);
		this.set = new HashSet<>();
		this.set.add(rootVal);
	}
	
	public MyAVL() {
		this.protect = new Node(protectVal);
		this.set = new HashSet<>();
	}
}

1、BST

1）insert(int insertVal)方法

可以先练习这道算法题：LeetCode 701 二叉搜索树中的插入操作

  • HashSet防重，则不会出现相同的val
  • 若insertVal < curNode.val则往左子树走
  • 若insertVal > curNode.val则往右子树走

递归实现：代码简洁，可读性高，易于维护
迭代实现：空间发杂度较低

这里自己使用了迭代实现，并且区分了内部外部方法

public boolean insert(int insertVal) {
	if (this.set.contains(insertVal))
		return false;
	return insert(this.protect, this.root, insertVal, true);
}

// @param fa 此次插入结点的父结点，由于是迭代实现，需要记录父结点来实现插入
// @param cur 用于找到需要插入的位置，当cur为null时则找到了
// @param insertLeft 此次插入结点是其父结点的哪个儿子？初始假设为左儿子
private boolean insert(Node fa, Node cur, int insertVal, boolean insertLeft) {
	// 找到插入位置
	while (cur != null) {
		fa = cur;
		if (cur.val < insertVal) {
			cur = cur.right;
			insertLeft = false;
		} else {
			cur = cur.left;
			insertLeft = true;
		}
	}
	// 插入操作
	if (insertLeft) fa.left = new Node(insertVal);
	else fa.right = new Node(insertVal);
	// 加入set
	this.set.add(insertVal);
	// 若初始化没有定义root
	if (this.root == null)
		this.root = this.protect.left;
}

2）remove(int removeVal)方法

可以先练习这道算法题：LeetCode 450 删除二叉搜索树中的结点

  • HashSet判断removeVal是否为有效的值
  • 若removeVal < curNode.val则往左子树走
  • 若removeVal > curNode.val则往右子树走
  • 若removeVal == curNode.val则进行删除：
  • 1、欲删除结点左右子树均空：直接删除
  • 2、欲删除结点左右子树有一个为空：删除并以其非空子树取代
  • 3、欲删除结点左右子树均非空：将当前结点替换为其前驱或后驱，并删除其前驱或后驱

递归实现：代码简洁，可读性高，易于维护
迭代实现：空间发杂度较低

这里自己仍使用迭代实现，以后驱代替欲删除结点，但仅是值的替换

public boolean remove(int removeVal) {
	if (!set.contains(removeVal))
		return false;
	return remove(this.protect, this.root, removeVal, true); 
}
	
// 其形参解释与insert()方法相同
// @param deleteLeft 初始时假设删除的是左节点
private boolean remove(Node fa, Node cur, int removeVal, boolean deleteLeft) {
	// 找到删除位置
	while (cur.val != removeVal) {
		fa = cur;
		if (cur.val < removeVal) {
			cur = cur.right;
			deleteLeft = false;
		} else {
			cur = cur.left;
			deleteLeft = true;
		}
	}
	// 删除操作
	if (cur.left == null && cur.right == null) { // 都null
		if (deleteLeft) fa.left = null;
		else fa.right = null;
	} else if (cur.left == null || cur.right == null) { // 一边null
		if (deleteLeft) fa.left = cur.left == null ? cur.right : cur.left;
		else fa.right = cur.left == null ? cur.right : cur.left;
	} else { // 都不null，找后驱，此处是修改结点的值
		Node nextDelete = cur.right;
		fa = cur; // 此时fa的定义修改为：nextDelete的父结点
		while (nextDelete.left != null) {
			fa = nextDelete;
			nextDelete = nextDelete.left;
		}
		if (fa.right == nextDelete) // 特殊情况：欲删除结点的后驱就是cur的右儿子
			fa.right = nextDelete.right;
		else // 一般情况：欲删除结点的后驱是 欲删除结点右儿子 的最左儿子
			fa.left = nextDelete.right;
		cur.val = nextDelete.val;
	}
	// 从set移除
	this.set.remove(removeVal);
}

2、计算平衡因子函数calBalance()

可以先练习这道算法题：LeetCode 110 平衡二叉树

1、对于每一次计算而言，只需要旋转第一个不平衡结点即可，所以设置了全局变量rotateFinished来保证只需旋转一次，并且可用于提前返回
2、对于左右子树高度差大于1的结点则要调取rotate()方法
3、对于形参fa_cur_isleftChild，由于rotate()可能导致当前结点的结构变化，所以需要存储一下，当前结点cur与父结点fa的关系
4、另外，由于旋转完毕之后root可能发生了改变，所以要重新获取root

// 做好旋转前的准别工作，并调用计算平衡因子的方法
private void calBalanceInit() {
	this.rotateFinished = false;
	calBalance(this.protect, this.root, true);
}
	
// @param fa_cur_isleftChild 反映了cur是否是fa的左儿子
private int calBalance(Node fa, Node cur, boolean fa_cur_isleftChild) {
	if (cur == null)
		return 0;
	int l = calBalance(cur, cur.left, true);
	int r = calBalance(cur, cur.right, false);
	if (Math.abs(l - r) > 1) {
		if (fa_cur_isleftChild) fa.left = rotate();
		else fa.right = rotate();
		// 由于旋转完毕之后root可能发生了改变，所以要重新赋予root
		this.root = this.protect.left;
	}
	cur.balance = l - r;
	return Math.max(l, r) + 1;
}

3、旋转方法rotate()

1）LL，RR的单旋

LL
RR

LL：第一个L指不平衡结点的左子树高度大于右子树高度，第二个L指其左子结点的左子树高度大于右子树高度
RR：第一个R指不平衡结点的右子树高度大于左子树高度，第二个R指其右子节点的右子树高度大于左子树高度

在这里插入图片描述
RR
于是rotate()函数便设计了四个形参

// @param cur_child_isLeft 不平衡结点是否是左子树不平衡，或者是child结点是否是cur的左儿子
// @param child_isLeft child结点是否是左子树高度大于右子树
private Node rotate(Node cur, Node child, 
									boolean cur_child_isLeft, boolean child_isLeft) {
	if (cur_child_isLeft && child_isLeft) { // LL
		cur.left = child.right;
		child.right = cur;
	} else if (!cur_child_isLeft && !child_isLeft) { // RR
		cur.right = child.left;
		child.left = cur;
	}
	return child;
}

3）LR，RL的双旋

在这里插入图片描述

RL

LR：第一个L指不平衡结点的左子树高度大于右子树高度，第二个R指其左子结点的右子树高度大于左子树高度
RR：第一个R指不平衡结点的右子树高度大于左子树高度，第二个R指其右子节点的左子树高度大于右子树高度

LR
LR可以视作grandchild与child之间的一次RR旋转 + grandchild与cur之间的一次LL旋转
RL
RL可以视作grandchild与child之间的一次LL旋转 + grandchild与cur之间的一次RR旋转
所以直接递归实现即可

// @param cur_child_isLeft 不平衡结点是否是左子树不平衡，或者是child结点是否是cur的左儿子
// @param child_isLeft child结点是否是左子树高度大于右子树
private Node rotate(Node cur, Node child, 
									boolean cur_child_isLeft, boolean child_isLeft) {
	if (cur_child_isLeft && child_isLeft) { // LL
		cur.left = child.right;
		child.right = cur;
	} else if (!cur_child_isLeft && !child_isLeft) { // RR
		cur.right = child.left;
		child.left = cur;
	} else if (cur_child_isLeft && !child_isLeft) { // LR
		cur.left = rotate(child, child.right, false, false); // RR
		return rotate(cur, cur.left, true, true); // LL
	} else { // RL
		cur.right = rotate(child, child.left, true, true); // LL
		return rotate(cur, cur.right, false, false); // RR
	}
	return child;
}

3） 更新calBalance()

// rotateFinished 由于只需要第一个不平衡的结点旋转，用一个bool来控制是否已经旋转完毕
// @param fa_cur_isleftChild 反映了cur是否是fa的左儿子
private int calBalance(Node fa, Node cur, boolean fa_cur_isleftChild) {
	if (cur == null || this.rotateFinished) // 增加强行终止
		return 0;
	int l = calBalance(cur, cur.left, true);
	int r = calBalance(cur, cur.right, false);
	if (!this.rotateFinished && Math.abs(l - r) > 1) {
		this.rotateFinished = true;
		Node child = l > r ? cur.left : cur.right;
		Node finished = rotate(cur, child, l > r, child.balance > 0);
		if (fa_cur_isleftChild) fa.left = finished;
		else fa.right = finished;
		// 由于旋转完毕之后root可能发生了改变，所以要重新赋予root
		this.root = this.protect.left;
	}
	cur.balance = l - r;
	return Math.max(l, r) + 1;
}

另外在insert()函数和delete()函数结束时调用计算平衡因子的方法

三、AVL源码

public class MyAVL {
	Node root;
	private Node protect; // 由于AVL需要旋转，则设置一个保护结点
	private static final int protectVal = 0; 
	private HashSet<Integer> set;
	private boolean rotateFinished;
	
	public MyAVL(int rootVal) {
		this.root = new Node(rootVal);
		this.protect = new Node(protectVal, this.root, null);
		this.set = new HashSet<>();
		this.set.add(rootVal);
	}
	
	public MyAVL() {
		this.protect = new Node(protectVal);
		this.set = new HashSet<>();
	}
	
	public boolean insert(int insertVal) {
		if (this.set.contains(insertVal))
			return false;
		return insert(this.protect, this.root, insertVal, true);
	}
	
	// @param insertLeft 假设初始时插入的是左结点
	private boolean insert(Node fa, Node cur, int insertVal, boolean insertLeft) {
		// 找到插入位置
		while (cur != null) {
			fa = cur;
			if (cur.val < insertVal) {
				cur = cur.right;
				insertLeft = false;
			} else {
				cur = cur.left;
				insertLeft = true;
			}
		}
		// 插入操作
		if (insertLeft) fa.left = new Node(insertVal);
		else fa.right = new Node(insertVal);
		// 加入set
		this.set.add(insertVal);
		// 若初始化没有加入root
		if (this.root == null)
			this.root = this.protect.left;
		
		// ----此时插入已经完成----
		// 计算平衡因子并旋转
		calBalanceInit();
		return true;
	}
	
	public boolean remove(int removeVal) {
		if (!set.contains(removeVal))
			return false;
		return remove(this.protect, this.root, removeVal, true); 
	}
	
	// @param deleteLeft 初始时假设删除的是左节点
	private boolean remove(Node fa, Node cur, int removeVal, boolean deleteLeft) {
		// 找到删除位置
		while (cur.val != removeVal) {
			fa = cur;
			if (cur.val < removeVal) {
				cur = cur.right;
				deleteLeft = false;
			} else {
				cur = cur.left;
				deleteLeft = true;
			}
		}
		// 删除操作
		if (cur.left == null && cur.right == null) { // 都null
			if (deleteLeft) fa.left = null;
			else fa.right = null;
		} else if (cur.left == null || cur.right == null) { // 一边null
			if (deleteLeft) fa.left = cur.left == null ? cur.right : cur.left;
			else fa.right = cur.left == null ? cur.right : cur.left;
		} else { // 都不null，找后驱，此处是修改结点的值
			Node nextDelete = cur.right;
			fa = cur; // 此时fa为nextDelete的父结点
			while (nextDelete.left != null) {
				fa = nextDelete;
				nextDelete = nextDelete.left;
			}
			if (fa.right == nextDelete) // 也就是cur的后驱就是cur的右儿子
				fa.right = nextDelete.right;
			else // cur的后驱是cur右儿子的最左儿子
				fa.left = nextDelete.right;
			cur.val = nextDelete.val;
		}
		// 从set移除
		this.set.remove(removeVal);
		
		// ----此时删除已经完成----
		// 计算平衡因子并旋转
		calBalanceInit();
		return true;
	}
	
	// 做好旋转前的准别工作，并调用计算平衡因子的方法
	private void calBalanceInit() {
		this.rotateFinished = false;
		calBalance(this.protect, this.root, true);
	}
	
	// rotateFinished 由于只需要第一个不平衡的结点旋转，用一个bool来控制是否已经旋转完毕
	private int calBalance(Node fa, Node cur, boolean fa_cur_isleftChild) {
		if (cur == null || this.rotateFinished) // 增加强行终止
			return 0;
		int l = calBalance(cur, cur.left, true);
		int r = calBalance(cur, cur.right, false);
		if (!this.rotateFinished && Math.abs(l - r) > 1) {
			this.rotateFinished = true;
			Node child = l > r ? cur.left : cur.right;
			Node finished = rotate(cur, child, l > r, child.balance > 0);
			if (fa_cur_isleftChild) fa.left = finished;
			else fa.right = finished;
			// 由于旋转完毕之后root可能发生了改变，所以要重新赋予root
			this.root = this.protect.left;
		}
		cur.balance = l - r;
		return Math.max(l, r) + 1;
	}
	
	private Node rotate(Node cur, Node child, 
									boolean cur_child_isLeft, boolean child_isLeft) {
		if (cur_child_isLeft && child_isLeft) { // LL
			cur.left = child.right;
			child.right = cur;
		} else if (!cur_child_isLeft && !child_isLeft) { // RR
			cur.right = child.left;
			child.left = cur;
		} else if (cur_child_isLeft && !child_isLeft) { // LR
			cur.left = rotate(child, child.right, false, false);
			return rotate(cur, cur.left, true, true);
		} else { // RL
			cur.right = rotate(child, child.left, true, true);
			return rotate(cur, cur.right, false, false);
		}
		return child;
	}
}
明里贵树
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手撕，高级数据结构——AVL树的实现和插入方法
回水的博客
07-31 1266
AVL树的实现和插入方法
【数据结构进阶】手撕红黑树
2303_79329831的博客
08-01 1228
红黑树的介绍，以及底层代码逻辑和实现。刚刚接触编程的时候就听说有的大厂HR会让手撕红黑树。心中一直对这个数据结构保持着敬畏和向往，今天在将其撕出来后，用本篇博客加以记录，望周知。红黑树的结点包含四个成员变量，模板类型T：可以存储K或者pair类型，便于后期封装；三个指针：分别为指向左孩子结点的指针，指向右孩子结点的指针，指向父结点的指针；最后变量_col：枚举类型，可以存RED和BLACK。
手撕AVL树
南猿北者博客
05-01 1116
在插入节点过后parent节点的_bf变为了-2或2，那么说明在插入节点之前，parent节点的平衡因子一定是-1或1（证明方法与前面无异），那是不是说明，在插入节点前后，parent这课树右子树-左子树的高度由-1或1变成了-2或2，我们在深入挖掘一下，这个插入的节点是不是一定是插在左右子树中高的一颗子树中的！因此，现在我们向一颗AVL树中插入节点，那么势必会导致AVL树中的某些节点的平衡因子发生改变，为了保证插入节点过后，这课树依旧是一颗AVL树，我们需要对相关节点的平衡因子，进行调整；
天天说手撕AVL树？你真的能撕下来吗？（详细解释+代码注释）
CYK_byte的博客
12-20 778
为什么要引入AVL树？我们熟知的二叉搜索树虽然在原来二叉树的基础上已经缩短了查找的效率，但是若数据有序，或接近有序的二叉搜索树将会退化成一个单支树，查找的效率相当于在顺序表中搜索元素，有悖引入二叉搜索树的初衷了；这时候就出现了AVL树，可以很好的接近上述问题；怎么解决？请往下看~接下来本文将用最简洁明了的话语、最详细的代码、最详细的注释，带你深入以及模拟实现一个AVL树；
手撕AVL树——四种旋转
weixin_63790936的博客
05-02 679
手撕AVL树旋转 对二叉搜索树进行中序遍历可以得到有序的序列 AVL树 是一颗严格平衡搜索树通过控制左右子树的高度差，左右子树的高度之差的绝对值超过(-1/0/1) 我这里用的是三叉链，用平衡因子控制左右之差 三叉链可以更方便操作和理解，也是有弊的，每个结点在32为
数据结构学习之路-二叉树
weixin_45452278的博客
05-07 964
注意哦，左子树和右子树也要遵循前序遍历的原则。很容易想到递归求解，传入的参数是根节点，这里我们访问形式选择的是打印，然后依次前序遍历左子树（传入的参数顺理成章的就是左子节点），最后前序遍历右子树（传入的参数就是右子节点）
很重要的数据结构
09-03 90
很重要的数据结构 文章目录很重要的数据结构1 数组1. 1 数组特点：2 链表2.1链表特点：2.2 单项链表2.3 双向链表3 二叉树3.1 二叉树特点3.2 二叉树的分支3.3 遍历操作3.4 删除结点3.5 查找局限性4 `AVL`树(平衡二叉树)4.1 描述：5 `2-3-4`树5.1 描述5.2 生成的过程5.3 和红黑树的等价关系5.3.1 `2结点`5.3.2 `3结点`6 红黑树6.1描述6.2 旋转描述6.2.1 概念讲解6.3 新增结点7 [Trie树](https://baike.b
手撕最小堆（重构堆 + 插入数据 + 删除数据 代码讲解 + 例题）
Love 6's Private Blog
11-06 462
文章目录推荐堆排序博客与视频讲解前引堆介绍1、Heapify（重建堆）2、Push（插入数据）3、Pop（删除数据）最小堆代码实现最小堆例题链接 推荐堆排序博客与视频讲解 堆排序（堆重建 + 插入 + 删除详细讲解）UP主：秃头少女王某人 强推 前引 今天10点才起床 大二了 真的不知道为什么越起床越晚了 当然现在也是周末 但是起这么晚 还是得做事情 在每日三道面试题的发现 第二个竟然是手撕堆排序 说来太惭愧了 原来数据结构 本来对手撕堆排序超级超级自信的 结果 我这一次从零开始写 写了好久 呜呜
保姆级别带你手撕红黑树BRTree
我的学习笔记分享
04-20 1646
一、前言 本文是自己在学习过程中，记录下的一些总结，以便日后复习，同时分享出来，方便与更多人学习交流，共同进步。鄙人水平有限，若有误，请不吝赐教😁😁😁。 二、从头介绍 红黑树树是一种二叉树，比较常用的数据结构，如果对二叉树不是很熟悉或者有遗忘的朋友，可以看看我之前做的笔记。 第一篇介绍二叉树的基础知识：数据结构与算法 树_振予的博客-CSDN博客 第二篇介绍二叉搜索树和二叉平衡树树：数据结构与算法 查找_振予的博客-CSDN博客 三、红黑树介绍 每当我们打开电脑查找一个文档、在教务系统输入我们
【手撕STL】map和set
AI_ELF的博客
07-09 764
这里写目录标题setset的使用举例map三级目录 set set文档介绍 set是按照一定次序存储元素的容器 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。 set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭
非科班无实习如何入职腾讯？后台开发岗个人校招学习路线分享！
weixin_70730532的博客
06-14 3945
从去年一直拖到现在的学习路线一直没有回馈给牛油们。上周答辩结束，正式准备毕业了，终于能有时间献上一封后台开发学习路线，如有疏漏或者疑问尽可在下方评论或者私信我。 先介绍一下情况吧，2022届单985通信背景非科班无实习水硕，C++经典烂大街项目，网络服务器，去年二三月份才开始准备的，正式刷题是从去年2月份开始的，最后也只是刷了200+，项目是四月份开始整的，八股文准备就更晚了，是从六七月份开始的（大佬们都有意向书了，我才刚开始背八股，卑微），和有大厂实习的科班大佬ssp们相比，真的是不敢大声说话，毕竟大佬在
【大总结2】大学两年，写了这篇几十万字的干货总结_万字 cndn
2401_84617533的博客
04-27 783
这部分在我看来是最有意思的，我们有必要了解底层数据结构的实现，这也是我最感兴趣的。比如，你知道redis中的字符串怎么实现的吗？为什么这么实现？你知道redis压缩列表是什么算法吗？你知道redis为什么抛弃了红黑树反而采用了跳表这种新的数据结构吗？你知道hyperloglog为什么用如此小的空间就可以有这么好的统计性能和准确性吗？你知道布隆过滤器为什么这么有效吗？有没有数学证明过？你是否还能很快写出来快排？或者不断优化性能的排序？是不是只会调库了甚至库函数怎么实现的都不知道？真的就是快排？
2020校招复盘——秋招不易，致敬每一位追梦者（含网易、京东等19家互联网公司后台/Server端面经）
热门推荐
ZY-JIMMY
10-18 3万+
秋招经历、秋招心得、C++后台/Server端方向校招准备、面经整理、面经题库
数据结构 数据结构
qq_69971969的博客
09-03 358
空间不连续 访问数据不方便（需要遍历） 插入和删除比较方便 不需要预分配，动态增长。空间连续 访问数据方便 插入和删除需要移动大量数据 需要预分配存储空间。数据的物理结构：数据的逻辑结构在计算机内存中的存储方式。线性结构：一对一的元素关系（数组，链表。图形结构：元素之间的多对多的关系（网状结构）数据的逻辑结构：数据元素与元素之间的关系。树型结构：一对多的元素关系（二叉树）链式存储：一段非连续的空间。程序：数据结构 + 算法。顺序存储：一段连续的空间。数据与数据之间的关系。
冒泡排序；选择排序；插入排序；快排；判断大小端；位运算
最新发布
qq_56797509的博客
09-03 229
假设有10个元素a[1]-a[10]，将a[1]与a[2]-a[10]比较，若a[1]比a[2]-a[10]都小，则不进行交换。若a[2]-a[10]中有一个以上比a[1]小，则将其中最小的一个与a[1]交换，此时a[1]就存放了10个数中最小的一个。同理，第二轮拿a[2]与a[3]-a[10]比较，a[2]存放a[2]-a[10]中最小的数，以此类推。选一个key值（选第一个值），从后面选一个比其小的值，从前面选一个比其大的值，key值放中间。1.小端：内存低地址存放低数据位称为内存小端。
数据结构（邓俊辉）学习笔记】串 10——BM_BC算法：坏字符
weixin_44399845的博客
08-28 894
BM_BC算法：坏字符
【手撕数据结构】二叉树的性质
apple_61439616的博客
08-31 389
目录叶子节点和边的性质概念小试牛刀 叶子节点和边的性质 概念 可以看到度为0的节点如F没有边，度为1的节点如C有一条边，而度为2的节点如B有两条边。 那么设度为2的节点为a个，度为1的节点为b个。二叉树边 = 2a+b 另⼀⽅⾯，由于共有 a+b+c 个节点，所以边数等于 a+b+c-1 这里-1是因为： 综合上面两个公式，我们2a+b = a + b + c - 1; 推出c = a+1(c为度为0节点，a为度为2节点) 所以叶子结点n0 = n2 + 1; 小试牛刀 这道题已经告诉了我们度
【数据结构】-----哈希
m0_73470633的博客
08-29 1765
一文看懂哈希结构！
优化数据结构：AVL树与平衡二叉操作详解
高级数据结构是一门深入研究的数据结构理论，它探讨了在复杂度优化方面超越基础数据结构的高级概念和技术。本讲内容涵盖了平衡二叉树、可并优先队列、线段树和树状数组的基础以及RMQ（Range Minimum Query）与LCA...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值