[学习笔记] treap

最新推荐文章于 2024-01-05 23:05:51 发布

C202044zxy

最新推荐文章于 2024-01-05 23:05:51 发布

阅读量250

点赞数

分类专栏：平衡树

本文链接：https://blog.csdn.net/C202044zxy/article/details/103244047

版权

平衡树专栏收录该内容

22 篇文章 0 订阅

订阅专栏

旋转treap

一些芝士

树堆，在数据结构中也称Treap，是指有一个随机附加域满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为O(logn)。相对于其他的平衡二叉搜索树，Treap的特点是实现简单，且能基本实现随机平衡的结构。--------百度百科

学习 $\text{Treap}$ 之前，我们先来了解一下二叉搜索树。

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。------百度百科

可以发现， $\text{BST}$ 有一个明显缺点，就是复杂度是跟树的深度直接挂钩的，在随机数据会表现得很好，但是很容易被卡掉，我们需要对其改良。

堆（英语：heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：
1、堆中某个节点的值总是不大于或不小于其父节点的值；
2、堆总是一棵完全二叉树。

这看起来毫无关联的两个数据结构，结合起来就有了 $\text{Treap}$ ，下面我们来详细介绍一下 $\text{Treap}$ 。

具体操作

数组定义

$c h [x] [0 / 1]$ 当前节点的左儿子 $/$ 右儿子
$v a l [x]$ 当前节点的值
$c n t [x]$ 当前节点出现了多少次
$s i z [x]$ 当前点的子树大小
$h p [x]$ 随机给当前点的修改值， $\text{Treap}$ 思想的精华就在于此，我们既要保证当前点的值大于左子树，小于右子树，又要保证修改值大于子树内的所有节点，我们随机修改值就能让树的形态随机，从而达到平均时间复杂度，改良该数据结构的目的。

更新操作

用于修改后更新节点的信息，日常操作。

void push_up(int x)
{
	siz[x]=siz[ch[x][0]]+siz[ch[x][1]]+cnt[x];
}

旋转操作

所谓旋转，就是在保证树性质不被改变的前提下改变树的形态，下面以举个例子，介绍一种旋转方法。
在这里插入图片描述
从中可以知道旋转需要改接两条边，把当前点的左儿子接到左儿子的右儿子，把左儿子的右儿子接到当前点，可以发现树的性质不会改变。

void rotate(int &x,int d)//0：左旋  1：右旋
{//这里打取值符是因为要修改旋转后的当前节点，便于返回
	int y=ch[x][d^1];
	ch[x][d^1]=ch[y][d];
	ch[y][d]=x;
	push_up(x);
	push_up(y);
	x=y;
}

插入操作

我们来分类讨论一下：

如果当前点没有编号，说明我们找到了，直接赋值后返回
如果当前点的值和我们要插入的值一样，把数量修改以后返回
否则看值应该在左子树还是右子树，函数返回需要看是否需要旋转，维护树的形态

void ins(int &x,int v)
{
	if(!x)
	{
		x=++Index;
		cnt[x]=siz[x]=1;
		ch[x][0]=ch[x][1]=0;
		hp[x]=rand();val[x]=v;
		return ;
	}
	if(val[x]==v)
	{
		cnt[x]++;
		siz[x]++;
		return ;
	}
	int d=v>val[x];
	ins(ch[x][d],v);
	if(hp[x]<hp[ch[x][d]])
		rotate(x,d^1);
	push_up(x);
}

删除操作

同样地，我们尝试分类讨论：

访问到空节点，直接返回
如果还没有找到值，看值是在左子树还是右子树
如果找到了值，执行下面的操作：
如果当前点是叶子节点，那么对于 $\text{heap}$ 的性质无影响，直接删除
如果当前点只有左儿子，那么右旋，一直把当前点旋转下去
只有右儿子同理
如果既有左儿子又有右儿子，选择 $\text{heap}$ 更大的旋转上来替换当前节点，把当前节点旋转下去

void del(int &x,int v)
{
	if(!x) return ;
	if(v!=val[x])
		del(ch[x][v>val[x]],v);
	else
	{
		if(!ch[x][0] && !ch[x][1])
		{
			cnt[x]--;
			siz[x]--;
			if(cnt[x]==0)
				x=0;
		}
		else if(ch[x][0] && !ch[x][1])
		{
			rotate(x,1);
			del(ch[x][1],v);
		}
		else if(!ch[x][0] && ch[x][1])
		{
			rotate(x,0);
			del(ch[x][0],v);
		}
		else
		{
			int d=hp[ch[x][0]]>hp[ch[x][1]];
			rotate(x,d);
			del(ch[x][d],v);
		}
	}
	push_up(x);
}

查询值的排名

如果查到了这个值，返回左子树的数量 $+ 1$
如果值在右子树，那么直接查询右子树，再加上左子树大小和当前点的数量
否则直接查找左子树

int rank(int x,int v)
{
	if(!x) return 0;
	if(v==val[x])
		return siz[ch[x][0]]+1;
	if(val[x]<v)
		return siz[ch[x][0]]+cnt[x]+rank(ch[x][1],v);
	return rank(ch[x][0],v);
}

查询排名的值

如果解在左子树，即左子树数量大于排名，查询左子树
如果排名比左子树大小加当前点数量大，说明解在右子树，查询右子树
否则解就是当前点，直接返回值

int ask(int x,int v)
{
	if(!x) return 0;
	if(siz[ch[x][0]]>=v)
		return ask(ch[x][0],v);
	else if(siz[ch[x][0]]+cnt[x]<v)
		return ask(ch[x][1],v-siz[ch[x][0]]-cnt[x]);
	return val[x];
}

查询值的前驱

如果当前点的值大于等于要查询的值，解在左儿子，查询左儿子
否则查询右儿子，注意可能存在没有右儿子的情况，要与当前点的值比较

int pre(int x,int v)
{
	if(!x) return -inf;
	if(val[x]>=v)
		return pre(ch[x][0],v);
	return max(val[x],pre(ch[x][1],v));
}

查询值的后继

如果当前点的值小于等于要查询的值，解在右儿子，查询右儿子
否则查询左儿子，注意可能存在没有左儿子的情况，要与当前点的值比较

int suf(int x,int v)
{
	if(!x) return inf;
	if(val[x]<=v)
		return suf(ch[x][1],v);
	return min(val[x],suf(ch[x][0],v));
}

这样就是 $\text{Treap}$ 所有的操作了，一定要理解其思想。

实战

有一道板题，【模板】普通平衡树，贴个代码。

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <ctime>
#define inf (2e9+5)
using namespace std; 
const int MAXN = 100005;
int read()
{
	int x=0,flag=1;char c;
	while((c=getchar())<'0' || c>'9') if(c=='-') flag=-1;
	while(c>='0' && c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
	return x*flag;
}
int n,rt,Index;
int ch[MAXN][2],val[MAXN],cnt[MAXN],siz[MAXN],hp[MAXN];
void push_up(int x)
{
	siz[x]=siz[ch[x][0]]+siz[ch[x][1]]+cnt[x];
}
void rotate(int &x,int d)
{
	int y=ch[x][d^1];
	ch[x][d^1]=ch[y][d];
	ch[y][d]=x;
	push_up(x);
	push_up(y);
	x=y;
}
void ins(int &x,int v)
{
	if(!x)
	{
		x=++Index;
		cnt[x]=siz[x]=1;
		ch[x][0]=ch[x][1]=0;
		hp[x]=rand();val[x]=v;
		return ;
	}
	if(val[x]==v)
	{
		cnt[x]++;
		siz[x]++;
		return ;
	}
	int d=v>val[x];
	ins(ch[x][d],v);
	if(hp[x]<hp[ch[x][d]])
		rotate(x,d^1);
	push_up(x);
}
void del(int &x,int v)
{
	if(!x) return ;
	if(v!=val[x])
		del(ch[x][v>val[x]],v);
	else
	{
		if(!ch[x][0] && !ch[x][1])
		{
			cnt[x]--;
			siz[x]--;
			if(cnt[x]==0)
				x=0;
		}
		else if(ch[x][0] && !ch[x][1])
		{
			rotate(x,1);
			del(ch[x][1],v);
		}
		else if(!ch[x][0] && ch[x][1])
		{
			rotate(x,0);
			del(ch[x][0],v);
		}
		else
		{
			int d=hp[ch[x][0]]>hp[ch[x][1]];
			rotate(x,d);
			del(ch[x][d],v);
		}
	}
	push_up(x);
}
int rank(int x,int v)
{
	if(!x) return 0;
	if(v==val[x])
		return siz[ch[x][0]]+1;
	if(val[x]<v)
		return siz[ch[x][0]]+cnt[x]+rank(ch[x][1],v);
	return rank(ch[x][0],v);
}
int ask(int x,int v)
{
	if(!x) return 0;
	if(siz[ch[x][0]]>=v)
		return ask(ch[x][0],v);
	else if(siz[ch[x][0]]+cnt[x]<v)
		return ask(ch[x][1],v-siz[ch[x][0]]-cnt[x]);
	return val[x];
}
int pre(int x,int v)
{
	if(!x) return -inf;
	if(val[x]>=v)
		return pre(ch[x][0],v);
	return max(val[x],pre(ch[x][1],v));
}
int suf(int x,int v)
{
	if(!x) return inf;
	if(val[x]<=v)
		return suf(ch[x][1],v);
	return min(val[x],suf(ch[x][0],v));
}
int main()
{
	srand(time(0));
	n=read();
	while(n--)
	{
		int op=read(),x=read();
		if(op==1)
			ins(rt,x);
		if(op==2)
			del(rt,x);
		if(op==3)
			printf("%d\n",rank(rt,x));
		if(op==4)
			printf("%d\n",ask(rt,x));
		if(op==5)
			printf("%d\n",pre(rt,x));
		if(op==6)
			printf("%d\n",suf(rt,x));
	}
}

无旋treap

无旋 $\text{treap}$ 主要的操作是 $\text{split,merge}$ ，就可以避免 $\text{rotate}$ ，由于无旋 $\text{treap}$ 是静态的，不仅可以支持区间操作，还可以持久化，下面就详细讲一下操作吧。

分裂 split

分裂分为权值分裂和排名分裂两种，我们把 $\text{split}$ 的返回值定为两棵树的根，注意维护一下左边的键值全部比右边的小。

node split(int x,int v)
{
	if(!x) return emp;
	int d=val[x]<=v;//注意必须打等于，包含val[x]的话要传给右儿子
	node y=split(ch[x][d],v);
	ch[x][d]=y.p[d^1];
	y.p[d^1]=x;
	push_up(x);
	return y;
}

合并 merge

合并要按修改值合并，维护根的修改值最小，如果两个根有一个为空，返回另一个根。

int merge(int x,int y)
{
	if(!x || !y) return x+y;
	if(hp[x]<hp[y])
	{
		ch[x][1]=merge(ch[x][1],y);
		push_up(x);
		return x;
	}
	ch[y][0]=merge(x,ch[y][0]);
	push_up(y);
	return y;
}

插入 insert

把整棵 $\text{treap}$ 按插入值 $v$ 裂成两棵树，在把第一棵树分裂，操作之后合并就行了，特别暴力。

int ins(int v)
{
	node tmp1=split(rt,v);
	node tmp0=split(tmp1.p[0],v-1);
	if(tmp0.p[1])
	{
		cnt[tmp0.p[1]]++;
		push_up(tmp0.p[1]);
		return merge(merge(tmp0.p[0],tmp0.p[1]),tmp1.p[1]); 
	}
	int x=++Index;
	cnt[x]=siz[x]=1;
	ch[x][0]=ch[x][1]=0;
	val[x]=v;hp[x]=rand();
	return merge(merge(tmp0.p[0],x),tmp1.p[1]);
}

删除 delete
类似于 $\text{insert}$ ，还是暴力。

int del(int v)
{
	node tmp1=split(rt,v);
	node tmp0=split(tmp1.p[0],v-1);
	if(tmp0.p[1] && cnt[tmp0.p[1]]>1)
	{
		cnt[tmp0.p[1]]--;
		push_up(tmp0.p[1]);
		return merge(merge(tmp0.p[0],tmp0.p[1]),tmp1.p[1]);
	}
	return merge(tmp0.p[0],tmp1.p[1]);
}

还是这道板题【模板】普通平衡树，贴个代码。

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <ctime>
#define inf 2147483647
using namespace std;
const int MAXN = 100005; 
int read()
{
	int x=0,flag=1;char c;
	while((c=getchar())<'0' || c>'9') if(c=='-') flag=-1;
	while(c>='0' && c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
	return x*flag;
}
int n,rt,Index;
int ch[MAXN][2],cnt[MAXN],siz[MAXN],val[MAXN],hp[MAXN];
struct node
{
	int p[2];
	node() {p[0]=p[1]=0;}
}emp;
void push_up(int x)
{
	siz[x]=siz[ch[x][0]]+siz[ch[x][1]]+cnt[x];
}
node split(int x,int v)
{
	if(!x) return emp;
	int d=val[x]<=v;
	node y=split(ch[x][d],v);
	ch[x][d]=y.p[d^1];
	y.p[d^1]=x;
	push_up(x);
	return y;
}
int merge(int x,int y)
{
	if(!x || !y) return x+y;
	if(hp[x]<hp[y])
	{
		ch[x][1]=merge(ch[x][1],y);
		push_up(x);
		return x;
	}
	ch[y][0]=merge(x,ch[y][0]);
	push_up(y);
	return y;
}
int ins(int v)
{
	node tmp1=split(rt,v);
	node tmp0=split(tmp1.p[0],v-1);
	if(tmp0.p[1])
	{
		cnt[tmp0.p[1]]++;
		push_up(tmp0.p[1]);
		return merge(merge(tmp0.p[0],tmp0.p[1]),tmp1.p[1]); 
	}
	int x=++Index;
	cnt[x]=siz[x]=1;
	ch[x][0]=ch[x][1]=0;
	val[x]=v;hp[x]=rand();
	return merge(merge(tmp0.p[0],x),tmp1.p[1]);
}
int del(int v)
{
	node tmp1=split(rt,v);
	node tmp0=split(tmp1.p[0],v-1);
	if(tmp0.p[1] && cnt[tmp0.p[1]]>1)
	{
		cnt[tmp0.p[1]]--;
		push_up(tmp0.p[1]);
		return merge(merge(tmp0.p[0],tmp0.p[1]),tmp1.p[1]);
	}
	return merge(tmp0.p[0],tmp1.p[1]);
}
int rank(int x,int v)
{
	if(!x) return 0;
	if(v==val[x])
		return siz[ch[x][0]]+1;
	if(val[x]<v)
		return siz[ch[x][0]]+cnt[x]+rank(ch[x][1],v);
	return rank(ch[x][0],v);
}
int ask(int x,int v)
{
	if(!x) return 0;
	if(siz[ch[x][0]]>=v)
		return ask(ch[x][0],v);
	else if(siz[ch[x][0]]+cnt[x]<v)
		return ask(ch[x][1],v-siz[ch[x][0]]-cnt[x]);
	return val[x];
}
int pre(int x,int v)
{
	if(!x) return -inf;
	if(val[x]>=v)
		return pre(ch[x][0],v);
	return max(val[x],pre(ch[x][1],v));
}
int suf(int x,int v)
{
	if(!x) return inf;
	if(val[x]<=v)
		return suf(ch[x][1],v);	
	return min(val[x],suf(ch[x][0],v));
}
int main()
{
	srand(time(0));
	n=read();
	for(int i=1;i<=n;i++)
	{
		int op=read(),x=read();
		if(op==1)
			rt=ins(x);
		if(op==2)
			rt=del(x);
		if(op==3)
			printf("%d\n",rank(rt,x));
		if(op==4)
			printf("%d\n",ask(rt,x));
		if(op==5)
			printf("%d\n",pre(rt,x));
		if(op==6)
			printf("%d\n",suf(rt,x)); 
	}
}

C202044zxy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[学习笔记] treap

一些芝士树堆，在数据结构中也称Treap，是指有一个随机附加域满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为O(logn)。相对于其他的平衡二叉搜索树，Treap的特点是实现简单，且能基本实现随机平衡的结构。--------百度百科学习 Treap\text{Treap}Treap 之前，我们先来了解一下二叉搜索树。二叉查找树（Binar...
复制链接

扫一扫

专栏目录