无旋treap树

最新推荐文章于 2023-04-20 14:29:34 发布
最新推荐文章于 2023-04-20 14:29:34 发布
阅读量325 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 平衡树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Black__wing/article/details/86091502
本文详细介绍了无旋treap树的基本概念，包括数据约定、分裂、合并、插入、删除等操作，以及如何求权值为k的点的排名和排名为k的点的权值，还探讨了求前驱后继的方法。此外，提供了普通平衡树和适用于区间操作的平衡树实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

约定：

int ch[maxd][3];//0左儿子，1右儿子
int val[maxd];//权值
int rnd[maxd];//随机权值
int sze[maxd];//以每个点为根树的大小
int T,rt,x,y,z;

分裂：

inline void update(int x)
{
    sze[x]=1+sze[ch[x][0]]+sze[ch[x][1]];
}
//x为权值小于k的子树的根，y为剩下的子树的根

void split(int now,int k,int &x,int &y)//权值分裂
{
    if(!now)
    {
        x=y=0;
        return ;
    }
    else if(val[now]<=k)//它及它的左子树都小于等于k，递归向右找第二颗树
    {
        x=now;
        split(ch[now][1],k,ch[now][1],y);
    }
    else
    {
        y=now;
        split(ch[now][0],k,x,ch[now][0]);
    }
    update(now);//更新sze
}
//x为前k个的子树的根，y为剩下的子树的根

void split1(int now,int k,int &x,int &y)//单点
{
    if(!now)
    {
        x=y=0;
    }
    else{
        if(k<=sze[ch[now][0]])//左子树元素个数大于k个，将右子树全部放在第二颗树上，递归分裂左子树
        {
            y=now;
            split1(ch[now][0],k,x,ch[now][0]);
        }
        else{
            x=now;
            split1(ch[now][1],k-sze[ch[now][0]]-1,ch[now][1],y);
        }
    }
    update(now);

}

合并：

//我们假设第一棵树的权值小于第二棵树的权值，
//那么我们就比较它们的随机权值。
//如果rnd[l]<rnd[r]，我们就保留它的左子树，
//另一棵树作为它的右子树；如果rnd[l]>=rnd[r]，
//那我们可以保留第二棵树的右子树，另一颗树作为它的左子树。
int merge(int A,int B)
{
    if(!A||!B)
    {
        return A+B;
    }
    if(rnd[A]<rnd[B])
    {
        ch[A][1]=merge(ch[A][1],B);
        update(A);
        return A;
    }
    else
    {
        ch[B][0]=merge(A,ch[B][0]);
        update(B);
        return B;
    }
}

插入：


int new_node(int x)
{
    sze[++T]=1;
    val[T]=x;
    rnd[T]=rand();
    return T;
}
void Inser(int k)
{
    split(rt,k,x,y);
    rt=merge(merge(x,new_node(k)),y);
}

删除：

//删除权值为v的点，先把整颗树以v为权值split成两棵树a,b,再把a树按照v-1分成c,d。
//这时候值为v的点一定为d的根，
//那么我们把d的两个子儿子merge起来（划重点：这一步就是去除掉v的影响），
//再把他们重新merge起来得到一个新的树，这颗树就去除掉了v的影响。
void del(int k){
    split(rt,k,x,z);
    split(x,k-1,x,y);
    y=merge(ch[y][0],ch[y][1]);
    rt=merge(merge(x,y),z);
}

求权值为k的点的排名/排名为k的点的权值:

//直接按照a-1的权值把树分开，那么x树中最大的应该小于等于a-1，那么a的排名就是size[x]+1。
int QueryRank(int k)
{
    split(rt,k-1,x,y);
    int res=sze[x]+1;
    rt=merge(x,y);
    return res;
}
int QueryK(int now,int k)
{
    while(1)
    {
        if(k<=sze[ch[now][0]])now=ch[now][0];
        else if(k==sze[ch[now][0]]+1) return now;
        else k-=sze[ch[now][0]]+1,now=ch[now][1];
    }
    return 0;
}

求前驱后继：

int pre(int k)
{
    split(rt,k-1,x,y);
    int res=val[QueryK(x,sze[x])];
    rt=merge(x,y);
    return res;
}
int suf(int k)
{
    split(rt,k,x,y);
    int res=val[QueryK(y,1)];
    rt=merge(x,y);
    return res;
}

普通的平衡树代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <ctime>
using namespace std;
const int maxd = 5e5+10;
inline int read()
{
    int x=0,f=1;char c = getchar();
    while(c>'9'||c<'0'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
int ch[maxd][3];//0左儿子，1右儿子
int val[maxd];//权值
int rnd[maxd];//随机权值
int sze[maxd];//以每个点为根树的大小
int T,rt,x,y,z;
inline void update(int x)
{
    sze[x]=1+sze[ch[x][0]]+sze[ch[x][1]];
}
//x为权值小于k的子树的根，y为剩下的子树的根

void split(int now,int k,int &x,int &y)//权值分裂
{
    if(!now)
    {
        x=y=0;
        return ;
    }
    else if(val[now]<=k)//它及它的左子树都小于等于k，递归向右找第二颗树
    {
        x=now;
        split(ch[now][1],k,ch[now][1],y);
    }
    else
    {
        y=now;
        split(ch[now][0],k,x,ch[now][0]);
    }
    update(now);//更新sze
}
//x为前k个的子树的根，y为剩下的子树的根

void split1(int now,int k,int &x,int &y)//单点
{
    if(!now)
    {
        x=y=0;
    }
    else{
        if(k<=sze[ch[now][0]])//左子树元素个数大于k个，将右子树全部放在第二颗树上，递归分裂左子树
        {
            y=now;
            split1(ch[now][0],k,x,ch[now][0]);
        }
        else{
            x=now;
            split1(ch[now][1],k-sze[ch[now][0]]-1,ch[now][1],y);
        }
    }
    update(now);

}
//我们假设第一棵树的权值小于第二棵树的权值，
//那么我们就比较它们的随机权值。
//如果rnd[l]<rnd[r]，我们就保留它的左子树，
//另一棵树作为它的右子树；如果rnd[l]>=rnd[r]，
//那我们可以保留第二棵树的右子树，另一颗树作为它的左子树。
int merge(int A,int B)
{
    if(!A||!B)
    {
        return A+B;
    }
    if(rnd[A]<rnd[B])
    {
        ch[A][1]=merge(ch[A][1],B);
        update(A);
        return A;
    }
    else
    {
        ch[B][0]=merge(A,ch[B][0]);
        update(B);
        return B;
    }
}

int new_node(int x)
{
    sze[++T]=1;
    val[T]=x;
    rnd[T]=rand();
    return T;
}
void Inser(int k)
{
    split(rt,k,x,y);
    rt=merge(merge(x,new_node(k)),y);
}
//删除权值为v的点，先把整颗树以v为权值split成两棵树a,b,再把a树按照v-1分成c,d。
//这时候值为v的点一定为d的根，
//那么我们把d的两个子儿子merge起来（划重点：这一步就是去除掉v的影响），
//再把他们重新merge起来得到一个新的树，这颗树就去除掉了v的影响。
void del(int k){
    split(rt,k,x,z);
    split(x,k-1,x,y);
    y=merge(ch[y][0],ch[y][1]);
    rt=merge(merge(x,y),z);
}
//直接按照a-1的权值把树分开，那么x树中最大的应该小于等于a-1，那么a的排名就是size[x]+1。
int QueryRank(int k)
{
    split(rt,k-1,x,y);
    int res=sze[x]+1;
    rt=merge(x,y);
    return res;
}
int QueryK(int now,int k)
{
    while(1)
    {
        if(k<=sze[ch[now][0]])now=ch[now][0];
        else if(k==sze[ch[now][0]]+1) return now;
        else k-=sze[ch[now][0]]+1,now=ch[now][1];
    }
    return 0;
}
int pre(int k)
{
    split(rt,k-1,x,y);
    int res=val[QueryK(x,sze[x])];
    rt=merge(x,y);
    return res;
}
int suf(int k)
{
    split(rt,k,x,y);
    int res=val[QueryK(y,1)];
    rt=merge(x,y);
    return res;
}
int main()
{
    int n;
    scanf("%d",&n);
    while(n--)
    {
        int op,x;
        scanf("%d%d",&op,&x);
        switch (op)
        {
        case 1:
            Inser(x);
            break;
        case 2:
            del(x);
            break;
        case 3:
            printf("%d\n",QueryRank(x));
            break;
        case 4:
            printf("%d\n",val[QueryK(rt,x)]);
            break;
        case 5:
            printf("%d\n",pre(x));
            break;
        case 6:
            printf("%d\n",suf(x));
            break;
        }
    }
    return 0;
}

区间操作（文艺的平衡树）：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <ctime>
using namespace std;
int rt,cnt,x,y,z,n,m;
const int maxn=1e5+10;
int ch[maxn][2];
int rnd[maxn];
int val[maxn];
int f[maxn];
int siz[maxn];
void pushdown(int x)
{
    swap(ch[x][0],ch[x][1]);
    if(ch[x][0]) f[ch[x][0]]^=1;
    if(ch[x][1]) f[ch[x][1]]^=1;
    f[x]=0;
}
void pushup(int x)
{
    siz[x]=siz[ch[x][1]]+siz[ch[x][0]]+1;
}
void split(int now,int k,int &x,int &y)
{
    if(!now)
    {
        x=y=0;
        return ;
    }
    if(f[now]) pushdown(now);
    if(siz[ch[now][0]]<k)
    {
        x=now;
        split(ch[now][1],k-siz[ch[now][0]]-1,ch[now][1],y);
    }
    else
    {
        y=now;
        split(ch[now][0],k,x,ch[now][0]);
    }
    pushup(now);
}
int merge(int a,int b)
{
    if(!a||!b)
    {
        return a+b;
    }
    if(rnd[a]<rnd[b])
    {
        if(f[a]) pushdown(a);
        ch[a][1]=merge(ch[a][1],b);
        pushup(a);
        return a;
    }
    else
    {
        if(f[b]) pushdown(b);
        ch[b][0]=merge(a,ch[b][0]);
        pushup(b);
        return b;
    }
}
int new_node(int x)
{
    val[++cnt]=x;
    rnd[cnt]=rand();
    siz[x]=1;
    return cnt;
}
void Insert(int k)
{
    split(rt,k,x,y);
    rt=merge(merge(x,new_node(k)),y);
}
void print(int k)
{
    if(!k) return ;
    if(f[k])pushdown(k);
    print(ch[k][0]);
    cout<<val[k]<<" ";
    print(ch[k][1]);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        //int x;
        //scanf("%d",&x);
        rt=merge(rt,new_node(i));
    }
    int l,r;
    while(m--)
    {
        scanf("%d%d",&l,&r);
        split(rt,l-1,x,y);
        split(y,r-l+1,y,z);
        f[y]=1;
        rt=merge(x,merge(y,z));
    }
    print(rt);
    return 0;
}

 

 

浅谈无旋treap(fhq_treap)
aaa3201的博客
06-01 1529
一、简介 无旋Treap（fhq_treap），是一种不用旋转的treap，其代码复杂度不高，应用范围广（能代替普通treap和splay的所有功能），是一种极其强大的平衡树。 无旋Treap是一个叫做范浩强的大佬发明的（快%啊！） 在我们一起学习无旋Treap之前，本蒟蒻有几句活想说： 1.无旋Treap我个人认为是最容易理解的一种平衡树，而且编程复杂度不高，功能还那么强大。 ...
【学习笔记】数据结构：无旋Treap
LeeCongWei的博客
01-02 1141
最近学习了一下无旋Treap，发现无旋Treap真的太好打了，而且也很好理解，很好用。 Treap? 什么是Treap？ 顾名思义：Treap=Tree+heap，即“树堆”，“树”指的是二叉查找树，“堆”就是堆。 那二叉查找树跟堆有什么关系呢？ 当输入的数据十分恶心的时候，普通的二叉查找树的时间复杂度就会由 nlog2nnlog_2nnlog2​n 退化到 n2n^2n2 级别，时间复杂度难以让人接受。 而我们现在考虑优化，我们可以在每一个节点上多放一个数，然后使得这棵树既满足二叉排序树的性质也满足堆的性
史上最简单的平衡树——无旋Treap.pdf
01-14
史上最简单的平衡树——无旋Treap.pdf
无旋Treap
蒟蒻QTY
08-03 1388
想要搞带区间的平衡树，要么用splay，要么用无旋treap。（现在只会后面的）     先%一下大佬LadyLex     无旋treap简言之不再有左旋和右旋，而多了拆分子树和合并子树的过程。     slipt为拆树。D 为定义的pair，first是拆下来的树，second是拆下来后剩下的原树。     如果要拆下来的树的大小比左子树小，就拆左子树，并把拆完的树接回来。
treap(树堆)
weixin_33923148的博客
05-06 184
一棵treap是一棵修改了结点顺序的二叉查找树，如图，显示一个例子，通常树内的每个结点x都有一个关键字值key[x]，另外，还要为结点分配priority[x]，它是一个独立选取的随机数。假设所有的优先级是不同的，所有的关键字也是不同的。treap的结点排列成让关键字遵循二叉查找树性质，并且优先级遵循最小堆顺序性质：1.如果v是u的左孩子，则key[v] &lt; key[u].2.如果v是u的右...
6天通吃树结构—— 第三天 Treap树
weixin_34224941的博客
07-30 163
               我们知道，二叉查找树相对来说比较容易形成最坏的链表情况，所以前辈们想尽了各种优化策略，包括AVL，红黑，以及今天 要讲的Treap树。        Treap树算是一种简单的优化策略，这名字大家也能猜到，树和堆的合体，其实原理比较简单，在树中维护一个"优先级“，”优先级“ 采用随机数的方法，但是”优先级“必须满足根堆的性质，当然是“大根堆”或者“小根堆”都无...
不基于旋转的treap
zmh的博客
01-18 4082
介绍最近看到有一种不用旋转的treap，好像还可以持久化，于是就学了一下。treap就是tree+heap。它的每个节点的权值data满足排序二叉树的性质，随机权值key满足堆的性质。由于key是随机的所以它大致是平衡的。 不基于旋转的treap有两个基本操作：merge(a,b)：返回一个treap，包含a，b两个treap中的所有节点，但要保证b中所有节点权值都大于等于a。split(a,n)
无旋Treap——FHQ Treap
Lucas_FC_的博客
08-29 848
FHQ Treap
无旋treap（可持久化，区间操作），解决普通平衡树、文艺平衡树
avenLJY的博客
05-23 930
无旋treap 普通平衡树tyvj1728（treap模板） 如果想看旋转treap怎么写戳这儿 无旋treap代码： #include<bits/stdc++.h> using namespace std; const int N=5e5+5; struct node{ int val,ch[2],size,rd; #define l(x) t[x].ch[0] #define...
模板 - 无旋Treap
weixin_30882895的博客
08-09 132
一般而言作为一棵平衡树只需要插入，删除，值求排名，排名求值，前驱，后继，六个接口。 #include<bits/stdc++.h> using namespace std; typedef long long ll; #define ls(p) ch[p][0] #define rs(p) ch[p][1] const int MAXN = 100000 + 5; int ...
可持久化平衡树： 无旋Treap
一位蒟蒻的小博客
08-15 432
例题 jzoj3658文本编辑器 无旋Treap 有旋Treap由于splay的存在而无用武之地了。 优点：代码较短，原生支持区间分裂合并，并支持可持久化。 缺点：较splay大概有2的常数。 核心操作 定义请戳 split(root,x) 将树root分解为两颗树，第一颗为其中[1,x]，第二颗为[x+1,size] 返回是保存上述两个根的pair。 merge(a,...
无旋treap
yzyyylx的博客
03-14 352
作用一种平衡树,可以只利用合并与拆分两种操作实现插入删除等所有二叉查找树可以做的事情.实现方法treap=tree+heap,利用tree来保持二叉查找树的功能,再利用heap来保证它是平衡树. 每个节点保存两个值,一个是题目给出的,要储存的值,还有一个是rand的且长期不变,建树时储存的值根据二叉查找树的性质来保存,同时保证rand()的值符合堆的性质,每个根为该子树的极值,这样就可以保证树的平
FHQ_Treap树（无旋Treap树）模板向
Izayoi_w的博客
11-04 678
这种树是一种无需旋转操作的Treap树，由FHQ（范浩强）大佬发明，堪称是神级的数据结构！他短小精悍，易于学习，而其思想的优雅令无数OIer/ACMer以及程序员们为之着迷！ 而这一切都来源于这一份ppt：范浩强谈数据结构 在了解这个数据结构之前最好先了解一下treap树以及笛卡尔树，这两种树本身具有一定的相似性，而为FHQ_Treap提供了思想延申的起点。 FHQ_Treap代替旋转操作的核心就...
树和树结构(2) : Treap树
weixin_30530523的博客
12-27 143
测试题目来自 http://codevs.cn/problem/1164/ 部分内容来自网络 想要了解treap树，你先要知道什么是二叉搜索树。 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则...
非旋treap
ureaster的博客
02-25 260
#include #define N 100005 using namespace std; int rt,val[N],lch[N],rch[N],pro[N],sz[N],cnt; int rnd() { static int sd=4234; return sd*=3423; } int node(int v) { val[++cnt]=v; pro[cnt]=rnd(); sz[
无旋版 TreapTreap。
li123128的博客
05-01 389
无旋版 TreapTreap。只需要两个操作即可达到 splaysplay 的所有功能1、splitsplit它的主要思想就是把一个 TreapTreap 分成两个。 splitsplit 操作有两种类型，一种是按照权值分配，一种是按前 k 个分配。第一种就是把所有小于 k 的权值的节点分到一棵树中，第二种是把前 k 个分到一个树里。权值版： 1 void split(int o,int k,in...
无旋Treap（fhq）
qq_43561934的博客
04-20 353
对于任意节点，保证根左侧子树的所有节点比根小，右侧的所有节点比根大的树（没有相同节点），Treap只是利用堆的性质，赋予每一个节点一个随机值，按照随机值维护堆的形状，即在插入的情况中，如果树A的根节点的权重比树B的大，那树B就一定是树A的子树，再根据树B的根节点的值的大小确定是在树A的左子树还是右子树。合并就是将两个树合并成一棵树，其中x树上的全部值小于等于y树上的所有值，并且合并出来的树依然满足Treap的性质，具体逻辑可见下面的代码，文字不想写了。左右子树、值、权重、树的大小。
无旋treap(fhq treap)
weixin_44316314的博客
02-26 403
普通平衡树 /* 无旋treap(fhq treap) treap是二叉搜索树结合二叉堆来的, 它保证树上任意节点,右节点值一定大于当前节点,儿子节点的索引一定小于父亲节点 对于任意一个点随机赋索引,这样的树就保证了随机,从而不会被卡链 无旋treap主要引入了分裂和合并两个操作,从而可用来处理很多问题 */ #include <iostream> #include <cstdlib> #include <ctime> using namespace std; c
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值