三大平衡树（Treap + Splay + SBT）总结+模板

Treap树

　　核心是利用随机数的二叉排序树的各种操作复杂度平均为O(lgn)

Treap模板：

#include <cstdio>

#include <cstring>

#include <ctime>

#include <iostream>

#include <algorithm>

#include <cstdlib>

#include <cmath>

#include <utility>

#include <vector>

#include <queue>

#include <map>

#include <set>

#define max(x,y) ((x)>(y)?(x):(y))

#define min(x,y) ((x)>(y)?(y):(x))

#define INF 0x3f3f3f3f

#define MAXN 100005

using namespace std;

int cnt=,rt=; //节点编号从1开始

struct Tree

{

    int key, size, pri, son[]; //保证父亲的pri大于儿子的pri

    void set(int x, int y, int z)

    {

        key=x;

        pri=y;

        size=z;

        son[]=son[]=;

    }

}T[MAXN];

void rotate(int p, int &x)

{

    int y=T[x].son[!p];

    T[x].size=T[x].size-T[y].size+T[T[y].son[p]].size;

    T[x].son[!p]=T[y].son[p];

    T[y].size=T[y].size-T[T[y].son[p]].size+T[x].size;

    T[y].son[p]=x;

    x=y;

}

void ins(int key, int &x)

{

    if(x == )

        T[x = cnt++].set(key, rand(), );

    else

    {

        T[x].size++;

        int p=key < T[x].key;

        ins(key, T[x].son[!p]);

        if(T[x].pri < T[T[x].son[!p]].pri)

            rotate(p, x);

    }

}

void del(int key, int &x) //删除值为key的节点

{

    if(T[x].key == key)

    {

        if(T[x].son[] && T[x].son[])

        {

            int p=T[T[x].son[]].pri > T[T[x].son[]].pri;

            rotate(p, x);

            del(key, T[x].son[p]);

        }

        else

        {

            if(!T[x].son[])

                x=T[x].son[];

            else

                x=T[x].son[];

        }

    }

    else

    {

        T[x].size--;

        int p=T[x].key > key;

        del(key, T[x].son[!p]);

    }

}

int find(int p, int &x) //找出第p小的节点的编号

{

    if(p == T[T[x].son[]].size+)

        return x;

    if(p > T[T[x].son[]].size+)

        find(p-T[T[x].son[]].size-, T[x].son[]);

    else

        find(p, T[x].son[]);

}

int find_NoLarger(int key, int &x) //找出值小于等于key的节点个数

{

    if(x == )

        return ;

    if(T[x].key <= key)

        return T[T[x].son[]].size++find_NoLarger(key, T[x].son[]);

    else

        return find_NoLarger(key, T[x].son[]);

}

相关题解：

POJ 3481 treap

POJ 1442 treap

POJ 2352 treap

Splay Tree（伸展树）

　　核心就是过程Splay(x, y)，即将x节点转移到y节点的子节点上面（其中y是x的祖先）。

　　利用其中双旋的优势能够保证查询复杂度均摊为O(lgn)

　　一开始理解有些困难，其实实际上不做深入的理解就是，双旋的过程就是一个建立相对平衡的二叉树的一个过程。

　　》对于二叉树，最极端的情况就是线性插入，使得整棵二叉树退化为一条链。比如你查询链的最后一个节点，之后再次查询第一个节点。

　　　　1）若只是单旋通过Splay(x, 0)将最后一个节点移动到根节点，需要O(n)复杂度，而查询第一个节点时又需要O(n)复杂度，来来往往就退化成一条链了。

　　　　2）若是双旋Splay(x, 0)将最后一个节点移动到根节点上时，移动过程中建立起了相对平衡的二叉树，需要O(n)，也就是查询第一个节点时，大概是需要O(lgn)复杂度。这就降低了复杂度。可以证明，总的每个操作的均摊复杂度是O(lgn)。

　　　　具体证明可以参见杨思雨《伸展树的基本操作与应用》

I 用于维护单调队列：（以key为维护对象保证单调）

常用版：（支持相同值）

Struct Tree{

　　int key, size, fa, son[2];

}

void PushUp(int x);

void Rotate(int x, int p); //0左旋 1右旋

void Splay(int x, int To) //将x节点插入到To的子节点中

int find(int key) //返回值为key的节点若无返回0 若有将其转移到根处

int prev() //返回比根值小的最大值若无返回0 若有将其转移到根处

int succ() //返回比根值大的最小值若无返回0 若有将其转移到根处

void Insert(int key) //插入key 并且将该节点转移到根处

void Delete(int key) //删除值为key的节点若有重点只删其中一个 x的前驱移动到根处

int GetPth(int p) //获得第p小的节点并将其转移到根处

int GetRank(int key) //获得值<=key的节点个数并将其转移到根处若<key只需将<=换为<

模板：

int cnt=, rt=;

struct Tree

{

    int key, size, fa, son[];

    void set(int _key, int _size, int _fa)

    {

        key=_key;

        size=_size;

        fa=_fa;

        son[]=son[]=;

    }

}T[MAXN];

inline void PushUp(int x)

{

    T[x].size=T[T[x].son[]].size+T[T[x].son[]].size+;

}

inline void Rotate(int x, int p) //0左旋 1右旋

{

    int y=T[x].fa;

    T[y].son[!p]=T[x].son[p];

    T[T[x].son[p]].fa=y;

    T[x].fa=T[y].fa;

    if(T[x].fa)

        T[T[x].fa].son[T[T[x].fa].son[] == y]=x;

    T[x].son[p]=y;

    T[y].fa=x;

    PushUp(y);

    PushUp(x);

}

void Splay(int x, int To) //将x节点插入到To的子节点中

{

    while(T[x].fa != To)

    {

        if(T[T[x].fa].fa == To)

            Rotate(x, T[T[x].fa].son[] == x);

        else

        {

            int y=T[x].fa, z=T[y].fa;

            int p=(T[z].son[] == y);

            if(T[y].son[p] == x)

                Rotate(x, !p), Rotate(x, p); //之字旋

            else

                Rotate(y, p), Rotate(x, p); //一字旋

        }

    }

    if(To == ) rt=x;

}

int find(int key) //返回值为key的节点 若无返回0 若有将其转移到根处

{

    int x=rt;

    while(x && T[x].key != key)

        x=T[x].son[key > T[x].key];

    if(x) Splay(x, );

    return x;

}

int prev() //返回比根值小的最大值 若无返回0 若有将其转移到根处

{

    int x=T[rt].son[];

    if(!x) return ;

    while(T[x].son[])

        x=T[x].son[];

    Splay(x, );

    return x;

}

int succ() //返回比根值大的最小值 若无返回0 若有将其转移到根处

{

    int x=T[rt].son[];

    if(!x) return ;

    while(T[x].son[])

        x=T[x].son[];

    Splay(x, );

    return x;

}

void Insert(int key) //插入key 并且将该节点转移到根处

{

    if(!rt)

        T[rt = cnt++].set(key, , );

    else

    {

        int x=rt, y=;

        while(x)

        {

            y=x;

            x=T[x].son[key > T[x].key];

        }

        T[x = cnt++].set(key, , y);

        T[y].son[key > T[y].key]=x;

        Splay(x, );

    }

}

void Delete(int key) //删除值为key的节点 若有重点只删其中一个 x的前驱移动到根处

{

    int x=find(key);

    if(!x) return;

    int y=T[x].son[];

    while(T[y].son[])

        y=T[y].son[];

    int z=T[x].son[];

    while(T[z].son[])

        z=T[z].son[];

    if(!y && !z)

    {

        rt=;

        return;

    }

    if(!y)

    {

        Splay(z, );

        T[z].son[]=;

        PushUp(z);

        return;

    }

    if(!z)

    {

        Splay(y, );

        T[y].son[]=;

        PushUp(y);

        return;

    }

    Splay(y, );

    Splay(z, y);

    T[z].son[]=;

    PushUp(z);

    PushUp(y);

}

int GetPth(int p) //获得第p小的节点 并将其转移到根处

{

    if(!rt) return ;

    int x=rt, ret=;

    while(x)

    {

        if(p == T[T[x].son[]].size+)

            break;

        if(p>T[T[x].son[]].size+)

        {

            p-=T[T[x].son[]].size+;

            x=T[x].son[];

        }

        else

            x=T[x].son[];

    }

    Splay(x, );

    return x;

}

int GetRank(int key) //获得值<=key的节点个数 并将其转移到根处 若<key只需将<=换为<

{

    if(!rt) return ;

    int x=rt, ret=, y;

    while(x)

    {

        y=x;

        if(T[x].key <= key)

        {

            ret+=T[T[x].son[]].size+;

            x=T[x].son[];

        }

        else

            x=T[x].son[];

    }

    Splay(y, );

    return ret;

}

完全版：（支持相同值，支持区间删除，支持懒惰标记）

Struct Tree{

　　int key, num, size, fa, son[2];

}

void PushUp(int x);

void PushDown(int x);

int Newnode(int key, int fa); //新建一个节点并返回

void Rotate(int x, int p); //0左旋 1右旋

void Splay(int x, int To); //将x节点移动到To的子节点中

int GetPth(int p, int To); //返回第p小的节点并移动到To的子节点中

int Find(int key); //返回值为key的节点若无返回0 若有将其转移到根处

int Prev(); //返回根节点的前驱

int Succ(); //返回根结点的后继

void Insert(int key); //插入key值

void Delete(int key); //删除值为key的节点

int GetRank(int key); //获得值<=key的节点个数

void Delete(int l, int r); //删除值在[l, r]中的节点

模板：

int cnt, rt;

int Add[MAXN];

struct Tree{

    int key, num, size, fa, son[];

}T[MAXN];

inline void PushUp(int x)

{

    T[x].size=T[T[x].son[]].size+T[T[x].son[]].size+T[x].num;

}

inline void PushDown(int x)

{

    if(Add[x])

    {

        if(T[x].son[])

        {

            T[T[x].son[]].key+=Add[x];

            Add[T[x].son[]]+=Add[x];

        }

        if(T[x].son[])

        {

            T[T[x].son[]].key+=Add[x];

            Add[T[x].son[]]+=Add[x];

        }

        Add[x]=;

    }

}

inline int Newnode(int key, int fa) //新建一个节点并返回

{

    ++cnt;

    T[cnt].key=key;

    T[cnt].num=T[cnt].size=;

    T[cnt].fa=fa;

    T[cnt].son[]=T[cnt].son[]=;

    return cnt;

}

inline void Rotate(int x, int p) //0左旋 1右旋

{

    int y=T[x].fa;

    PushDown(y);

    PushDown(x);

    T[y].son[!p]=T[x].son[p];

    T[T[x].son[p]].fa=y;

    T[x].fa=T[y].fa;

    if(T[x].fa)

        T[T[x].fa].son[T[T[x].fa].son[] == y]=x;

    T[x].son[p]=y;

    T[y].fa=x;

    PushUp(y);

    PushUp(x);

}

void Splay(int x, int To) //将x节点移动到To的子节点中

{

    while(T[x].fa != To)

    {

        if(T[T[x].fa].fa == To)

            Rotate(x, T[T[x].fa].son[] == x);

        else

        {

            int y=T[x].fa, z=T[y].fa;

            int p=(T[z].son[] == y);

            if(T[y].son[p] == x)

                Rotate(x, !p), Rotate(x, p); //之字旋

            else

                Rotate(y, p), Rotate(x, p); //一字旋

        }

    }

    if(To == ) rt=x;

}

int GetPth(int p, int To) //返回第p小的节点 并移动到To的子节点中

{

    if(!rt || p > T[rt].size) return ;

    int x=rt;

    while(x)

    {

        PushDown(x);

        if(p >= T[T[x].son[]].size+ && p <= T[T[x].son[]].size+T[x].num)

            break;

        if(p > T[T[x].son[]].size+T[x].num)

        {

            p-=T[T[x].son[]].size+T[x].num;

            x=T[x].son[];

        }

        else

            x=T[x].son[];

    }

    Splay(x, );

    return x;

}

int Find(int key) //返回值为key的节点 若无返回0 若有将其转移到根处

{

    if(!rt) return ;

    int x=rt;

    while(x)

    {

        PushDown(x);

        if(T[x].key == key) break;

        x=T[x].son[key > T[x].key];

    }

    if(x) Splay(x, );

    return x;

}

int Prev() //返回根节点的前驱 非重点

{

    if(!rt || !T[rt].son[]) return ;

    int x=T[rt].son[];

    while(T[x].son[])

    {

        PushDown(x);

        x=T[x].son[];

    }

    Splay(x, );

    return x;

}

int Succ() //返回根结点的后继 非重点

{

    if(!rt || !T[rt].son[]) return ;

    int x=T[rt].son[];

    while(T[x].son[])

    {

        PushDown(x);

        x=T[x].son[];

    }

    Splay(x, );

    return x;

}

void Insert(int key) //插入key值

{

    if(!rt)

        rt=Newnode(key, );

    else

    {

        int x=rt, y=;

        while(x)

        {

            PushDown(x);

            y=x;

            if(T[x].key == key)

            {

                T[x].num++;

                T[x].size++;

                break;

            }

            T[x].size++;

            x=T[x].son[key > T[x].key];

        }

        if(!x)

            x=T[y].son[key > T[y].key]=Newnode(key, y);

        Splay(x, );

    }

}

void Delete(int key) //删除值为key的节点1个

{

    int x=Find(key);

    if(!x) return;

    if(T[x].num>)

    {

        T[x].num--;

        PushUp(x);

        return;

    }

    int y=T[x].son[];

    while(T[y].son[])

        y=T[y].son[];

    int z=T[x].son[];

    while(T[z].son[])

        z=T[z].son[];

    if(!y && !z)

    {

        rt=;

        return;

    }

    if(!y)

    {

        Splay(z, );

        T[z].son[]=;

        PushUp(z);

        return;

    }

    if(!z)

    {

        Splay(y, );

        T[y].son[]=;

        PushUp(y);

        return;

    }

    Splay(y, );

    Splay(z, y);

    T[z].son[]=;

    PushUp(z);

    PushUp(y);

}

int GetRank(int key) //获得值<=key的节点个数

{

    if(!Find(key))

    {

        Insert(key);

        int tmp=T[T[rt].son[]].size;

        Delete(key);

        return tmp;

    }

    else

        return T[T[rt].son[]].size+T[rt].num;

}

void Delete(int l, int r) //删除值在[l, r]中的所有节点 l!=r

{

    if(!Find(l)) Insert(l);

    int p=Prev();

    if(!Find(r)) Insert(r);

    int q=Succ();

    if(!p && !q)

    {

        rt=;

        return;

    }

    if(!p)

    {

        T[rt].son[]=;

        PushUp(rt);

        return;

    }

    if(!q)

    {

        Splay(p, );

        T[rt].son[]=;

        PushUp(rt);

        return;

    }

    Splay(p, q);

    T[p].son[]=;

    PushUp(p);

    PushUp(q);

}

(经测NOI2004郁闷的出纳员 POJ3481 POJ2352 POJ1442)

速度相对来说都还不错，POJ这些都3~500ms，郁闷的出纳员900多ms

三大平衡树（Treap + Splay + SBT）总结+模板的更多相关文章

平衡树初阶——AVL平衡二叉查找树+三大平衡树（Treap + Splay + SBT）模板【超详解】
平衡树初阶——AVL平衡二叉查找树一.什么是二叉树 1. 什么是树. 计算机科学里面的树本质是一个树状图.树首先是一个有向无环图,由根节点指向子结点.但是不严格的说,我们也研究无向树.所谓无向树就是 ...
三大平衡树（Treap + Splay + SBT）总结+模板［转］
Treap树核心是利用随机数的二叉排序树的各种操作复杂度平均为O(lgn) Treap模板: #include <cstdio> #include <cstring> #i ...
三大平衡树（Treap + Splay + SBT）总结+模板[转]
Treap树核心是利用随机数的二叉排序树的各种操作复杂度平均为O(lgn) Treap模板: #include <cstdio> #include <cstring> #i ...
BZOJ 3224 - 普通平衡树 - [Treap][Splay]
题目链接:https://www.lydsy.com/JudgeOnline/problem.php?id=3224 Description 您需要写一种数据结构(可参考题目标题),来维护一些数,其中 ...
[洛谷P3369] 普通平衡树 Treap & Splay
这个就是存一下板子...... 题目传送门 Treap的实现应该是比较正经的. 插入删除前驱后继排名什么的都是平衡树的基本操作. #include<cstdio> #include< ...
luoguP3369[模板]普通平衡树(Treap/SBT) 题解
链接一下题目:luoguP3369[模板]普通平衡树(Treap/SBT) 平衡树解析 #include<iostream> #include<cstdlib> #includ ...
平衡树Treap模板与原理
这次我们来讲一讲Treap(splay以后再更) 平衡树是一种排序二叉树(或二叉搜索树),所以排序二叉树可以迅速地判断两个值的大小,当然操作肯定不止那么多(不然我们还学什么). 而平衡树在排序二叉树的 ...
P3369 【模板】普通平衡树（splay）
P3369 [模板]普通平衡树就是不用treap splay板子,好好背吧TAT #include<iostream> #include<cstdio> #include&l ...
算法模板——平衡树Treap 2
实现功能:同平衡树Treap 1(BZOJ3224 / tyvj1728) 这次的模板有了不少的改进,显然更加美观了,几乎每个部分都有了不少简化,尤其是删除部分,这个参照了hzwer神犇的写法,在此鸣 ...

随机推荐

iOS 定位方式 iOSNsPredicateString 详解
原文地址https://segmentfault.com/a/1190000010205649 前言由于使用id.className.AccessibilityId定位方式较为简单,多数情况下,在同 ...
java 定时器实现
java工程中,不免遇到需要定时处理任务的需求,有如下两种方法: 1.使用java.util.TimerTask 2.使用Quartz 一.java.util.TimerTask Timer time ...
java 并发——内置锁
坚持学习,总会有一些不一样的东西. 一.由单例模式引入引用一下百度百科的定义-- 线程安全是多线程编程时的计算机程序代码中的一个概念.在拥有共享数据的多条线程并行执行的程序中,线程安全的代码会通过同 ...
es6函数模块-------初步学习
初步学习: 函数参数允许尾逗号 function clownsEverywhere( param1, param2, //param2后面有逗号 ) { } 函数参数可以赋初值利用解构赋值默认值结合 ...
145. Binary Tree Postorder Traversal（二叉树后序遍历）
Given a binary tree, return the postorder traversal of its nodes' values. For example:Given binary t ...
SQL学习笔记之SQL中INNER、LEFT、RIGHT JOIN的区别和用法详解
0x00 建表准备相信很多人在刚开始使用数据库的INNER JOIN.LEFT JOIN和RIGHT JOIN时,都不太能明确区分和正确使用这三种JOIN操作,本文通过一个简单的例子通俗易懂的讲解这 ...
Web前端开发学习笔记（一）
最近在复习Web前端的开发知识,于是就把大二上学期曾经学过的东西拿出来复习一遍,把自己在做曾经的作业时遇到有意义的点都记下来吧. Homework1:http://my.ss.sysu.edu.cn/ ...
[Linux 002]——Linux的常用命令
经过前面的学习,大概了解了计算机组成原理和操作系统的一些知识.尽管这些知识都是琐碎的,拼凑的,在以后的工作和学习中仍需进行深入的了解.但是这些预备知识对于准备跨入 Linux 大门的童鞋来说,应该是足 ...
20135302魏静静——linux课程第三周实验及总结
linux课程第三周实验及总结一.实验:跟踪分析Linux内核的启动过程使用gdb跟踪调试内核从start_kernel到init进程启动使用实验楼的虚拟机打开shell cd LinuxKer ...
组播的介绍以及CS模型实现
1.组播介绍组播组可以是永久的也可以是临时的.组播组地址中,有一部分由官方分配的,称为永久组播组. 永久组播组保持不变的是它的ip地址,组中的成员构成可以发生变化.永久组播组中成员的数量都可以是任意 ...

三大平衡树（Treap + Splay + SBT）总结+模板

三大平衡树（Treap + Splay + SBT）总结+模板的更多相关文章

随机推荐

热门专题