【学习笔记】SBT学习笔记

最新推荐文章于 2022-08-16 15:59:44 发布
最新推荐文章于 2022-08-16 15:59:44 发布
阅读量951 收藏 3
点赞数 1
原文链接：http://www.cnblogs.com/fpjo/p/10816808.html
版权

[## 一、什么是SBT

SBT , 即 Size Balanced Tree，是一种平衡二叉排序树，根据其节点中 Size 域大小进行平衡，由陈启峰于2006年在冬令营提出

二、为什么写SBT：

  1. 书写简单：在常用的平衡树（ Spaly , Treap , AVL , Red-Black Tree ……）中，SBT的码量较小，只是在原有 BST 的基础上加入 Maintain 函数以及对Size域的一些调整.

  2. 理解简单：SBT 的基本思想相对于别的平衡树（ Splay , AVL ,RBT……）来说更加容易被初学者所接受

  3. 效率较高：其核心算法 Maintain 的复杂度平摊为O(1)(不会证)，（证明过程可见论文），且其趋近于一棵完美的二叉排序树。

三、平衡性质

SBT总满足：

1.Size[Right[t]] >= Size[Left[Left[t]]],Size[Right[Left[t]]]
2.Size[Left[t]] >= Size[Left[Right[t]]],Size[Right[Right[t]]]

翻译过来即：
一个节点的左右儿子的子树大小总不小于其兄弟的儿子（侄子）的子树大小

而这种平衡性质便是以 Maintain 来维持

四、基本操作

0、声明：

int n, root, tot;
int Right[100100], Left[100100], Size[100100], Val[100100];

1、旋转

实现 Maintain 的基本操作即 左旋 与 右旋

左右旋.PNG

左旋即将操作点（L）变为其先前右儿子(P)的左儿子，先前右儿子(P)变为操作点(L)的父亲，同时保持BST性质。（如图，先前P为L的右儿子，现在L为P的左儿子）

void Left_rotate(int &p)//
{
    int k = Right[p];
    Right[p] = Left[k];//将p的右儿子变为其原本右儿子的左儿子
    Left[k] = p;//将p原本的右儿子的左儿子变为p
    Size[k] = Size[p];//k取代p的Size值
    Size[p] = Size[Right[p]] + Size[Left[p]] + 1;//计算p的大小值
    p = k;
}

右旋即将操作点(P)变为其先前左儿子(L)的右儿子，先前左儿子(L)变为操作点(P)的父亲,同时保持BST性质。（如图，先前L为P的左儿子，现在P为L的右儿子）

void Right_rotate(int &p)//右旋与左旋相反
{
    int k = Left[p];
    Left[p] = Right[k];
    Right[k] = p;
    Size[k] = Size[p];
    Size[p] = Size[Right[p]] + Size[Left[p]] + 1;
    p = k;
}

2、Maintain

在什么情况下会使用 Maintain 呢？就是在性质1或2不满足，平衡树不平衡。所以，当一棵 SBT 变化的时候会使用 Maintain。
在所有的基本操作中，改变 BST 的也就两个,Insert 和 Delete。而 Delete 是不改变树的形态的。

虽然它(Delete)会破坏SBT的结构，但因为使用 Insert 操作，它还是一棵高度为O(log2 K)的 SBT 。这里的 K 是所有插入节点的个数，而不是当前节点的个数

而插入一个节点后中，我们需要对插入过程中经过的点进行 Maintain 操作，否则以这些点为根的子树有可能不平衡。
Maintain(p）指的是调整以 p 为根的 SBT 。

我们可以发现，性质1，2是基本对称的，所以我们可以先讨论性质1，再类比性质2
性质1.a: 如图，Size[Right[t]] < Size[Left[Left[t]]],
1.PNG
(1）为了配平，我们可以先将L进行右旋操作，变为下图;
2.PNG
(2)如图，有可能Size[C] or Size[D] 大于 Size[B] ,所以需要再次 Maintain(right[p])(p在上一次操作中指向了L);

(3)调整完后，我们会发现以L为根节点的子树仍有可能不平，所以需要继续执行Maintain(p);

性质1.b: 如图，Size[Right[t]] < Size[Right[Left[t]]],
3.PNG
(1)先调整以L为根节点的子树，对L执行左旋操作，变为下图
4.PNG
(2)再对P执行右旋操作，变为下图。
5.PNG
(3)我们可以发现，虽然这棵树炒鸡不平衡，但子树 A，E，F，R只是挪了挪位置，其平衡性质并没有改变，所以我们只需要再Maintain(L),Maintain(P),Maintain(B)即可。

性质2.a:Size[Left[t]] < Size[Right[Right[t]]]:
与性质1.a刚好相反，可以自行画图理解。

性质2.b:Size[Left[t]] < Size[Left[Right[t]]]:
与性质1.b刚好相反，可以自行画图理解。
其实是我不想画图了

综上，我们可以大致的写出如下程序：

void Maintian(int &p)
{
    if (Size[Left[Left[p]]] > Size[Right[p]])
    {
        Right_rotate(p);
        Maintian(Right[p]);
        Maintian(p);
        return；
    }
    if (Size[Right[Left[p]]] > Size[Right[p]])
    {
        Left_rotate(Left[p]);
        Right_rotate(p);
        Maintian(Left[p]);
        Maintian(Right[p]);
        Maintian(p);
        return；
    }
    if (Size[Left[Left[p]]] > Size[Right[p]])
    {
        Left_rotate(p);
        Maintian(Left[p]);
        Maintian(p);
        return；
    }
    if (Size[Right[Left[p]]] > Size[Right[p]])
    {
        Right_rotate(Right[p]);
        Left_rotate(p);
        Maintian(Left[p]);
        Maintian(Right[p]);
        Maintian(p);
        return；
    }
    return;
}

不过我们还可以有另一种写法，即用一个bool参数flag来表示其究竟是违反了性质1还是性质2，并且将一些重合的操作写在外面

void Maintian(int &p, bool flag)
{
    if (!flag)
    {
        if (Size[Left[Left[p]]] > Size[Right[p]])
            Right_rotate(p);
        else if (Size[Right[Left[p]]] > Size[Right[p]])
        {
            Left_rotate(Left[p]);
            Right_rotate(p);
        }
        else
            return;
    }
    else
    {
        if (Size[Right[Right[p]]] > Size[Left[p]])
            Left_rotate(p);
        else if (Size[Left[Right[p]]] > Size[Left[p]])
        {
            Right_rotate(Right[p]);
            Left_rotate(p);
        }
        else
            return;
    }
    Maintian(Left[p], false);//以Left[p]为根的子树中，左子树定比右子树的儿子子树的大小要大
    Maintian(Right[p], true);//以Right[p]为根的子树中，右子树定比左子树的儿子子树的大小要大
    Maintian(p, true);
    Maintian(p, false);
}

至于 Maintain 的效率云云，可见陈启峰大佬的论文：中文译文版 英文版

3、Insert

与 BST 差不多，只是多加了 Maintain 与 对Size的处理，故直接放代码：

void Insert(int &p, int &v)
{
    if (!p)
    {
        p = ++tot;
        Val[++p] = v;
        Size[p] = 1;//Size
        return;
    }
    Size[p]++;//Size
    if (v < Val[p])
        Insert(Left[p], v);
    else
        Insert(Right[p], v);
    Maintian(p, v >= Val[p]);//Maintain
}

4、Delete
与 BST 差不多，只需再注意对 Size 的处理，直接放代码：

int Delete(int &p, int x)
{
    Size[p]--;
    int tmp;
    if (x == Val[p] || (x < Val[p] && !Left[p]) || (x > Val[p] && !Right[p]))
    {
        tmp = Val[p];
        if (!Left[p] || !Right[p])
            p = Left[p] + Right[p];
        else
            Val[p] = erase(Left[p], Val[p] + 1);
        return tmp;
    }
    if (x < Val[p])
        tmp = erase(Left[p], x);
    else
        tmp = erase(Right[p], x);
    return tmp;
}

5、Rank：

查找一个值在树中的大小排名，细节在代码中

int Rank(int &p, int &v)
{
    if (p == 0)
        return 1;
    if (v <= Val[p])
        return Rank(Left[p], v);
    else
        return Size[Left[p]] + 1 + Rank(Right[p], v);
}

6、Select：

查找一个排名在树中的具体值，细节在代码中：

int Select(int &p, int k)
{
    if (Size[Left[p]] + 1 == k)
        return Val[p];
    if (k <= Size[Left[p]])
        return Select(Left[p], k);
    else
        return Select(Right[p], k - 1 - Size[Left[p]]);
}

7、Find:

查找一个值是否存在

bool Find(int &p, int &v)
{
    if (p == 0)
        return 0;
    if (v < Val[p])
        return Find(Left[p], v);
    else if (v == Val[p])
        return 1;
    else
        return Find(Right[p], v);
}

8、找前驱/后继：

细节在代码中：

int GetLast(int &p, int &v)//前驱
{
    if (p == 0)
        return v;
    int x;
    if (v <= Val[p])
        return GetLast(Left[p], v);
    else
    {
        x = GetLast(Right[p], v);
        if (x == v)
            x = Val[p];
        return x;
    }
}
int GetNext(int &p, int &v)//后继
{
    if (p == 0)
        return v;
    int x;
    if (v >= Val[p])
        return GetNext(Right[p], v);
    else
    {
        x = GetNext(Left[p], v);
        if (x == v)
            x = Val[p];
        return x;
    }
}

9、完整代码：

#include <bits/stdc++.h>
using namespace std;
int n, root, tot;
int Right[100100], Left[100100], Size[100100], Val[100100];
void Right_rotate(int &p)
{
    int k = Left[p];
    Left[p] = Right[k];
    Right[k] = p;
    Size[k] = Size[p];
    Size[p] = Size[Right[p]] + Size[Left[p]] + 1;
    p = k;
}
void Left_rotate(int &p)
{
    int k = Right[p];
    Right[p] = Left[k];
    Left[k] = p;
    Size[k] = Size[p];
    Size[p] = Size[Right[p]] + Size[Left[p]] + 1;
    p = k;
}
void Maintian(int &p, bool flag)
{
    if (!flag)
    {
        if (Size[Left[Left[p]]] > Size[Right[p]])
            Right_rotate(p);
        else if (Size[Right[Left[p]]] > Size[Right[p]])
        {
            Left_rotate(Left[p]);
            Right_rotate(p);
        }
        else
            return;
    }
    else
    {
        if (Size[Right[Right[p]]] > Size[Left[p]])
            Left_rotate(p);
        else if (Size[Left[Right[p]]] > Size[Left[p]])
        {
            Right_rotate(Right[p]);
            Left_rotate(p);
        }
        else
            return;
    }
    Maintian(Left[p], false);
    Maintian(Right[p], true);
    Maintian(p, true);
    Maintian(p, false);
}
void Insert(int &p, int &v)
{
    if (!p)
    {
        p = ++tot;
        Val[++p] = v;
        Size[p] = 1;
        return;
    }
    Size[p]++;
    if (v < Val[p])
        Insert(Left[p], v);
    else
        Insert(Right[p], v);
    Maintian(p, v >= Val[p]);
}
int Delete(int &p, int x)
{
    Size[p]--;
    int tmp;
    if (x == Val[p] || (x < Val[p] && !Left[p]) || (x > Val[p] && !Right[p]))
    {
        tmp = Val[p];
        if (!Left[p] || !Right[p])
            p = Left[p] + Right[p];
        else
            Val[p] = erase(Left[p], Val[p] + 1);
        return tmp;
    }
    if (x < Val[p])
        tmp = erase(Left[p], x);
    else
        tmp = erase(Right[p], x);
    return tmp;
}
int Rank(int &p, int &v)
{
    if (p == 0)
        return 1;
    if (v <= Val[p])
        return Rank(Left[p], v);
    else
        return Size[Left[p]] + 1 + Rank(Right[p], v);
}
int Select(int &p, int k)
{
    if (Size[Left[p]] + 1 == k)
        return Val[p];
    if (k <= Size[Left[p]])
        return Select(Left[p], k);
    else
        return Select(Right[p], k - 1 - Size[Left[p]]);
}
int GetLast(int &p, int &v)
{
    if (p == 0)
        return v;
    int x;
    if (v <= Val[p])
        return GetLast(Left[p], v);
    else
    {
        x = GetLast(Right[p], v);
        if (x == v)
            x = Val[p];
        return x;
    }
}
int GetNext(int &p, int &v)
{
    if (p == 0)
        return v;
    int x;
    if (v >= Val[p])
        return GetNext(Right[p], v);
    else
    {
        x = GetNext(Left[p], v);
        if (x == v)
            x = Val[p];
        return x;
    }
}
void LDR(int &p)
{
    if (p == 0)
        return;
    LDR(Left[p]);
    printf("%d ", Val[p]);
    LDR(Right[p]);
    return;
}
bool Find(int &p, int &v)
{
    if (p == 0)
        return 0;
    if (v < Val[p])
        return Find(Left[p], v);
    else if (v == Val[p])
        return 1;
    else
        return Find(Right[p], v);
}
int Max(int &p)
{
    if (Right[p] != 0)
        return Max(Right[p]);
    else
        return Val[p];
}
int Min(int &p)
{
    if (Left[p] != 0)
        return Min(Left[p]);
    else
        return Val[p];
}

int main()
{
    scanf("%d", &n);
    int k, v;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &k, &v);
        if (k == 1)
            Insert(root, v);
        else if (k == 2)
            Delete(root, v);
        else if (k == 3)
            printf("%d\n", Rank(root, v));
        else if (k == 4)
            printf("%d\n", Select(root, v));
        else if (k == 5)
            printf("%d\n", GetLast(root, v));
        else if (k == 6)
            printf("%d\n", GetNext(root, v));
        else if (k == 7)
            LDR(root);
    }
    return 0;
}

四、推荐习题：

1 【模板】普通平衡树
2、郁闷的出纳员

五、关于 SBT 的几个疑惑暂时只有一个

1、为啥没多少人用SBT？？？

六、参考文献：

1、感谢陈启峰大佬的论文（虽然我并没有找到原版）
2、感谢 I_AM_HelloWord，olinr 的博客

转载于:https://www.cnblogs.com/fpjo/p/10816808.html

weixin_30892037
关注
算法笔记——SBT
m0_67142204的博客
08-26 612
SBT
sbt学习笔记
anjsoft's it blog
04-25 1034
1、自动生成build.sbt文件 $sbt >set name := "anjsoft" （:= 表示 sbt.Setting["name"]="anjsoft"） >session save 2、 ModuleID = groupId % artifact % version % configuration "org.specs2" %% "specs2" % "1.6.1" %
SBT
拱头的专栏
03-22 1670
常用命令 clean 删除所有生成的文件 （在 target 目录下）。 compile 编译源文件（在 src/main/scala 和 src/main/java 目录下）。 test 编译和运行所有测试。 console 进入到一个包含所有编译的文件和所有依赖的 classpath 的 Scala 解析器。输入 :quit， Ct
Size Balanced Tree(SBT) 类模板C++实现(持续更新)
zdy0_2004的专栏
10-22 635
Size Balanced Tree(SBT) 类模板C++实现(持续更新) http://blog.csdn.net/sprintfwater/article/details/8316268        Size Balanced Tree是OI神犇陈启峰发明的，据说是目前最高效的二叉查找树，搞了好长时间终于弄出来了～这个版本的SBT本来是打算用来实现STL的set
6.编写Spark独立应用程序(sbt)（华为云学习笔记，Spark编程基础，大数据）
GCPOP的博客
06-13 1490
编写Spark独立应用程序(sbt) ① 使用Scala语言编写Spark独立应用程序； ② 使用sbt工具对Spark应用程序进行编译打包。 实验原理 -> sbt SBT是一个现代化的构建工具。虽然它由Scala编写并提供了很多Scala便利，但它是一个通用的构建工具。可以使用sbt工具，对采用Scala语言编写的Spark应用程序进行编译打包。1. 安装sbt工具 下载安装包请打开浏览器访问如下链接进行下载拷贝代码 http://file.ictedu.com/fileserver/big_data_
第97讲：使用SBT开发Akka第一个案例环境搭建详解学习笔记
slq1023的博客
09-10 1786
第97讲：使用SBT开发Akka第一个案例环境搭建详解学习笔记 使用IDEA搭建scala SBT开发环境 1.下载IDEA. Windows版：http://download-cf.jetbrains.com/idea/ideaIC-14.1.4.exe2.IDEA默认没有安装SBT，所以需要安装SBT。打开IDEA,选择File->Settings 选择Plugins,在搜索栏打入S
Spark 学习笔记（一）使用Intellij Idea编写Spark应用程序（Scala+SBT）
zhaoaiqq的博客
07-31 1291
本文基于踩了无数坑和这篇本地部署的基础上写成。 本文适用于云主机搭建的spark环境下运行spark程序。 运行环境 阿里云主机 Linux部署 Spark 2.3.1 本地JDK 1.8 Intellij Idea (Version 2018) 安装Scala插件 安装Scala插件,该Scala插件自带SBT工具。如果已经安装Scala插件，即可跳过此步骤 ...
Spark 源码编译完整教程（maven编译+sbt编译+编译工具包+操作步骤笔记+依赖包下载镜像设置）
03-08
自己学习并应用Spark一段时间后，由于需要改源代码，就研究了下怎么编译源码，成功编译后，记录下了编译的步骤和遇到的问题，例如编译过程中，下载大量的依赖包，默认从国外下载，非常慢，可能要编译好几个小时，...
sbt-0.13.8 for windows
10-16
官网找不到此版本，好了很久终于找到了，分享给大家。
SBT和AVL的C++模板实现 最新版
04-11
SBT和AVL的C++模板实现，提供了与stl中的set类似接口，支持迭代器，并提供了set所不支持的动态顺序统计功能，内含参考手册。
sbt-1.2.7windows最新安装包
12-01
sbt-1.2.7windows最新安装包，Scala编译插件
SBT简介
热门推荐
逝无痕——kaidy
03-31 1万+
文章目录一、关于SBT二、为什么使用SBT三、SBT工程目录结构四、SBT交互模式 一、关于SBT SBT是一个现代构建工具。它是用Scala编写的，并且针对Scala也提供了很多方便快捷的功能。它也是一个通用的构建工具。 二、为什么使用SBT 强大的依赖管理功能 Ivy用来管理依赖 一个只会根据需求更新的模型 所有任务的创建都支持Scala 可连续执行命令 可以在工程的上下文里启动REP...
Size Balanced Tree
Make Progress Everyday!
08-02 1319
 今天上网搜索关于红黑树的资料时，发现一种新的平衡二叉树（SBT），据说各方面性能很好，先摘录在此，以后再细看。 Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山纪念中学的陈启峰于2006年底完成，并在Winter Camp 2007中发表。由于SBT的拼写很容易找到中文谐音，它常被中国的OIer们戏称为“傻X树”、“Super BT”等。但它
sbt教程
zpc10105的专栏
10-22 1302
sbt类似maven，非常简单，想必大家接触它都是使用其编译scala。本文仅以构建scala项目为例，java项目原理一致，不多敖述。 1.Hello World 直接从源码构建 一个sbt工程可以只包含一个源文件，尝试建立一个文件夹名为hello，内部生成源文件hw.scala。 object Hi { def main(args: Array[String]) = println
sbt入门
a18792721831的博客
02-10 2200
sbt入门sbt 介绍sbt 下载sbt 安装sbt 入门 -- helloworldsbt 目录结构sbt 命令总结 sbt 介绍 sbt是什么？ sbt到底是什么，在网上找找，似乎找不到一个非常准确，而且大家都认可的定义。 我自己对sbt的理解没有那么复杂，主要是以下这些。 sbt翻译为simple build tool，这是一种较为直观的，而且比较符合sbt官网的一些信息： 在官网的首页上第一条就说明sbt是一个简单的构建工具，所以翻译为simple build tool似乎也没有什么不妥。 不过就
SBT 综述
孟岩
08-16 3533
SBT 综述---迈向 Web3 的重要观念突破作者：Solv 研究组导言5 月初 SBT 论文发表之后，迅速成为整个 Web3 领域最热门的话题之一。我本人在数字资产领域学习实践多年，对于 SBT 一方面感到兴奋，另一方面也多少有些怅然。兴奋是容易理解的，怅然何解呢？主要是因为，在创建去中心化的信誉体系这个问题上，类似 SBT 这样的思路，之前也有人提出来过，甚至有些想法也很精彩。然而，...
深入理解RMAN恢复管理器：核心概念与操作
"这篇文档是关于Oracle数据库的RMAN（Recovery Manager）恢复管理器的学习笔记，涵盖了其基本概念、体系结构以及常用命令。RMAN是Oracle提供的一种强大的数据库备份和恢复工具，它能帮助管理员执行数据库的完整备份...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值