非旋转Treap

最新推荐文章于 2022-07-11 09:54:47 发布
最新推荐文章于 2022-07-11 09:54:47 发布
阅读量698 收藏
点赞数 1
分类专栏： 平衡树 算法&数据结构总结By_ZZK 文章标签： 数据结构 平衡树 非旋转Treap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzkksunboy/article/details/69939298
版权

作用

旋转Treap是非常经典的一种平衡树，但是由于旋转会破坏各种乱七八糟的东西，导致旋转Treap不能可持久化。而非旋转Treap根本不需要旋转，就可以维护堆性质和二叉排序树性质，从而实现可持久化（然而我太蒟蒻，依然不会可持久化，以后会了再更新）。当然，也可以和Splay一样进行区间操作（也不比Splay难写）。

实现

非旋转Treap和很多可并堆比如左偏树很像，一切操作基于Merge和Split，即合并与分裂（以下以大根堆为例）。

1.合并A和B

（合并的前提是A全小于B，否则只能启发式合并）
首先是递归边界：当A和B中有一个是null时，退出另一个。
如果A的fix（随机堆值）＜B的fix，不能交换A和B，因为我们还要维护二叉排序树性质，所以就需要Merge(A,B->son[0])。这里还需要注意的是，不能Merge(B->son[0],A)，因为要确保A全小于B。
如果A的fix>B的fix，同理，就Merge(A->son[1],B)。

2.将p分裂为前k个和剩下的部分

（简称左和右部分）
首先是递归边界：当p是null时，退出的两个部分为null和null。
如果k<=p->son[0]->si（子树节点个数），说明k在p的左儿子，那么就先把p->son[0]分裂为L（前k个）和R（剩下的部分），然后p->son[0]变成了R，整棵树分裂完成后左部分是L，而右部分是p。
如果k>p->son[0]->si，说明k在p的右儿子或p，由于向右走，所以要把p->son[1]分裂为L（前k-p->son[0]->si-1个）和R（剩下的部分），然后p->son[1]变成了L，整棵树分裂完成后左部分是p，右部分是R。

3.使用

分裂之后的合并就是A全小于B的合并，所以分裂与合并就可以很快速的改变Treap的结构，而不用旋转。

4.建树

非旋转Treap的建树不能像Splay一样分治建树，而要用笛卡尔树的建树方法来建树（因为笛卡尔树和Treap一模一样）。笛卡尔树的建树方法是维护最右边的一条路径，用栈储存这条路径上的节点（越深的节点越接近堆顶）。每当新来了一个节点now，就把now放到最右边，然而此时并不保证堆性质，于是把栈中所有fix小于now的fix的节点都从栈中删除，假设最后一个被删除的节点是lst，那么now的左儿子就是lst，当前栈顶（如果存在的话）的右儿子就是now。特别注意更新节点信息。

模板-普通

BZOJ3224

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define fst first
#define snd second
using namespace std;
const int maxn=100000,MAXINT=((1<<30)-1)*2+1;

int te;
//==================================================
struct Node
{
    Node *son[2];
    int si,val,fix; //val是二叉排序树权值
    void Pushup() {si=son[0]->si+1+son[1]->si;}
};
typedef Node* P_node;
typedef pair<P_node,P_node> pnn;
Node tem[maxn+5];
P_node null=tem,len=null,ro=null;
P_node newNode(int k)
{
    len++;len->son[0]=len->son[1]=null;
    len->si=1;len->fix=rand();len->val=k;
    return len;
}
P_node Merge(P_node A,P_node B) //合并
{
    if (A==null) return B;if (B==null) return A;
    if (A->fix<B->fix)
    {
        B->son[0]=Merge(A,B->son[0]);
        B->Pushup();return B;
    } else
    {
        A->son[1]=Merge(A->son[1],B);
        A->Pushup();return A;
    }
}
pnn Split(P_node p,int k) //分裂
{
    if (p==null) return pnn(null,null);
    pnn now;
    if (k<=p->son[0]->si)
    {
        now=Split(p->son[0],k);
        p->son[0]=now.snd;p->Pushup();
        now.snd=p;
    } else
    {
        now=Split(p->son[1],k-p->son[0]->si-1);
        p->son[1]=now.fst;p->Pushup();
        now.fst=p;
    }
    return now;
}
int getrank(P_node p,int k) //为避免重复，这个函数返回真正答案-1
{
    if (p==null) return 0;
    if (k<=p->val) return getrank(p->son[0],k); else
    return p->son[0]->si+1+getrank(p->son[1],k);
}
void Insert(P_node &p,int x)
{
    //插入等同于分裂出<=x的部分和>x的部分，然后插入新节点
    pnn now=Split(p,getrank(p,x));
    p=Merge(Merge(now.fst,newNode(x)),now.snd);
}
void Delete(P_node &p,int x)
{
    //删除等同于分裂出<x的部分和>=x的部分，然后删除>=x部分的第一个
    pnn now=Split(p,getrank(p,x));
    p=Merge(now.fst,Split(now.snd,1).snd);
}
int getkth(P_node p,int k)
{
    if (p==null) return MAXINT;
    if (k==p->son[0]->si+1) return p->val; else
    if (k<=p->son[0]->si) return getkth(p->son[0],k); else
    return getkth(p->son[1],k-p->son[0]->si-1);
}
int getpre(P_node p,int k)
{
    if (p==null) return MAXINT;
    if (k>p->val)
    {
        int now=p->val,nxt=getpre(p->son[1],k);
        if (nxt==MAXINT) return now; else return nxt;
    } else return getpre(p->son[0],k);
}
int getsuf(P_node p,int k)
{
    if (p==null) return MAXINT;
    if (k<p->val)
    {
        int now=p->val,nxt=getsuf(p->son[0],k);
        if (nxt==MAXINT) return now; else return nxt;
    } else return getsuf(p->son[1],k);
}
//==================================================
bool Eoln(char ch) {return ch==10||ch==13||ch==EOF;}
int readi(int &x)
{
    int tot=0,f=1;char ch=getchar(),lst=' ';
    while ('9'<ch||ch<'0') {if (ch==EOF) return EOF;lst=ch;ch=getchar();}
    if (lst=='-') f=-f;
    while ('0'<=ch&&ch<='9') tot=tot*10+ch-48,ch=getchar();
    x=tot*f;
    return Eoln(ch);
}
int main()
{
    freopen("Treap.in","r",stdin);
    freopen("Treap.out","w",stdout);
    readi(te);
    while (te--)
    {
        int td,x;readi(td);readi(x);
        switch (td)
        {
            case 1:Insert(ro,x);break;
            case 2:Delete(ro,x);break;
            case 3:printf("%d\n",getrank(ro,x)+1);break;
            case 4:printf("%d\n",getkth(ro,x));break;
            case 5:printf("%d\n",getpre(ro,x));break;
            case 6:printf("%d\n",getsuf(ro,x));break;
        }
    }
    return 0;
}

模板-区间反转

BZOJ3223

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int maxn=100000,MAXINT=((1<<30)-1)*2+1;

int n,te;
//==================================================
struct Node
{
    Node *son[2];
    int si,val,fix;
    bool tag_flip; //lazy-tag
    void Pushup() {si=son[0]->si+1+son[1]->si;}
    void Addflip() {swap(son[0],son[1]);tag_flip^=1;} //加标记
};
typedef Node* P_node;
struct pnn
{
    P_node fst,snd;
    pnn(P_node a=NULL,P_node b=NULL) {fst=a;snd=b;}
};
Node tem[maxn+5];
P_node null=tem,len=null,ro=null;
P_node newNode(int k)
{
    len++;len->son[0]=len->son[1]=null;
    len->si=1;len->fix=rand();len->val=k;len->tag_flip=false;
    return len;
}
void Pushdown(P_node p) //传递标记
{
    if (p->tag_flip)
    {
        p->tag_flip=false;
        if (p->son[0]!=null) p->son[0]->Addflip();
        if (p->son[1]!=null) p->son[1]->Addflip();
    }
}
void LNR(P_node p)
{
    if (p==null) return;Pushdown(p);
    LNR(p->son[0]);printf("%d ",p->val);LNR(p->son[1]);
}
int top_b;P_node stk_b[maxn+5]; //代表最右边路径的栈
P_node Build(int L,int R)
{
    top_b=0;stk_b[1]=null;
    for (int i=L;i<=R;i++)
    {
        P_node now=newNode(i),lst=null;
        while (top_b&&stk_b[top_b]->fix<now->fix)
        {
            stk_b[top_b]->Pushup(); //更新节点信息
            lst=stk_b[top_b--]; //记录lst
        }
        if (top_b) stk_b[top_b]->son[1]=now;
        now->son[0]=lst;stk_b[++top_b]=now;
    }
    while (top_b) stk_b[top_b--]->Pushup(); //更新节点信息
    return stk_b[1]; //栈底就是根节点
}
P_node Merge(P_node A,P_node B)
{
    if (A==null) return B;if (B==null) return A;
    Pushdown(A);Pushdown(B);
    if (A->fix<B->fix)
    {
        B->son[0]=Merge(A,B->son[0]);
        B->Pushup();return B;
    } else
    {
        A->son[1]=Merge(A->son[1],B);
        A->Pushup();return A;
    }
}
pnn Split(P_node p,int k)
{
    if (p==null) return pnn(null,null);
    pnn now;Pushdown(p);
    if (k<=p->son[0]->si)
    {
        now=Split(p->son[0],k);
        p->son[0]=now.snd;p->Pushup();
        now.snd=p;
    } else
    {
        now=Split(p->son[1],k-p->son[0]->si-1);
        p->son[1]=now.fst;p->Pushup();
        now.fst=p;
    }
    return now;
}
//==================================================
bool Eoln(char ch) {return ch==10||ch==13||ch==EOF;}
int readi(int &x)
{
    int tot=0,f=1;char ch=getchar(),lst=' ';
    while ('9'<ch||ch<'0') {if (ch==EOF) return EOF;lst=ch;ch=getchar();}
    if (lst=='-') f=-f;
    while ('0'<=ch&&ch<='9') tot=tot*10+ch-48,ch=getchar();
    x=tot*f;
    return Eoln(ch);
}
int main()
{
    freopen("Treap.in","r",stdin);
    freopen("Treap.out","w",stdout);
    readi(n);readi(te);ro=Build(1,n);
    while (te--)
    {
        int x,y;readi(x);readi(y);y=y-x+1;
        pnn l=Split(ro,x-1),r=Split(l.snd,y);r.fst->Addflip();
        //分裂出1~x-1和x~n，再把后面分裂为x~y和y+1~n，加标记后合并
        ro=Merge(l.fst,Merge(r.fst,r.snd));
    }
    LNR(ro);
    return 0;
}
ZigZagK
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
fruit --treep平衡树
10-30
fruit --treep平衡树 Treap=Tree+Heap。Treap本身是一棵二叉搜索树，它的左子树和右子树也分别是一个Treap，和一般的二叉搜索树不同...Treap维护堆性质的方法用到了旋转，只需要两种旋转，编程复杂度比Splay要小一些。
【平衡树】非旋转Treap及其可持久化详解
IDDFS
10-08 313
Part.0 前置知识 Treap； 可持久化。 Part.1 非旋转Treap 顾名思义就是不需要旋转的Treap。 众所周知所有的平衡树都需要通过旋转来保证深度。 然而非旋转Treap却不需要通过旋转就能够保证深度。 非旋转Treap通过两个基本操作来实现平衡树的所有操作。 合并操作 分裂操作（按值分裂） 其他操作 参考模板 指针写的代码清晰度果然很高。QAQ… struct NonRot...
不需要旋转，却能力压群雄的数据结构——非旋Treap 看完还不会你打我
呆头呆脑没有烦恼
12-16 626
非旋Treap讲解 Treap，一种平衡树。作为一棵平衡树，一定是遵从着某种原则，使得这棵树尽量的接近完全二叉树。除了二叉搜索树都具备的性质——左子树 ≤ 根 ≤ 右子树，顾名思义，Treap = tree＋heap。这时他的特殊性质就飘出水面了——heap。 有一个需要慢慢理解的东西，我觉得是本文最重要的——二叉搜索树中顺次排列所参考的参数是灵活的，谁说非要按数值？？有的题你就得用下
FHQ-Treap(非旋treap/平衡树)——从入门到入坟
yyh_getAC的博客
07-11 4746
平衡树有很多种，其中fhq-treap 可以说是最强的一种平衡树之一，它可以维护值域，也可以维护下标，还能维护区间修改，更难能可贵的是，它可以完成splay都完成不了的可持久化操作。其唯一弱于splay的就是在LCT上，splay维护LCT的复杂度是O(nlog(n)),而fhq-treap的复杂度为O(nlog^2(n))，稍微大了一点，但是比splay好写多了。............
【平衡树总结 Ⅲ】【FHQ Treap】非旋Treap |【CGWR③】| E
Keyu Tian's blog
05-16 467
闭关了一周，终于可以正面对刚淑芬啦 qwq，刷分成功√ 接下来就好好补题填坑吧… 平衡树总结Ⅲ：FHQ Treap 概述 说 FHQ Treap 前，先来说说 Treap 吧：Treap的结点...
非旋转式treap及可持久化
srand(time(0))
02-01 4036
可持久化Treap
leetcode分类-LeetCode:力码
06-30
leetcode 分类 leetcode AC代码 所有题目我尽量优化到最优时间复杂度，包括我做题时题解中没有的算法 下面记录了哪些题目使用了题解中没看到的，时间复杂度最优的算法 1389 //nlogn, ...//旋转卡壳
可持久化（非旋转式）treap 学习记录
Lcomyn的专栏
01-18 5636
原来的treap是通过左旋右旋来维护最小堆性质，但在此处，由于是区间操作，我们需要截出一整段区间（也就是一段treap），并且在重新插入回去的时候，不能够破坏最小堆性质，于是我们可以用merge（合并操作）和split（拆分操作）来维护
【模板】 非旋转treap
Tricksterism
05-01 87
【模板】 非旋转treap 模板：luogu P3369 【模板】普通平衡树 code： #include &lt;cstdio&gt; #include &lt;cstdlib&gt; const int MAX_N=100010; int rd() { int x=0,fla=1; char c=' '; w...
不基于旋转的treap
zmh的博客
01-18 3976
介绍最近看到有一种不用旋转的treap，好像还可以持久化，于是就学了一下。treap就是tree+heap。它的每个节点的权值data满足排序二叉树的性质，随机权值key满足堆的性质。由于key是随机的所以它大致是平衡的。 不基于旋转的treap有两个基本操作：merge(a,b)：返回一个treap，包含a，b两个treap中的所有节点，但要保证b中所有节点权值都大于等于a。split(a,n)
非旋转Treap-总结
linkfqy
04-18 2553
【前言】 非旋转Treap，又称FHQ_Treap，函数式Treap。由神犇FHQ首先提出（OrzOrzOrz）。由于使用了函数式编程的思想，非旋转Treap可以实现可持久化。 此外，非旋转Treap的大多数操作都基于分裂与合并，所以代码简短精炼，非常适合OIer食用。 【操作】 就讲讲分裂与合并好了……其他都是可以用脚趾头想出来的。分裂(split) 对于一棵Treap，我们把它分为ke
非旋转Treap模板
hao_zong_yin的博客
08-06 228
/* Treap[Merge,Split] by Memphis */ #include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;cstring&gt; #include&lt;ctime&gt; using namespace std; #define maxn 2000005 #define rep(i,x,...
非旋转 Treap 学习笔记（一）
Kumii
11-17 420
非旋转 Treap 学习笔记（一）
【模板】非旋转Treap
linkfqy
06-02 496
运用了函数式编程的思想。 能实现更为强大的功能关于非旋转Treap，看这里写得比较简洁：
数据结构-非旋TREAP
Ice_teapoy的博客
01-03 659
Treap=Tree+Heap
继续treap代码
最新发布
05-27
这是Treap的代码: ``` #include using namespace std; struct Node { int key, priority; Node *left, *right; Node(int key, int priority) : key(key), priority(priority), left(NULL), right(NULL) {} }...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值