旋转还是无旋？treap从入门到想死

最新推荐文章于 2024-02-13 14:48:50 发布
最新推荐文章于 2024-02-13 14:48:50 发布
阅读量2k 收藏 3
点赞数 3
分类专栏： 数据结构 文章标签： treap 无旋treap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litble/article/details/78934306
版权

旋转treap

优点：代码比splay好打
缺点：很多操作（尤其是区间操作）不资磁

插入

插入方式和二叉查找树一致，新建节点后，要给节点rand一个pos值。
然后返回改节点的父亲，如果该节点pos值比父亲大，就要旋转，以保证父节点的pos值小于儿子的，满足堆的性质。使用随机数可以使得这棵树尽量平衡。

void ins(int &x,LL bh) {
	if(!x) {x=++sss,pos[x]=rand(),num[x]=bh,v[x]=1;return;}
	if(bh<num[x]) {ins(son[x][0],bh);if(pos[son[x][0]]<pos[x]) spin(x,0);}
	else {ins(son[x][1],bh);if(pos[son[x][1]]<pos[x]) spin(x,1);}
}

旋转

treap的旋转操作比splay清爽多了，可以说是相当于splay的zig/zag操作。

void spin(int &x,int is) {
	int t=son[x][is];
	son[x][is]=son[t][!is],son[t][!is]=x,x=t;
}

查找前驱后继

例题：洛谷P2234/bzoj2234/codevs1296 营业额统计

LL pre(int x,LL num) {//前驱
	if(!x) return -inf;
	if(v[x]>num) return pre(son[x][0],num);
	return max(pre(son[x][1],num),v[x]);
}
LL nxt(int x,LL num) {//后继
	if(!x) return inf;
	if(v[x]<num) return nxt(son[x][1],num);
	return min(nxt(son[x][0],num),v[x]);
}

##　删除
找到要删除的节点x，看它的左右儿子，旋转pos值较小的那个儿子，直到x成为叶子节点，删除x。

void del(int &x,LL bh) {
	if(!x) return;
	if(num[x]==bh) {
		if(son[x][0]*son[x][1]==0) {x=son[x][0]+son[x][1];return;}
		if(pos[son[x][0]]<pos[son[x][1]]) spin(x,0),del(x,bh);
		else spin(x,1),del(x,bh);
	}
	if(bh<num[x]) del(son[x][0],bh);
	else del(son[x][1],bh);
}

无旋treap

优点：可以可持久化，资磁的操作多
缺点：比splay慢
例题：洛谷P2464/codevs1840
打这道题的时候，我真的是比小j还烦恼…这道题有一种解法是离散+对于每一种书建立一棵无旋treap，然后进行操作。
无旋treap是基于合并与分裂两个操作的一种treap。

合并

现在我们有两棵分别以a和b为根的treap，想要a在左b在右的合并。如何合并呢？
首先，比较a和b的pos值，较小的那个可以作为一个根，然后将其左/右子树和另一个合并。如果是a，那么让a的右子树和b合并。如果是b，那么让b的左子树和a合并。

int merge(int a,int b) {
	if(!a) return b;
	if(!b) return a;
	if(pos[a]<pos[b]) {son[a][1]=merge(son[a][1],b),up(a);return a;}
	else {son[b][0]=merge(a,son[b][0]),up(b);return b;}
}

分裂

现在我们想在以x为根的子树里，左边分裂出一个num大小的树。怎么办？
我们的函数返回值是一个pair，这样可以存两棵分裂出来的子树的根：左边的和右边的。
首先特判两种可以直接分裂的情况：
1.x的左子树大小为num，此时可以直接分裂为左子树和以x为根的子树
2.x的左子树大小为num-1，此时可以直接分裂为以x为根的子树和右子树
然后再比较x左子树和num的大小，进行递归分裂。（不懂看代码）

#define pr pair<int,int>
#define mkp make_pair
pr split(int x,int num) {//从将树左边分离出一个num大小的
	if(!x) return mkp(0,0);
	int ls=son[x][0],rs=son[x][1];
	if(sz[son[x][0]]==num) {son[x][0]=0,up(x);return mkp(ls,x);}
	if(sz[son[x][0]]+1==num) {son[x][1]=0,up(x);return mkp(x,rs);}
	if(num<sz[son[x][0]]) {//递归分裂
		pr tmp=split(son[x][0],num);
		son[x][0]=tmp.second,up(x);
		return mkp(tmp.first,x);
	}
	else {
		pr tmp=split(son[x][1],num-sz[son[x][0]]-1);
		son[x][1]=tmp.first,up(x);
		return mkp(x,tmp.second);
	}
}

插入

有了上面两种操作，插入操作就变得轻松了许多，即新建一个节点，找到原树中该节点应该排在第几，然后分裂原来的树，再依次合并（分裂出来的左边，新节点，分裂出来的右边）
插入一个区间也与之类似。
代码：见完整代码标记处。

删除

找到要删除的节点，先分裂出该节点左边一棵子树，再分裂出该节点右边一棵子树，然后把两棵子树合并，就不要那个节点了。
删除一个区间也与之类似。
代码：见完整代码标记处。

区间操作

用类似于删除的方法把整个区间取出来，打上区间操作标记即可。
然后在合并和删除操作的时候都要记得pushdown。
例题就是bzoj3223/洛谷P3391 文艺平衡树　啦，完整代码下面有

完整代码

小J的烦恼

#include<bits/stdc++.h>
using namespace std;
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
#define pr pair<int,int>
#define mkp make_pair
const int N=600005;
int n,m,cnt,sss;
map<int,int> mp;
int rt[N],bk[N],son[N][2],pos[N],wz[N],sz[N];
int newjd(int x) {if(!mp[x]) mp[x]=++cnt; return mp[x];}
void up(int x) {sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;}
int merge(int a,int b) {
	if(!a) return b;
	if(!b) return a;
	if(pos[a]<pos[b]) {son[a][1]=merge(son[a][1],b),up(a);return a;}
	else {son[b][0]=merge(a,son[b][0]),up(b);return b;}
}
pr split(int x,int num) {//从将树左边分离出一个num大小的
	if(!x) return mkp(0,0);
	int ls=son[x][0],rs=son[x][1];
	if(sz[son[x][0]]==num) {son[x][0]=0,up(x);return mkp(ls,x);}
	if(sz[son[x][0]]+1==num) {son[x][1]=0,up(x);return mkp(x,rs);}
	if(num<sz[son[x][0]]) {
		pr tmp=split(son[x][0],num);
		son[x][0]=tmp.second,up(x);
		return mkp(tmp.first,x);
	}
	else {
		pr tmp=split(son[x][1],num-sz[son[x][0]]-1);
		son[x][1]=tmp.first,up(x);
		return mkp(x,tmp.second);
	}
}
int find(int x,int kth) {//wz小于kth的节点个数
	if(!x) return 0;
	if(wz[x]<=kth) return sz[son[x][0]]+1+find(son[x][1],kth);
	return find(son[x][0],kth);
}
int main()
{
	char ch[10];int x,y,z;
	n=read(),m=read(),srand(m);
	for(int i=1;i<=n;++i) {
		x=read(),bk[i]=newjd(x);
		pos[++sss]=rand(),sz[sss]=1,wz[sss]=i;
		rt[bk[i]]=merge(rt[bk[i]],sss);//这是插入操作
	}
	while(m--) {
		scanf("%s",ch),x=read(),y=read();
		if(ch[0]=='Q') {
			z=read(),z=newjd(z);
			printf("%d\n",find(rt[z],y)-find(rt[z],x-1));
		}
		else {
			pr t1,t2;
			t1=split(rt[bk[x]],find(rt[bk[x]],x)-1);//这里是删除操作
			t2=split(t1.second,1);
			rt[bk[x]]=merge(t1.first,t2.second);
			bk[x]=newjd(y);
			t1=split(rt[bk[x]],find(rt[bk[x]],x));//以下是插入操作
			pos[++sss]=rand(),sz[sss]=1,wz[sss]=x;
			rt[bk[x]]=merge(t1.first,merge(sss,t1.second));
		}
	}
	return 0;
}

文艺平衡树

#include<bits/stdc++.h>
using namespace std;
#define mkp make_pair
#define pr pair<int,int>
const int N=100005;
int n,m,rt;
int son[N][2],rev[N],pos[N],sz[N];
void up(int x) {sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;}
void pd(int x) {
	if(son[x][0]) rev[son[x][0]]^=1;
	if(son[x][1]) rev[son[x][1]]^=1;
	swap(son[x][0],son[x][1]),rev[x]=0;
}
int merge(int a,int b) {
	if(!a) return b;
	if(!b) return a;
	if(rev[a]) pd(a); if(rev[b]) pd(b);//注意pushdown
	if(pos[a]<pos[b]) {son[a][1]=merge(son[a][1],b),up(a);return a;}
	else {son[b][0]=merge(a,son[b][0]),up(b);return b;}
}
pr split(int x,int num) {
	if(!x) return mkp(0,0);
	if(rev[x]) pd(x);//注意pushdown
	int ls=son[x][0],rs=son[x][1];
	if(sz[son[x][0]]==num) {son[x][0]=0,up(x);return mkp(ls,x);}
	if(sz[son[x][0]]+1==num) {son[x][1]=0,up(x);return mkp(x,rs);}
	if(num<sz[son[x][0]]) {
		pr tmp=split(son[x][0],num);
		son[x][0]=tmp.second,up(x);
		return mkp(tmp.first,x);
	}
	else {
		pr tmp=split(son[x][1],num-sz[son[x][0]]-1);
		son[x][1]=tmp.first,up(x);
		return mkp(x,tmp.second);
	}
}
int build(int l,int r) {
	if(l==r) {pos[l]=rand(),sz[l]=1;return l;}
	int mid=(l+r)>>1;
	return merge(build(l,mid),build(mid+1,r));
}
void print(int x) {
	if(rev[x]) pd(x);
	if(son[x][0]) print(son[x][0]);
	printf("%d ",x);
	if(son[x][1]) print(son[x][1]);
}
int main()
{
	int x,y;srand(14233);
	scanf("%d%d",&n,&m);rt=build(1,n);
	while(m--) {
		scanf("%d%d",&x,&y);
		pr t2=split(rt,y);
		pr t1=split(t2.first,x-1);
		rev[t1.second]^=1;
		rt=merge(t1.first,merge(t1.second,t2.second));
	}
	print(rt);
	return 0;
}

维护数列

既然学了无旋treap，就不得不去做一做这道神题啦！
你会发现无旋treap虽然比splay慢，可是编码速度更快呢！
戳我看代码

无旋treap树
Black__wing的博客
01-08 293
约定： 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为...
无旋Treap
蒟蒻QTY
08-03 1362
想要搞带区间的平衡树，要么用splay，要么用无旋treap。（现在只会后面的）     先%一下大佬LadyLex     无旋treap简言之不再有左旋和右旋，而多了拆分子树和合并子树的过程。     slipt为拆树。D 为定义的pair，first是拆下来的树，second是拆下来后剩下的原树。     如果要拆下来的树的大小比左子树小，就拆左子树，并把拆完的树接回来。
种下一棵树：有旋Treap
weixin_34362991的博客
07-26 91
第一个平衡树板子，有旋Treap。用随机函数规定一个堆，维护点权的同时维护堆的性质，可以有效地避免退化成链。按我的理解，建立一棵二叉排序树，树的形态会和给出节点的顺序有关。按照出题人很机智定理，数据肯定不会太容易操作，这时候就需要我们自行调整“数据顺序”，平衡树应运而生。 这个板子涵盖的操作有左旋、右旋(维护堆性质)、添加节点、删除节点(建树相关)、查找第x个元素、查...
不基于旋转的treap
zmh的博客
01-18 4034
介绍最近看到有一种不用旋转的treap，好像还可以持久化，于是就学了一下。treap就是tree+heap。它的每个节点的权值data满足排序二叉树的性质，随机权值key满足堆的性质。由于key是随机的所以它大致是平衡的。 不基于旋转的treap有两个基本操作：merge(a,b)：返回一个treap，包含a，b两个treap中的所有节点，但要保证b中所有节点权值都大于等于a。split(a,n)
【数据结构】【PT.1】 旋转treap（指针版）
m0_56406674的博客
03-22 335
前言 树堆，在数据结构中也称Treap，是指有一个随机附加域满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为O(logn)。相对于其他的平衡二叉搜索树，Treap的特点是实现简单，且能基本实现随机平衡的结构。 在深入了解Treap之前，我们先来了解一下BST。 BST(Binary-search tree),即二分搜索树，是一棵二叉树，且满足性质：若每个节点都有一个key值，则对于每个根节点，均满足key[leftson]<key[root]<key
无旋Treap——从入门到放弃
Friedrich_Taylor的博客
09-22 5231
前言已经是从入门到放弃的第四篇了。 但是本文并不打算给大家讲无旋Treap复杂度证明一类的。 很显然每次操作都是期望Olog(n)的{\bf O}\log(n)的什么是Treap？Treap=Tree+heap 其核心思想在于在权值上维护一棵二叉查找树，在优先级上维护一个堆 有旋treap利用旋转操作来维护堆的性质， 而无旋treap利用有序构树维护堆的性质。无旋Treap的两大构树顺序：
无旋treap
yzyyylx的博客
03-14 324
作用一种平衡树,可以只利用合并与拆分两种操作实现插入删除等所有二叉查找树可以做的事情.实现方法treap=tree+heap,利用tree来保持二叉查找树的功能,再利用heap来保证它是平衡树. 每个节点保存两个值,一个是题目给出的,要储存的值,还有一个是rand的且长期不变,建树时储存的值根据二叉查找树的性质来保存,同时保证rand()的值符合堆的性质,每个根为该子树的极值,这样就可以保证树的平
fhq treap入门
qq_35577488的博客
03-23 835
目录一.前言二.原理三.具体实现模板题目一.洛谷P3369:普通平衡树二.洛谷P3391 文艺平衡树 一.前言 这个数据结构早有耳闻.只是一直没学.跟着AgOH学了一波.发现很简单. 二.原理 二叉搜索树之所以不够优秀,是因为存在一些数据能够将二叉搜索树退化成一条链.从而导致平方级的复杂度.那么对于这个缺陷,大佬们想出了很多方法去解决,衍生出了①替罪羊树②有旋/无旋Treap③splay.今天我入门学习的就是无旋treap. Treap之所以能够克服二叉搜索树的缺陷,主要因为它以随机的方式构造二叉搜索树.使
Treap学习基本入门
Cynthia_wjyi
12-04 2090
Treap标准学习模板1.treap的基本了解(1)splay与treap的区别Splay的旋转操作是将普通节点转到根 而treap是将根转为普通节点(2)treap的时空复杂度treap的各项操作时间复杂度均摊为O(logn)。 由于treap的指针写法容易出错，所以通常用数组代替。 通常要有以下几种： v[]——存放键值 rnd[]——存放随机出的优先级 l[],r[]——左右子树的
无旋Treap——FHQ Treap
Lucas_FC_的博客
08-29 790
FHQ Treap
数据结构-非旋TREAP
Ice_teapoy的博客
01-03 722
Treap=Tree+Heap
[C++ 学习笔记] FHQ-Treap (无旋 Treap)
lzl20220405的博客
01-05 2095
C++ FHQ-Treap - 无旋 Treap - 树堆 学习笔记
【模板】带旋Treap（指针实现）
anlongyi8087的博客
10-06 153
参考题目：LOJ107 解析： 联赛结束后统一更模板题题解。 数组实现看这里 代码： #include<bits/stdc++.h> using namespace std; #define ll long long #define re register #define gc getchar #define pc putc...
模板 - 无旋Treap
weixin_30882895的博客
08-09 111
一般而言作为一棵平衡树只需要插入，删除，值求排名，排名求值，前驱，后继，六个接口。 #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 从狂转到不转
Chlience的博客
07-27 1175
在学习平衡树部分时,旁边的某位C姓dalao对Treap情有独钟,而我却为Splay的优美而深深着迷.这导致了对Treap的不屑一顾 这东西有什么用,那么多操作都不资瓷,low 如今繁华落尽,每次遇到需要使用平衡树的题时,不禁流下了悔恨的泪(汗)水 Splay真xx**难打! 所以,今天,就让我们来讲讲无旋Treap 无旋Treap 无旋Treap最大的优势就是编码简单...
11.2.2 蓝桥杯树形数据结构之平衡树FHQ—Treap(无旋Treap)
最新发布
tang7mj的博客
02-13 402
无旋Treap是Treap（树堆）数据结构的一个变种，结合了二叉搜索树和堆的特性。与传统的Treap通过旋转操作保持平衡不同，无旋Treap通过分裂（Split）和合并（Merge）操作维护树的平衡，避免了复杂的旋转逻辑，从而得名“无旋”。无旋Treap结合了二叉搜索树和堆的优点，通过分裂和合并操作维持平衡，既简化了实现又保持了高效的性能。在蓝桥杯等算法竞赛中，掌握无旋Treap能够帮助参赛者高效解决一系列动态数据集合的问题，是学习数据结构和算法的重要内容。
旋转Treap
xiji333的博客
02-04 496
文章目录Treap是什么基本结构基本操作初始化修改某个节点的siz左旋右旋插入数x删除数x查找数x的排名查找排名为x的数查找数x的前趋查找数x的后继完整模板 Treap是什么   树堆，在数据结构中也称TreapTreapTreap，是指有一个随机附加域满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为O(logn)O(logn)O(logn)。相对于其他的平衡二叉搜索树，TreapTreapTreap的特点是实现简单，且能基本实现随机平衡的结构。   Treap
无旋版 TreapTreap。
li123128的博客
05-01 360
无旋版 TreapTreap。只需要两个操作即可达到 splaysplay 的所有功能1、splitsplit它的主要思想就是把一个 TreapTreap 分成两个。 splitsplit 操作有两种类型，一种是按照权值分配，一种是按前 k 个分配。第一种就是把所有小于 k 的权值的节点分到一棵树中，第二种是把前 k 个分到一个树里。权值版： 1 void split(int o,int k,in...
史上最简单的平衡树——无旋Treap.pdf
01-14
史上最简单的平衡树——无旋Treap.pdf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值