Size Balanced Tree(SBT)

竞赛最好用的平衡树-Size Balanced Tree(SBT)【建议收藏】 大家好。 前段时间我更新过AVL、红黑树以及搜索二叉树的简单讲解。今天我们还是围绕着平衡树的话题,来讲解一个很牛逼的平衡树结构。这种结构是我国的一位大牛:陈启峰。在2006年,他还在读高中阶段,所发明的一种平衡树结构,叫Size Balanced Tree(SBT),根据节点的个数,来调整平衡性。一直到今天,这种平衡树结构,在算法竞赛领域是非常常用的,虽然SBT的时间复杂度跟AVL、红黑树这些平衡树一样,但是SBT是比较好写,比较好改的。所以在算法竞赛时,是最常用的一种算法。陈启峰SBT论文(译) 本期文章 阅读详情

转载:http://www.nocow.cn/index.php/Size_Balanced_Tree

性质

Size Balanced Tree(SBT)是一种通过大小(Size)域来保持平衡的二叉搜索树,它也因此得名。它总是满足:
对于SBT的每一个结点 t:

  1. 性质(a) s[right[t] ]≥s[left[left[t]]],s[right[left[t]]]
  2. 性质(b) s[left[t] ]≥s[right[right[t]]],s[left[right[t]]]

即每棵子树的大小不小于其兄弟的子树大小。

Sbt1.PNG
图1

如图(圈代表结点,三角代表SBT,下同):

  1. s[R] ≥ s[A],s[B]
  2. s[L] ≥ s[C],s[D]

[编辑] 旋转

SBT的旋转(Rotations)与其他许多高级BST相同。它是下面提到的Maintain操作的基础。

Sbt2.PNG
图2

[编辑] 左旋转

Left-Rotate (t)

1     k ← right[t]
2     right[t] ← left[k]
3     left[k] ← t
4     s[k] ← s[t]
5     s[t] ← s[left[t]] + s[right[t]] + 1
6     t ← k

[编辑] 右旋转

Right-Rotate(t)

1     k ← left[t]
2     left[t] ← right[k]
3     right[k] ← t
4     s[k] ← s[t]
5     s[t] ← s[left[t]] + s[right[t]] + 1
6     t ← k

[编辑] 保持性质(Maintain)

当我们插入或删除一个结点后,SBT的大小就发生了改变。这种改变有可能导致性质(a)或(b)被破坏。这时,我们需要用Maintain操作来修复这棵树。Maintain操作是SBT中最具活力的一个独特过程;Maintain(T)用于修复以T为根的 SBT。调用Maintain(T)的前提条件是T的子树都已经是SBT了。
我们需要讨论的有4种情况。由于性质a和性质b是对称的,所以我们仅仅详细的讨论性质a。

  1. 第一种情况:s[left[left[t]]>s[right[t]]
    Sbt1.PNG
    图3(同图1)
    如图3,执行完Insert(left[t],v)后发生S[A]>S[R],我们可以执行以下的指令来修复SBT:
    1. 首先执行Right-Ratote(t),这个操作让图3变成图4;
      Sbt4.PNG
      图4
    2. 在这之后,有时候这棵树还仍然不是一棵SBT,因为 s[C]>s[B] 或者 s[D]>s[B] 也是可能发生的。所以就有必要继续调用Maintain(T)。
    3. 结点L的右子树有可能被连续调整,因为有可能由于性质的破坏需要再一次运行Maintain(L)。

  2. 第二种情况:s[right[left[t]]>s[right[t]]
    Sbt5.PNG
    图5
    在执行完Insert(left[t],v)后发生s[B]>s[R],如图5,这种调整要比情况1复杂一些。我们可以执行下面的操作来修复:
    1. 在执行完Left-Ratote(L)后,图5就会变成下面图6那样了。
      Sbt6.PNG
      图6
    2. 然后执行Right-Ratote(T),最后的结果就会由图6转变成为下面的图7。
      Sbt7.PNG
      图7
    3. 在第1步和第2步过后,整棵树就变得非常不可预料了。万幸的是,在图7中,子树A、E、F和R仍就是SBT,所以我们可以调用Maintain(L)和Maintain(T)来修复结点B的子树。
    4. 在第3步之后,子树都已经是SBT了,但是在结点B上还可能不满足性质a或性质b,因此我们需要再一次调用Maintain(B)。

  3. 第三种情况:s[right[right[t]]>s[left[t]]
    与情况1对称。
  4. 第四种情况:s[left[right[t]]>s[left[t]]
    与情况2对称。



通过前面的分析,很容易写出一个普通的Maintain。

Maintain (t)

01     If s[left[left[t]]>s[right[t]] then    //case1
02          Right-Rotate(t)
03          Maintain(right[t])
04          Maintain(t)
05          Exit
06     If s[left[right[t]]>s[right[t]] then   //case2
07          Left-Rotate(left[t])
08          Right-Rotate(t)
09          Maintain(left[t])
10          Maintain(right[t])
11          Maintain(t)
12          Exit
13     If s[right[right[t]]>s[left[t]] then   //case1'
14          Left-Rotate(t)
15          Maintain(left[t])
16          Maintain(t)
17          Exit
18     If s[right[left[t]]>s[left[t]] then    //case2'
19          Right-Rotate(right[t])
20          Left-Rotate(t)
21          Maintain(left[t])
22          Maintain(right[t])
23          Maintain(t)


前面的标准过程的伪代码有一点复杂和缓慢。通常我们可以保证性质a和性质b的满足,因此我们只需要检查情况1和情况2或者情况3和情况4,这样可以提高速度。所以在那种情况下,我们需要增加一个布尔(boolean)型变量:flag,来避免毫无意义的判断。如果flag是false,那么检查情况1和情况2;否则检查情况3和情况4。

Maintain (t,flag)

01     If flag=false then
02          If s[left[left[t]]>s[right[t]] then      //case1
03               Right-Rotate(t)
04          Else
05               If s[left[right[t]]>s[right[t]] then   //case2
06                    Left-Rotate(left[t])
07                     Right-Rotate(t)
08          Else                                   //needn’t repair
09               Exit
10     Else
11          If s[right[right[t]]>s[left[t]] then      //case1'
12               Left-Rotate(t)
13          Else
14               If s[right[left[t]]>s[left[t]] then     //case2'
15                    Right-Rotate(right[t])
16                    Left-Rotate(t)
17          Else                                    //needn’t repair
18               Exit
19     Maintain(left[t],false)                     //repair the left subtree
20     Maintain(right[t],true)                     //repair the right subtree
21     Maintain(t,false)                           //repair the whole tree
22     Maintain(t,true)                            //repair the whole tree

为什么Maintain(left[t],true)和Maintain(right[t],false)被省略了呢?您可以在陈启峰论文第六部分的分析中找到答案。
其他可以从论文中获得的信息:每次SBT后树的总深度递减的证明;Maintain的平摊运行时间是O(1)的证明(也就是说你不必担心Maintain这个递归过程是否会永不停止)等。

[编辑] 基本操作

[编辑] 查找

SBT的查找操作与普通BST完全相同。下面的过程将返回指向目标节点的指针。

Search(x,k)

1     if x=NULL or k=key[x] //找到了目标节点或目标节点不存在则返回x
2        then return x
3     if k<key[x]
4        then return Search(left[x],k)
5     else return Search(right[x],k)

[编辑] 取大/取小

由于SBT本身已经维护了size,因此这两项可用Select操作完成。

[编辑] 后继

SBT的后继操作与普通BST完全相同。

[编辑] 前趋

SBT的前趋操作与普通BST完全相同。它与上面的后继操作对称。

[编辑] 插入

SBT的插入操作很简单。它仅仅比普通BST的多出了一个Maintain操作和对s的简单维护。下面这个过程将一个节点v插入SBT中。

Insert (t,v)

1     If t=0 then
2        t ← v
3     Else
4        s[t] ← s[t]+1
5         If v<key[t] then
6              Insert(left[t],v)
7         Else
8              Insert(right[t],v)
9     Maintain(t,v≥key[t])

[编辑] 删除

与普通维护size域的BST删除相同。
关于无需Maintain的说明by sqybi:
在删除之前,可以保证整棵树是一棵SBT。当删除之后,虽然不能保证这棵树还是SBT,但是这时整棵树的最大深度并没有改变,所以时间复杂度也不会增加。这时,Maintain就显得是多余的了。

[编辑] 动态顺序统计操作

由于SBT本来就是靠着size域来维持平衡的,当我们进行动态顺序统计操作时,我们就无需去“额外”维护一个size域来进行数据结构的扩张。这样,以下操作就与其他高级BST扩张后的动态顺序统计操作完全一样了。

[编辑] 检索具有给定排序的元素

下面这个过程将返回一个指向以x为根的子树中包含第i小关键字的节点的指针。

Select(x,i)

1     r ← size[left[x]] + 1
2     if(i=r)
3          then return x
4     else if i<r
5          then return Select(left[x],i)
6     else return Select(right[x],i-r)


 实现代码:
 #include <fstream>
 
 using namespace std;
 
 ifstream fin("cashier.in"); 
 ofstream fout("cashier.out"); 
 const unsigned int MAX_N=100001; 
 int ZUISHAO;     //最低工资 
 int ADD_PAY=0; 
 unsigned int C_NUM=0; 
 int front = 0; 
 struct node 
 { 
   int key; 
   int size, llink, rlink; 
 }OIER[MAX_N]; 
 void LeftRotate(int &x)//左旋 
 { 
   int y = OIER[x].rlink; 
   if (y == 0) return; 
   OIER[x].rlink = OIER[y].llink; 
   OIER[y].llink = x; 
   OIER[y].size = OIER[x].size; 
   OIER[x].size = OIER[OIER[x].llink].size+OIER[OIER[x].rlink].size+1; 
   x = y; 
 } 
 void RightRotate(int &x)//右旋 
 { 
   int y = OIER[x].llink; 
   if (y == 0) return; 
   OIER[x].llink = OIER[y].rlink; 
   OIER[y].rlink = x; 
   OIER[y].size = OIER[x].size; 
   OIER[x].size = OIER[OIER[x].llink].size+OIER[OIER[x].rlink].size+1; 
   x = y; 
 } 
 void Maintain(int &root, bool flag)//维护 SBT 树 
 { 
   if (!root) return; 
   if (flag) 
   { 
       if(OIER[root].llink && OIER[OIER[root].llink].llink 
           && (!OIER[root].rlink || OIER[OIER[OIER[root].llink].llink].size > OIER[OIER[root].rlink].size)) 
           RightRotate(root); 
       else if(OIER[root].llink && OIER[OIER[root].llink].rlink 
           && (!OIER[root].rlink || OIER[OIER[OIER[root].llink].rlink].size > OIER[OIER[root].rlink].size)) 
       { 
           LeftRotate(OIER[root].llink); 
           RightRotate(root); 
       } 
       else return; 
   } 
   else 
   { 
       if (OIER[root].rlink && OIER[OIER[root].rlink].rlink 
           && (!OIER[root].llink || OIER[OIER[OIER[root].rlink].rlink].size > OIER[OIER[root].llink].size)) 
           LeftRotate(root); 
       else if (OIER[root].rlink && OIER[OIER[root].rlink].llink 
           && (!OIER[root].llink || OIER[OIER[OIER[root].rlink].llink].size > OIER[OIER[root].llink].size)) 
       { 
           RightRotate(OIER[root].rlink); 
           LeftRotate(root); 
       } 
       else return; 
   } 
   Maintain(OIER[root].llink, true); 
   Maintain(OIER[root].rlink, false); 
   Maintain(root, true); 
   Maintain(root, false); 
 } 
 void Insert(int &root, int x)//插入关键字 x 
 { 
   if (!root) 
   { 
       root = ++front; 
       OIER[root].key = x; 
       OIER[root].size = 1; 
   } 
   else 
   { 
       ++OIER[root].size; 
       Insert(x <= OIER[root].key ? OIER[root].llink : OIER[root].rlink, x); 
       Maintain(root, x <= OIER[root].key); 
   } 
 } 
 int Delete(int &root)//删除 
 { 
    int t=0,sum=0; 
    if(!root) return root; 
    if(OIER[root].key+ADD_PAY<ZUISHAO) { 
 sum+=OIER[OIER[root].llink].size+1; 
 OIER[root].size-=sum; 
 OIER[root].llink=0; 
 t=Delete(OIER[root].rlink); 
 sum+=t; 
 OIER[root].size-=t; 
    OIER[OIER[root].rlink].size=OIER[root].size; 
 root=OIER[root].rlink; 
 } 
    else { 
         t=Delete(OIER[root].llink); 
         sum=t; 
         OIER[root].size-=t; 
         } 
    return sum; 
 }       
 int Select(int R, int x)//返回第 x 大的元素 
 { 
   if(OIER[R].rlink==0)OIER[OIER[R].rlink].size=0; 
   int r = OIER[OIER[R].rlink].size+1; 
   if (x<r) return Select(OIER[R].rlink, x); 
   else 
   if (x>r) return Select(OIER[R].llink, x-r); 
   if(x==r) return OIER[R].key; 
   } 
 
 int main(void) 
 { 
   unsigned int N; 
   char command; 
   int pay,root=0; 
   int i; 
   fin>>N>>ZUISHAO; 
   for(i=1;i<=N;i++) 
      { 
         fin>>command>>pay; 
         if(command=='I'){ 
                 if(pay>=ZUISHAO)Insert(root,pay-ADD_PAY);                                               
                          } 
         if(command=='F'){ 
                          if(pay>OIER[root].size) fout<<-1<<endl; 
                          else   fout<<Select(root, pay)+ADD_PAY<<endl; 
                          } 
         if(command=='A')ADD_PAY+=pay; 
         if(command=='S'){ 
                          ADD_PAY-=pay; 
                          C_NUM+=Delete(root); 
                          } 
        } 
    fout<<C_NUM<<endl; 
   return 0;
  }

Size Balanced Tree(SBT)平衡二叉树 定义数据结构 struct SBT { int key,left,right,size; } tree[N];key:存储值,left,right:左右子树,size:保持平衡最终要的数据,表示子树的大小 SBT树的性质 定义一个节点x,同时满足下面两个条件 (a)、x.left.size >= max(x.right.right.size, x.right.left.si 阅读详情

相关推荐

节点大小平衡树((Size Balanced Tree, c++和python源码)

我自己写的SBTree的实现 参考了http://www.nocow.cn/index.php/Size_Balanced_Tree的算法 声明:此源码可以用于商业用途,但请注明来源于random

Size Balanced Tree

 今天上网搜索关于红黑树的资料时,发现一种新的平衡二叉树(SBT),据说各方面性能很好,先摘录在此,以后再细看。 Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山纪念中学的陈启峰于2006年底完成,并在Winter Camp 2007中发表。由于SBT的拼写很容易找到中文谐音,它常被中国的OIer们戏称为“傻X树”、“Super BT”等。但它

Make Progress Everyday! 1510

陈启峰《Size Balanced Tree》 pdf英文版

“Size Balanced Tree (abbr. SBT) 是一种通过大小来保持平衡的BST。” SBT资料——陈启峰本人 pdf英文版 若需参考更多资料,请下载“陈启峰《Size Balanced Tree》 ppt中文版”

SizeBalanceTree详解(含代码实现)

+1.SBT树的概念及其相关性质 Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山记念中学的陈启峰于2006年末完成,php 并在Winter Camp 2007中发表。因为SBT的拼写很容易找到中文谐音, 它常被中国的Oler们戏称为 “傻X树”、html “Super BT”等。但它的性能并不SB,编写起来也并不BT。偏偏相反,SBT易于实现,且据陈启峰论文中所言 ,node “这是目前为止速度最快的高级二叉搜索树”。它能在O(logn)的时间..

qq_56999918的博客 2030

SBT陈启峰(高级数据结构)

由中山纪念中学陈启峰写的介绍SBT的课件 有其原理及重要部分的代码 是他弄的一个很好很简单的高级数据结构(可与AVL treap splay等媲美)

光伏电站发电功率预测实战:从基础物理模型到LSTM时间序列分析

本文系统介绍了光伏电站发电功率预测的实战方法,从基础的物理晴空模型到先进的LSTM时间序列分析。通过结合电工杯等竞赛中常用的代码与模型,详细阐述了如何利用历史数据和数值天气预报构建高精度预测体系,并针对阴雨天气等预测瓶颈提出了分场景建模与模型融合等优化策略,为电站运维和电网调度提供可靠的数据支持。

pp12345的博客 217

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

今天来种一种个人最喜欢的SBTree Size Balanced Tree,顾名思义是尽量维护子树大小(结点个数)平衡的树。 也就是当左右子树失衡(某个结点的size比它兄弟的孩子的size都要小)时就得进行旋转操作,来使子树的size始终保持在一个较为平衡的状态。 自平衡操作 SBT的自平衡维护比较简单,只有两种旋转操作而且是最基本的选择操作:简单左旋和简单右旋: 例题&...

Keyu Tian's blog 973

SAP FICO 银企直联实战:从配置到异常处理的全流程解析

本文详细解析了SAP FICO银企直联的实战配置与异常处理全流程,涵盖银行主数据搭建、支付类配置、银行接口适配等关键步骤。通过实际案例分享,帮助用户掌握实时付款、余额监控和自动对账等核心功能,提升企业财务效率与安全性。特别针对常见问题如凭证重复付款、前置机UUID冲突等提供了实用解决方案。

weixin_29215815的博客 664

傻逼树SBT:Size Balanced Tree的实现原理,增删改查,调平衡

为了调平衡,咱们必须要有左旋函数(leftRotate)、右旋函数(rightRotate) 调平每次变化了哪些节点,就需要再次检查和调平(maintain),maintain函数需要分LL,RR,LR,RL四种状况 查傻逼树SBT中是否有节点key,并返回离key最近的不为null的那个节点(pre),查询key函数:findLeastKeyNode 返回傻逼树SBT整体有多少个节点?size()函数 判断傻逼树是否为空树?isEmpty() put函数是更新,或者新增--没有返回值,内部操作add:ke

weixin_46838716的博客 1087

实战避坑:在Ubuntu 22.04上配置NVIDIA GPU Direct RDMA时,必须搞清的P2P DMA与IOMMU那些事

本文深入探讨在Ubuntu 22.04上配置NVIDIA GPU Direct RDMA时P2P DMA与IOMMU的关键问题,解析PCIe架构中的地址转换、P2P DMA与标准DMA的区别,以及IOMMU对性能的影响。通过实战案例和调优建议,帮助用户避免常见配置陷阱,提升AI训练集群的数据传输效率。

weixin_33720078的博客 447

PyCharm与MicroPython联手:打造高效ESP32开发环境

本文详细介绍了如何使用PyCharm与MicroPython打造高效的ESP32开发环境。通过配置PyCharm插件、刷写MicroPython固件以及实战示例,帮助开发者快速上手嵌入式Python开发,显著提升物联网项目的开发效率。

weixin_29169899的博客 384

POJ 2761 SBT(size balanced tree)

题意:给出n个数字m个询问,每次询问在范围[a,b]内第k小数字是多少,并输出。 思路:网上的最优解法是划分树或者归并树,最近学了SBT(size balanced tree),正好里面有类似的select(t,k)选择第k小数的操作,所以就用SBT写了一下。 #include #include #include #include #include #include #incl

just_water 1299

达梦数据库(DM)的备份与恢复功能

本文系统介绍了达梦数据库(DM)的备份与恢复功能,主要包括作业系统和物理/逻辑备份还原两大模块。作业系统部分详细说明了通过代理环境创建定时备份和删除备份作业的步骤;物理备份还原部分阐述了联机和脱机备份方式,包括数据库、表空间、表和归档的备份还原操作;逻辑备份还原部分介绍了dexp/dimp工具的使用方法及四种级别的导入导出功能。文章还介绍了图形化管理工具进行备份还原的操作流程,全面覆盖了达梦数据库的数据保护方案,为数据库管理员提供了详细的技术指导。

weixin_48812832的博客 1214

Size Balanced Tree(SBT) 模板

首先是从二叉搜索树开始,一棵二叉搜索树的定义是: 1.这是一棵二叉树; 2.令x为二叉树中某个结点上表示的值,那么其左子树上所有结点的值都要不大于x,其右子树上所有结点的值都要不小于x。 由二叉搜索树的第二条定义,可以很方便地利用这种特点在二叉树中以O(logn)的渐进复杂度完成插入、查找、删除等操作。 但是这里还是有个问题,就是弄不好的话,一棵普通的二叉搜索树经过多次修改操作...

weixin_30321709的博客 175

YOLOv8 | 损失函数改进,最新提出的Shape-IoU,有效涨点

作为检测器定位分支的重要组成,边框回归损失在目标检测任务中发挥巨大作用。现有的边框回归方法,通常考虑了GT框与预测框之间的几何关系,通过使用边框间的相对位置与相对形状等计算损失,而忽略了边框其自身的形状与尺度等固有属性对边框回归的影响。为了弥补现有研究的不足,本文提出聚焦边框自身形状与尺度的边框回归方法。首先我们对边框回归特性进行分析,得出边框自身形状因素与尺度因素会对回归结果产生影响。

kay_545 1916

OpenCV实战系列——图像线条提取

基于内容的图像分析,需要从构成图像的像素集合中提取有意义的特征。轮廓、线条、区域等是基本的图像基元,可用于描述图像中包含的元素。本节将介绍如何提取重要的图像线条特征。

m0_58523831的博客 1万+

SBT(Size Balanced Tree平衡树的一种)

这次要学习平衡树被称为SBT,其全称为Size Balanced Tree,由我国的陈启峰同学所提出。 它是一种高度平衡的二叉树。其基本思想是根据每颗子树的大小,来对二叉树的形态进行调整。 采用s[]数组来记录每颗子树的大小,比如s[T]就表示以T为根节点的子树的节点总数。特别的,如果T为空,那么S[T]=0。 SBT通过两个性质来保证树的平衡性: s[T.right]≥s

Renaissancer的专栏 1375

马达种类全解析:VCM、Stepper、Piezo 在手机相机中的驱动原理与工程差异

在现代手机影像系统中,马达承担着核心成像组件的动态调节任务,如自动对焦(AF)、光学防抖(OIS)以及变焦调节。目前主流采用三类驱动器件:VCM(Voice Coil Motor)、Stepper(步进马达)、Piezo(压电马达)。不同马达方案在结构复杂度、响应速度、功耗、驱动方式与模组厚度适配等方面差异显著,对成像系统的性能表现有直接影响。本文将结合最新旗舰设备的应用现状,系统剖析这三类驱动马达的工作原理、架构特点与工程应用经验,为工程实践中选型与调试提供参考。

努力分享一些人工智能、计算机视觉、影像等相关的知识干货! 3793

Size Balanced Tree Sbt模板

#include<bits/stdc++.h> using namespace std; const int maxn = 200000 + 10;struct SBT { int cnt; int c[maxn][2], key[maxn], size[maxn]; void init() { cnt = 0; memset(c, 0, si

Free keyboard 跳动的键盘 424

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

SBT(Size balanced tree)

http://www.docin.com/p-47348009.html#

qwe20060514的专栏 572

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

【学习笔记】Size-Balanced Tree(SBT)

伞兵-Tree,听名字就很适合我🤤

七代目鸽影 303

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Java基础 - 节点自平衡树(Size Balanced Tree,简称SBT)

package com.yc.tree; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Deque; import java.util.List; public class SizeBalancedTree >{ public class Node{ //data域:存放数据项 T

ApatheCrazyFan的博客 1587

Size Balanced Tree(SBT树)整理

Size Balanced Tree(简称SBT)是一种平衡二叉搜索树,它通过子树的大小s[t]来维持平衡性质。它支持很多动态操作,并且都能够在O(log n)的时间内完成。 我做了简单的整理。挺好理解的。

细语呢喃 1万+

SBT(Size Balanced Tree)

1. 二叉搜索树   二叉搜索树,是一种能实现动态查询第k大或查询,某数在序列中的排名的树形结构,在数据较为随机的情况下,它的期望复杂度为O(logn),但是若是数据为一个有序序列,那么该二叉搜索树,将会变成一条链,此时每次查找的复杂度将会变成复杂度为O(n) 2. SBT   针对上述问题,为了能使复杂度回到O(logn),我们在每次插入操作后,对树形进行高效的调整使之变的较为平衡。这时树...

weixin_30875157的博客 186

SBT——Size Balanced Tree

这个数据结构是我在做一道蓝桥杯的题目(逆序对)时了解到的,本来打算搞完题目来对SBT整理一下,就是对它的各种操作小小的分析一下,刚开始尝试过自己去分析,但是还是没能分析出来。后来就看到了下面这篇博客,看完之后我就不打算再去分析了(扎心了),只能说自己的数学功底太差了,所以打算只掌握好各个操作的实现方式,对于具体的数学分析就了解了解就好了。 文章转载于:https://www.cnblogs.com...

Dripping Blog 154

SBT(Size Balanced Tree)2016.9.6

参考:陈启峰《Size Balanced Tree》 一、定义 节点大小平衡树( Size Balanced Tree,缩写:SBT)是一种自平衡二叉查找树 它是由中国广东中山纪念中学的陈启峰发明的 陈启峰于 2006 年底完成论文《Size Balanced Tree》,并在 2007 年的全国青少年信息学奥林匹克竞赛冬令营中发表 由于 SBT 的拼写很容易找到中文谐音,它常被中国

追风蹑影 1115
上一篇: SB tree (Size Balanced Tree)
下一篇: QTCreater调试时提示ptrace不允许的操作
SprintfWater
博客等级 码龄15年 242粉丝 139原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值