【平衡树总结 Ⅱ】【SBT】Size Balanced Tree | E

最新推荐文章于 2023-02-15 21:00:59 发布
最新推荐文章于 2023-02-15 21:00:59 发布
阅读量762 收藏 2
点赞数
分类专栏： L | 洛谷 P | 平衡树 (各种) Z | 总结题型 经典平衡树的介绍与应用 文章标签： SBT 平衡树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42102584/article/details/88881932
版权

今天来种一种个人最喜欢的SBTree

平衡树总结Ⅱ：SBT



概述

SBT，Size Balanced Tree，顾名思义是尽量维护子树大小（结点个数）平衡的树。

也就是当每次插入新结点后，如果发现左右子树失衡（某个结点的size比它兄弟的孩子的size都要小）就得进行旋转操作，来使子树的size始终保持在一个较为平衡的状态。



自平衡操作

① SBT的自平衡维护比较简单，只在插入时进行自平衡维护，且只有两种最基本的旋转操作：简单左旋和简单右旋：

  • 左旋操作：（点击可以看大图哦）在这里插入图片描述
  • 右旋操作：（点击可以看大图哦）在这里插入图片描述

一个值得注意的地方是，在设计旋转函数的时候，参数 i 应该是引用类型（可以发现在第四步修改了这个引用）。这样我们在第四步对 i 进行的赋值才会真的修改 i 的值（即父节点指针的值）


② 那么啥时候需要旋转呢？什么时候叫做 “左右子树size失衡” 了呢？

我们定义某个结点是平衡的当且仅当他的size不小于其兄弟结点的任一子节点的size：（如图。为了表示方便，每个结点或子树都用一个大写字母起了名字，并将其真实下标标注在正下方）
在这里插入图片描述
SBT在每次插入结点后会检查当前结点一直到根结点这一条链上的各个结点是否满足平衡条件，如果不满足就进行旋转。

③ 具体调整逻辑：

  • 1.YD失衡（D太重，要左旋X (即i号) ）在这里插入图片描述

  • 2.YC失衡（C太重，要先右旋Z (即t[i].ri号) ，再左旋X (即i号) ）在这里插入图片描述在这里插入图片描述

  • 3.ZA失衡（对称于YD失衡（图就不画啦）：A太重，要右旋X (即i号) ）

  • 4.ZB失衡（对称于YC失衡（图就不画啦）：B太重，要先左旋Y (即t[i].li号)，再右旋X (即i号) ）

是不是很简单呢 当然，最后为了写代码方便，我们还可以把调整平衡的函数加一个 bool 型参数，告知函数我刚刚是改了左子树还是右子树，如果改了右子树就只用判断是否发生了YD失衡或YC失衡，如果改了左子树就只用判断是否发生了ZA失衡或ZB失衡。并且可以在函数的最后暴力地检查当前结点、当前结点左孩子、当前结点右孩子是否需要再递归调整（稍微降低一点点运行效率，但大幅减少出 bug 概率）


④ 关键函数代码：（基本上把上面的分析翻译一下就行）

struct SBN	// SBT结点
{
	xint li, ri, sz;	// 左孩子指针（下标）、右孩子指针（下标）、该子树的size
	vint v;				// 点权
} t[MN];

inline void l_rotate(xint &i)	// 左旋
{
	const xint ri = t[i].ri;								// 记住ri
	t[i].ri = t[ri].li, t[ri].li = i, t[ri].sz = t[i].sz;	// 修改t[i]的右指针、t[ri]的左指针，同时修改t[ri]的size
	t[i].sz = t[t[i].li].sz + t[t[i].ri].sz + 1;			// 修改t[i]的size
	i = ri;													// 修改i的父节点的指针
	/*	改引用i是因为旋转后i的父节点就不应该指向i了，而应该指向i的右孩子
		所以要把i父节点指向i的指针改成指向ri的指针，所以需要传引用改i（调用时传的正是i父节点指向i的指针的引用）*/
}

inline void r_rotate(xint &i)	// 右旋
{
	const xint li = t[i].li;								// 记住li
	t[i].li = t[li].ri, t[li].ri = i, t[li].sz = t[i].sz;	// 修改t[i]的左指针、t[li]的右指针，同时修改t[li]的size
	t[i].sz = t[t[i].li].sz + t[t[i].ri].sz + 1;			// 修改t[i]的size
	i = li;													// 修改i的父节点的指针
}

void maintain(xint &i, const bool rr)	// 维护平衡
{
	if (rr)	// 如果刚才改的是右子树
	{
		if (t[t[t[i].ri].ri].sz > t[t[i].li].sz)		// YD失衡，D太重
			l_rotate(i);								// 要左旋X(即i号)
		else if (t[t[t[i].ri].li].sz > t[t[i].li].sz)	// YC失衡，C太重
			r_rotate(t[i].ri), l_rotate(i);				// 要先右旋Z(即t[i].ri号)；然后再左旋X(即i号)
		else											// 没有失衡
			return;
	}
	else	// 刚才改的是左子树
	{
		if (t[t[t[i].li].li].sz > t[t[i].ri].sz)		// ZA失衡，A太重
			r_rotate(i);								// 要右旋X(即i号)
		else if (t[t[t[i].li].ri].sz > t[t[i].ri].sz)	// ZB失衡，B太重
			l_rotate(t[i].li), r_rotate(i);				// 要先左旋Y(即t[i].li号)；然后再右旋X(即i号)
		else											// 没有失衡
			return;
	}

	// 懒得具体分析了，直接暴力递归所有可能需要维护平衡的情况(最多就造成几次额外的if判断，不用担心会产生无用的旋转操作)
	maintain(t[i].li, false), maintain(t[i].ri, true), maintain(i, false), maintain(i, true);
}



例题   洛谷P3369 【模板】普通平衡树


分析：没什么好说的…把SBT最基本的功能实现即可

代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define LL long long
#define _BS 1048576
char _bf[_BS];
char *__p1=_bf,*__p2=_bf;
#define _IO char *_p1=__p1,*_p2=__p2;
#define _OI __p1=_p1,__p2=_p2;

#ifdef _KEVIN
#define GC getchar()
#else
#define GC (_p1==_p2&&(_p2=(_p1=_bf)+fread(_bf,1,_BS,stdin),_p1==_p2)?EOF:*_p1++)
#endif
#define PC putchar
#define sc(x) {register char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}

template<class T>
void PRT(const T _){if(_<0){PC(45),PRT(-_);return;}if(_>=10)PRT(_/10);PC(_%10+48);}

constexpr int MN(1e5+7);

template <typename vint, typename xint = int>
class SBT
{
private:

	xint root, tot;
	struct SBN
	{
		xint li, ri, sz;
		vint v;
	} t[MN];

	inline void l_r(xint &i)	// 左旋
	{
		const xint ri = t[i].ri;
		t[i].ri = t[ri].li, t[ri].li = i, t[ri].sz = t[i].sz;
		t[i].sz = t[t[i].li].sz + t[t[i].ri].sz + 1;
		i = ri;
	}

	inline void r_r(xint &i)	// 右旋
	{
		const xint li = t[i].li;
		t[i].li = t[li].ri, t[li].ri = i, t[li].sz = t[i].sz;
		t[i].sz = t[t[i].li].sz + t[t[i].ri].sz + 1;
		i = li;
	}

	void mt(xint &i, const bool rr)	// 维护平衡
	{
		if (rr)	// 如果刚才改的是右子树
		{
			if (t[t[t[i].ri].ri].sz > t[t[i].li].sz)		// YD失衡
				l_r(i);
			else if (t[t[t[i].ri].li].sz > t[t[i].li].sz)	// YC失衡
				r_r(t[i].ri), l_r(i);
			else											// 没有失衡
				return;
		}
		else	// 刚才改的是左子树
		{
			if (t[t[t[i].li].li].sz > t[t[i].ri].sz)		// ZA失衡
				r_r(i);
			else if (t[t[t[i].li].ri].sz > t[t[i].ri].sz)	// ZB失衡
				l_r(t[i].li), r_r(i);
			else											// 没有失衡
				return;
		}

		mt(t[i].li, 0), mt(t[i].ri, 1), mt(i, 0), mt(i, 1);
	}

	void _insert(xint &i, const vint v)
	{
		if (i)
		{
			++t[i].sz;
			if (v < t[i].v)
				_insert(t[i].li, v), mt(i, 0);
			else
				_insert(t[i].ri, v), mt(i, 1);
		}
		else
		{
			i = ++tot;
			t[i].v = v;
			t[i].sz = 1;
		}
	}

	vint _erase(xint &i, const vint v)
	{
		--t[i].sz;
		if (v==t[i].v || (!t[i].li && v<t[i].v) || (!t[i].ri && v>t[i].v))
		{
			vint tmp = t[i].v;
			if (!t[i].li || !t[i].ri)
				i = t[i].li + t[i].ri;
			else
				t[i].v = _erase(t[i].li, t[i].v+1);
			return tmp;
		}
		if (v<t[i].v)
			return _erase(t[i].li, v);
		else
			return _erase(t[i].ri, v);
	}

	xint _lower_rk(xint i, const vint v) const
	{
		xint rk = 1;
		while (i)
		{
			if (t[i].v >= v)
				i = t[i].li;
			else
				rk += t[t[i].li].sz + 1, i = t[i].ri;	// 先+=再改i
		}

		return rk;
	}

	xint _upper_rk(xint i, const vint v) const
	{
		xint rk = 0;
    	while (i)
    	{
    		if (t[i].v > v)
    			i = t[i].li;
    		else
    			rk += t[t[i].li].sz + 1, i = t[i].ri;	// 先+=再改i
		}

		return rk;
	}

	vint _nth(xint i, xint k) const
	{
		xint lz;
		while (i)
		{
			lz = t[t[i].li].sz;
	        if (k == lz+1)
	        	break;
	        if (k <= lz)
	            i = t[i].li;
	        else
	            i = t[i].ri, k -= lz + 1;
	    }

	    return t[i].v;
	}

	vint _prev(const xint i, const vint v) const
	{
		if (!i)
			return v;
		vint tp;
		if (v <= t[i].v)
			tp = _prev(t[i].li, v);
		else
		{
			tp = _prev(t[i].ri, v);
			if (tp == v)
				tp = t[i].v;
		}
		return tp;
	}

	vint _next(const xint i, const vint v) const
	{
		if (!i)
			return v;
		vint tp;
		if (v >= t[i].v)
			tp = _next(t[i].ri, v);
		else
		{
			tp = _next(t[i].li, v);
			if (tp == v)
				tp = t[i].v;
		}
		return tp;
	}

// interfaces
public:

	inline void init(void)
	{
		root = tot = 0;
	}

	inline void insert(const vint v)
	{
		_insert(this->root, v);
	}

	inline vint erase(const vint v)
	{
		return _erase(this->root, v);
	}

	inline xint lower_rk(const vint v) const
	{
		return _lower_rk(this->root, v);
	}

	inline xint upper_rk(const vint v) const
	{
		return _upper_rk(this->root, v);
	}

	inline vint nth(const xint k) const
	{
		return _nth(this->root, k);
	}

	inline vint prev(const vint v) const
	{
		return _prev(this->root, v);
	}

	inline vint next(const vint v) const
	{
		return _next(this->root, v);
	}
};

SBT<int> sbt;

int main()
{
	_IO

	sbt.init();
	int T;
	sc(T)
	while (T--)
	{
		int op, v;
		sc(op)sc(v)
		switch (op)
		{
			case 1:
				sbt.insert(v);
				break;
			case 2:
				sbt.erase(v);
				break;
			case 3:
				PRT(sbt.lower_rk(v)), PC(10);
				break;
			case 4:
				PRT(sbt.nth(v)), PC(10);
				break;
			case 5:
				PRT(sbt.prev(v)), PC(10);
				break;
			case 6:
				PRT(sbt.next(v)), PC(10);
				break;
		}
	}

	return 0;
}


论文

最后贴出陈启峰巨巨的论文原文：https://wenku.baidu.com/view/a96cef5abe23482fb4da4cb1.html


Keyu Tian
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
节点大小平衡树(（Size Balanced Tree, c++和python源码）
02-26
我自己写的SBTree的实现 参考了http://www.nocow.cn/index.php/Size_Balanced_Tree的算法 声明：此源码可以用于商业用途，但请注明来源于random
竞赛最好用的平衡树-Size Balanced Tree（SBT）【建议收藏】
x0919的博客
10-24 3016
大家好。 前段时间我更新过AVL、红黑树以及搜索二叉树的简单讲解。今天我们还是围绕着平衡树的话题，来讲解一个很牛逼的平衡树结构。这种结构是我国的一位大牛：陈启峰。在2006年，他还在读高中阶段，所发明的一种平衡树结构，叫Size Balanced Tree（SBT），根据节点的个数，来调整平衡性。一直到今天，这种平衡树结构，在算法竞赛领域是非常常用的，虽然SBT的时间复杂度跟AVL、红黑树这些平衡树一样，但是SBT是比较好写，比较好改的。所以在算法竞赛时，是最常用的一种算法。陈启峰SBT论文（译） 本期文章
有序表之SB树（Size Balanced Tree）
明朗晨光的专栏
02-15 1039
1、SB树的失衡类型及失衡的调整方式 2、SB树的代码实现
平衡树学习笔记
柴春阳的博客
03-06 6950
平衡树 1. 伪平衡树（并不是平衡树） 2. Treap 3. 替罪羊树 4. AVL树 5. 伸展树 6. 红黑树 7. 加权平衡树 8. 2-3树 9. AA树 10. 节点大小平衡树
SizeBalancedTrees
Darkside的博客
10-14 208
前言 BST一直都是卡常的领域，为了不被卡常，我们需要一个更平衡的BST，SizeBalanceTree就是不错的选择。 旋转 众所周知，平衡树分为两类，非旋平衡树和旋转平衡树， SizeBalanceTree是依靠旋转来保持平衡的。 左旋 左旋的意思就是把当前节点移到左边去，同时保持树的中序遍历不变，右旋也是同理(代码与左旋对称)，注意保持树的中序遍历不变是非常重要的，它决定了树的搜索性质是否变化； 右旋 代码 inline void Rotate(int &now,bool flag) {
sbt.rar_SBT_Size Balanced Tree
09-22
SBT，全称为Size Balanced Tree，是一种特殊类型的自平衡二叉搜索树，设计用于高效地执行插入、查找和删除操作。这种数据结构在计算机科学中主要用于动态存储有序数据，尤其适用于需要频繁进行增删查改操作的应用...
SBT.rar_SBT_二叉搜索树
09-24
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中所有节点的值都大于该节点的值。这种排序性质...
SBT模板(平衡树)
04-02
本模板为 BZOJ3224：文艺平衡树 的源程序 含各种操作，旋转，插入，删除，求前驱，后继，查询值为x的数的排名，查询排名为k的数，求最大值，最小值……
陈启峰《Size Balanced Tree》 ppt中文版
02-07
“Size Balanced Tree (abbr. SBT) 是一种通过大小来保持平衡的BST。” SBT资料——陈启峰本人 ppt中文版 若需参考更多资料，请下载“陈启峰《Size Balanced Tree》 pdf英文版”
AVL 红黑树 SBT-2020.12.11.pdf
12-11
AVL树是一种自平衡的二叉搜索树，由G.M. Adelson-Velskii和E.M. Landis在1962年提出。它具有以下特点： - 每个节点的两个子树的高度最大差别不超过1。 - 任何时候都是平衡的，确保了查找、插入和删除操作的时间...
陈启峰《Size Balanced Tree》 pdf英文版
02-07
“Size Balanced Tree (abbr. SBT) 是一种通过大小来保持平衡的BST。” SBT资料——陈启峰本人 pdf英文版 若需参考更多资料，请下载“陈启峰《Size Balanced Tree》 ppt中文版”
算法笔记——SBT
m0_67142204的博客
08-26 596
SBT
SizeBalanceTree详解（含代码实现）
qq_56999918的博客
02-03 1698
+1.SBT树的概念及其相关性质 Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山记念中学的陈启峰于2006年末完成，php 并在Winter Camp 2007中发表。因为SBT的拼写很容易找到中文谐音， 它常被中国的Oler们戏称为 “傻X树”、html “Super BT”等。但它的性能并不SB，编写起来也并不BT。偏偏相反，SBT易于实现，且据陈启峰论文中所言 ，node “这是目前为止速度最快的高级二叉搜索树”。它能在O(logn)的时间..
SBT（Size Balanced Tree）2016.9.6
追风蹑影
09-06 906
参考：陈启峰《Size Balanced Tree》 一、定义 节点大小平衡树（ Size Balanced Tree，缩写：SBT）是一种自平衡二叉查找树 它是由中国广东中山纪念中学的陈启峰发明的 陈启峰于 2006 年底完成论文《Size Balanced Tree》，并在 2007 年的全国青少年信息学奥林匹克竞赛冬令营中发表 由于 SBT 的拼写很容易找到中文谐音，它常被中国
Size Balanced Tree
Make Progress Everyday!
08-02 1286
 今天上网搜索关于红黑树的资料时，发现一种新的平衡二叉树（SBT），据说各方面性能很好，先摘录在此，以后再细看。 Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山纪念中学的陈启峰于2006年底完成，并在Winter Camp 2007中发表。由于SBT的拼写很容易找到中文谐音，它常被中国的OIer们戏称为“傻X树”、“Super BT”等。但它
【数据结构与算法】Size Balanced Tree（SBT）平衡二叉树
小哲的博客
11-02 1483
尺寸平衡树（SBT）平衡二叉树 原文链接大小平衡树（SBT）平衡二叉树 定义数据结构 struct SBT { int key,left,right,size; } tree[N]; 关键：存储值，左，右：左右子树，大小：保持平衡最终要的数据，表示子树的大小 SBT树的性质 定义一个节点X，同时满足下面两个条件 (a)、x.left.size &gt;= max(x.r...
傻逼树SBT：Size Balanced Tree的实现原理，增删改查，调平衡
weixin_46838716的博客
05-29 689
为了调平衡，咱们必须要有左旋函数（leftRotate）、右旋函数（rightRotate） 调平每次变化了哪些节点，就需要再次检查和调平（maintain），maintain函数需要分LL,RR,LR,RL四种状况 查傻逼树SBT中是否有节点key，并返回离key最近的不为null的那个节点（pre），查询key函数：findLeastKeyNode 返回傻逼树SBT整体有多少个节点？size()函数 判断傻逼树是否为空树？isEmpty() put函数是更新，或者新增--没有返回值，内部操作add:ke
数据结构之平衡二叉树详解
热门推荐
any_ways的博客
06-05 1万+
平衡二叉树（balanced binary tree)又称AVL树（Adelson-Velskii and Landis)一棵平衡二叉树或者是空树，或者是具有下列性质的二叉排序树： １，左子树与右子树的高度之差的绝对值小于等于１； ２，左子树和右子树也是平衡二叉排序树．为了方便起见，给每个结点附加一个数字，给出该结点左子树与右子树的高度差．这个数字称为结点的平衡因子（ＢＦ）．平衡因子　＝　结点左子树的高度　－　结点右子树的高度根据平衡二叉树的定义，平衡二叉树上所有结点的平衡因子只
Size Balanced Tree(SBT树)整理
weixin_30414245的博客
11-29 556
不想用treap和Splay，那就用SB树把，哈哈，其实它一点也SB，厉害着呢。 先膜拜一下作者陈启峰。Orz 以下内容由我搜集整理得来。 一、BST及其局限性 二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 1.若任意...
java实现SizeBalancedTree大小平衡树（附完整源码）
最新发布
05-26
首先，SizeBalancedTree是一种基于平衡树的数据结构，它的特点是除了具备平衡树的特性之外，还能够在节点中记录子树大小。这样可以方便地查询某个节点的排名或者寻找某个排名的节点。 以下是Java实现SizeBalancedTree的完整源码： ```java import java.util.Random; public class SizeBalancedTree { private static final int MAXN = 100005; private static final Random random = new Random(); static class Node { int key, size, cnt; Node ch[] = new Node[2]; Node(int key) { this.key = key; size = cnt = 1; } } private Node nullNode = new Node(0); private Node root = nullNode; private Node newNode(int key) { Node x = new Node(key); x.ch[0] = x.ch[1] = nullNode; return x; } private void pushup(Node x) { x.size = x.ch[0].size + x.ch[1].size + x.cnt; } private Node rotate(Node x, int k) { Node y = x.ch[k^1]; x.ch[k^1] = y.ch[k]; y.ch[k] = x; pushup(x); pushup(y); return y; } private Node maintain(Node x, boolean flag) { if (x == nullNode) return x; if (flag && x.ch[0].size > x.ch[1].size * 3) { x = rotate(x, 1); } else if (!flag && x.ch[1].size > x.ch[0].size * 3) { x = rotate(x, 0); } return x; } private Node insert(Node x, int key) { if (x == nullNode) return newNode(key); if (key == x.key) { x.cnt++; pushup(x); return x; } boolean k = key > x.key; x.ch[k] = insert(x.ch[k], key); pushup(x); return maintain(x, k); } private Node remove(Node x, int key) { if (x == nullNode) return x; if (key == x.key) { if (x.cnt > 1) { x.cnt--; pushup(x); return x; } if (x.ch[0] == nullNode && x.ch[1] == nullNode) { return nullNode; } else if (x.ch[0] == nullNode) { x = x.ch[1]; } else if (x.ch[1] == nullNode) { x = x.ch[0]; } else { boolean k = x.ch[0].size > x.ch[1].size; x = rotate(x, k ? 0 : 1); x.ch[k^1] = remove(x.ch[k^1], key); pushup(x); x = maintain(x, k^1); } } else { boolean k = key > x.key; x.ch[k] = remove(x.ch[k], key); pushup(x); x = maintain(x, k); } return x; } private Node getKth(Node x, int k) { if (x == nullNode) return nullNode; int rank = x.ch[0].size + 1; if (k < rank) { return getKth(x.ch[0], k); } else if (k > rank + x.ch[1].size) { return getKth(x.ch[1], k - rank - x.cnt); } else { return x; } } public void insert(int key) { root = insert(root, key); } public void remove(int key) { root = remove(root, key); } public int getRank(int key) { int rank = 0; Node x = root; while (x != nullNode) { if (key == x.key) { return rank + x.ch[0].size + 1; } else if (key < x.key) { x = x.ch[0]; } else { rank += x.ch[0].size + x.cnt; x = x.ch[1]; } } return rank; } public int getKth(int k) { Node x = getKth(root, k); return x.key; } public static void main(String[] args) { SizeBalancedTree sbt = new SizeBalancedTree(); sbt.insert(1); sbt.insert(2); sbt.insert(3); sbt.insert(4); sbt.insert(5); System.out.println(sbt.getRank(3)); // output: 3 System.out.println(sbt.getKth(3)); // output: 3 sbt.remove(3); System.out.println(sbt.getRank(3)); // output: 0 System.out.println(sbt.getKth(3)); // output: 4 } } ``` 在这里，我们定义了一个内部类Node来表示SizeBalancedTree的节点，包含了键值key、子树大小size和数量cnt。同时，我们也定义了一个nullNode，用于代表空节点。在这里，我们将SizeBalancedTree视作一个二叉搜索树，因此左子树的值都小于当前节点，右子树的值都大于当前节点。 在插入和删除节点的时候，我们需要维护平衡和子树大小，因此需要编写maintain和pushup方法。maintain方法用于在插入或删除节点后，对树进行平衡调整。如果左子树的大小大于右子树的大小的三倍，就进行右旋转；如果右子树的大小大于左子树的大小的三倍，就进行左旋转。pushup方法用于更新节点的子树大小。 在插入节点的时候，我们首先查找要插入的位置，如果该节点已经存在，则只需要增加它的数量即可。如果要插入的节点不存在，则将其插入到相应的位置，并对树进行平衡调整。 在删除节点的时候，我们同样需要查找要删除的节点，如果该节点数量大于1，则只需要减少其数量即可。如果要删除的节点数量为1，则需要考虑该节点的子树情况。如果节点没有子树，则直接删除即可；如果节点只有一个子树，则将子树接到该节点的父节点上；如果节点有两个子树，则选择左子树的大小大于右子树的大小，则在左子树中找到最大值，将其替换为当前节点，并从左子树中删除该最大值。 在查询排名和寻找第k小的节点时，我们需要使用getRank和getKth方法。getRank方法首先查找要查询的节点，如果该节点存在，则返回左子树的大小加上1，否则继续向下查找。getKth方法则根据当前节点的左子树大小和数量，以及右子树的大小，来判断第k小的节点在哪个子树中，然后递归到相应的子树中查找。 最后，我们在main方法中进行测试，插入一些节点并查询排名和第k小的节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值