Treap-平衡树学习笔记

最新推荐文章于 2023-05-06 22:22:39 发布
最新推荐文章于 2023-05-06 22:22:39 发布
阅读量447 收藏 1
点赞数
分类专栏： # Treap 平衡树 文章标签： 平衡树 Treap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niiick/article/details/79231728
版权

Treap=Tree+Heap

仔细观察Treap这个名字，你会发现他是Tree+Heap的合体
所以他的中文名叫树堆，正如其字面意思
对于权值而言，它是二叉查找树
对于优先级，它是堆

Treap的每个节点需要维护下列值

int rt;
int ch[maxn][2];//左右孩子指针,0为左孩子，1,为右孩子
int val[maxn],rnd[maxn],size[maxn],cnt[maxn],tot;
//val:权值,cnt:该节点保存相同权值的个数,size:该节点的子树的节点数,rnd:优先级
Treap–旋转

平衡树最重要的操作–旋转
直接按代码的步骤画图模拟一遍就很好理解了

这里以右旋(将p向右旋转)为例，一开始的树长这样
在这里插入图片描述

现在我们用指针K指向他的左子树

在这里插入图片描述

令p的左子树变成K的右子树
在这里插入图片描述
令K的右子树变成p
在这里插入图片描述

注意这里只在指针K上完成了旋转
我们还要赋值给p，即令p=k

左旋则正好相反，可以尝试自己画一下加深理解

//p：带旋转结点，d==0:左旋, d==1：右旋，旋转见图解 
void rotate(int &p,int d)//记得引用 
{
	int k=ch[p][d^1];
	ch[p][d^1]=ch[k][d];
	ch[k][d]=p;
	update(p); update(k);
	p=k;
}
Treap–插入

既然Treap是二叉查找树
那么插入自然按照二叉查找树的性质
即每个结点的左孩子权值一定小于该节点，而右孩子反之
只要按照二叉查找树的插入方式递归寻找带插入位置就好

然而，Treap还是个堆啊
所以插入后还要判断优先级
之前我们初始化优先级rnd为随机rand()
从而保证了整个程序平均的运行效率

void ins(int &p,int x)//记得引用 
{
	if(!p)//找到带插入节点 
	{ 
		p=++tot; val[p]=x; 
		rnd[p]=rand(); size[p]=cnt[p]=1;
		return;
	}
	if(val[p]==x){ ++size[p]; ++cnt[p]; return;}//若已有权值相同的结点，直接更新 
	int d=x<val[p] ?0:1;//查询应该往哪边插入 ，若x比该节点小，则cmp返回0，反之返回1
	ins(ch[p][d],x);
	if( rnd[ch[p][d]]<rnd[p]) rotate(p,d^1);//维护堆的性质 
	update(p);
}

Treap–删除

寻找待删除结点可以依照二叉查找树的性质
找到待删除节点后有几种情况

1.若结点保存了多个相同的值，则直接更新 s i z e − 1 , c n t − 1 size-1,cnt-1 size−1,cnt−1即可
2.若结点只有一棵子树，就以该子树代替该节点
3.若结点两棵子树都不为空，则先把优先级较高的子树旋转到根，然后递归在另一子树中继续寻找待删除结点

void del(int &p,int x)//记得引用 
{
	if(!p) return;
	if(val[p]==x)
	{
		if(cnt[p]>1){ --size[p]; --cnt[p]; return;}//若该节点保存了多个相同值，直接更新即可 
		else
		{
			if(!ch[p][0])p=ch[p][1];//如果这个结点只有一棵子树，就以该子树代替该节点
			else if(!ch[p][1])p=ch[p][0];
			else//两棵子树都不为空 
			{
				int dd=rnd[ch[p][0]] < rnd[ch[p][1]] ?1:0;
				rotate(p,dd); del(ch[p][dd],x);
				//先把优先级较高的子树旋转到根，然后递归在另一子树中删除p 
			}
		}
	}
	else if(x<val[p]) del(ch[p][0],x);
	else del(ch[p][1],x);
	if(p) update(p);//删除后一定要更新信息，更新前判断p不为NULL
}
Treap–查询排名

查询数x的排名

int rank(int p,int x)//查询函数都不加引用
{
	int ss=size[ch[p][0]];
	if(x<val[p]) return rank(ch[p][0],x);
	else if(x==val[p]) return ss+1;//找到待查询结点，则其排名为左子树节点数+1
	else return ss+cnt[p]+rank(ch[p][1],x);
	//待查询权值在右子树内
    //则该节点及其左子树必定小于待查询结点
    //所以加上该节点左孩子的size+该点cnt，递归右孩子
}
Treap–查询第K小

查询数x的排名

int kth(int p,int k)
{
	int ss=size[ch[p][0]];
	if(k<=ss) return  kth(ch[p][0],k);//若待查询排名小于左孩子数，则应继续在左子树递归寻找
	else if(k<=ss+cnt[p]) return val[p];//如果排名小于左孩子数加该节点cnt，则该节点为待查询结点
	else return kth(ch[p][1],k-ss-cnt[p]);//如果排名还要大，那就要往右子树找
}
Treap–前驱后继

求x的前驱(前驱定义为小于x，且最大的数)
求x的后继(后继定义为大于x，且最小的数)

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

int nxt(int p,int x)
{
	if(!p) return inf;
	if(x>=val[p]) return nxt(ch[p][1],x);
	else return min(val[p],nxt(ch[p][0],x));
}

一般题目中会出现的Treap操作都包含在了上面
下面给出洛谷 P3369 【模板】普通平衡树的完整代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

int read()
{
	int f=1,x=0;
	char ss=getchar();
	while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
	while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
	return f*x;
}

const int inf=1e9+7;
const int maxn=500010;
int n,rt,tot;
int rnd[maxn],val[maxn],ch[maxn][2];
int size[maxn],cnt[maxn];

void update(int p){ size[p]=size[ch[p][0]]+size[ch[p][1]]+cnt[p];}

void rotate(int &p,int d)
{
	int k=ch[p][d^1];
	ch[p][d^1]=ch[k][d];
	ch[k][d]=p;
	update(p); update(k);
	p=k;
}

void ins(int &p,int x)
{
	if(!p)
	{
		p=++tot; val[p]=x;
		rnd[p]=rand(); size[p]=cnt[p]=1;
		return;
	}
	if(val[p]==x){ size[p]++; cnt[p]++; return;}
	int d=x<val[p]?0:1;
	ins(ch[p][d],x);
	if(rnd[ch[p][d]]<rnd[p]) rotate(p,d^1);
	update(p);
}

void del(int &p,int x)
{
	if(!p) return;
	if(val[p]==x)
	{
		if(cnt[p]>1){ size[p]--; cnt[p]--; return;}
		else
		{
			if(!ch[p][1]) p=ch[p][0];
			else if(!ch[p][0]) p=ch[p][1];
			else
			{
				int dd=rnd[ch[p][0]]<rnd[ch[p][1]]?1:0;
				rotate(p,dd); del(ch[p][dd],x);
			} 
		}
	}
	else if(x<val[p]) del(ch[p][0],x);
	else del(ch[p][1],x);
	if(p) update(p);
}

int rank(int p,int x)
{
	int ss=size[ch[p][0]];
	if(x<val[p]) return rank(ch[p][0],x);
	else if(x==val[p]) return ss+1;
	else return ss+cnt[p]+rank(ch[p][1],x);
}

int kth(int p,int k)
{
	int ss=size[ch[p][0]];
	if(k<=ss) return kth(ch[p][0],k);
	else if(k<=ss+cnt[p]) return val[p];
	else return kth(ch[p][1],k-ss-cnt[p]);
}

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

int nxt(int p,int x)
{
	if(!p) return inf;
	if(x>=val[p]) return nxt(ch[p][1],x);
	else return min(val[p],nxt(ch[p][0],x));
}

int main()
{
	n=read();
	while(n--)
	{
		int opt=read(),x=read();
		if(opt==1) ins(rt,x);
		else if(opt==2) del(rt,x);
		else if(opt==3) printf("%d\n",rank(rt,x));
		else if(opt==4) printf("%d\n",kth(rt,x));
		else if(opt==5) printf("%d\n",pre(rt,x));
		else if(opt==6) printf("%d\n",nxt(rt,x));
	}
	return 0;
}

附赠一个指针版的

#include<iostream>
#include<cstdio>
#include<cmath>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;

int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}

const int inf=2e9;
int n; 
struct node
{
    node* ch[2];
    int size,cnt,rnd,val;
    node(int v): val(v) { size=cnt=1; rnd=rand(); ch[0]=ch[1]=NULL;}
    int cmp(int x){ if(x==val)return -1; return x<val?0:1;}
    void update()
    {
        size=cnt;
        if(ch[0]!=NULL) size+=ch[0]->size;
        if(ch[1]!=NULL) size+=ch[1]->size;
    }
};
node *rt=NULL;

void rotate(node* &p,int d)
{
    node* k=p->ch[d^1];
    p->ch[d^1]=k->ch[d];
    k->ch[d]=p;
    p->update(); k->update();
    p=k;
}

void ins(node* &p,int x)
{
    if(p==NULL){ p=new node(x); return;}
    if(x==p->val){ ++p->size; ++p->cnt; return;}
    int d=p->cmp(x);
    ins(p->ch[d],x);
    if(p->ch[d]->rnd < p->rnd) rotate(p,d^1);
    p->update();
}

void del(node* &p,int x)
{
    if(p==NULL) return;
    if(x==p->val)
    {
        if(p->cnt>1){ --p->size; --p->cnt; return;}
        if(p->ch[0]==NULL){ node* k=p; p=p->ch[1]; delete(k);}
        else if(p->ch[1]==NULL){ node* k=p; p=p->ch[0]; delete(k);}
        else
        {
            int dd=p->ch[0]->rnd < p->ch[1]->rnd ?1:0;
            rotate(p,dd); del(p->ch[dd],x);
        }
    }
    else if(x<p->val) del(p->ch[0],x);
    else del(p->ch[1],x);
    if(p!=NULL) p->update();
}

int rank(node* p,int x)
{
    int ss=p->ch[0]==NULL?0:p->ch[0]->size;
    if(x==p->val) return ss+1;
    else if(x<p->val) return rank(p->ch[0],x);
    else return ss+p->cnt+rank(p->ch[1],x);
}

int kth(node *p,int k)
{
    int ss=p->ch[0]==NULL?0:p->ch[0]->size;
    if(k<=ss) return kth(p->ch[0],k);
    else if(k<=ss+p->cnt) return p->val;
    else return kth(p->ch[1],k-ss-p->cnt);
}

int pre(node* p,int x)
{
    if(p==NULL) return -inf;
    int d=p->cmp(x);
    if(d==-1||d==0) return pre(p->ch[0],x);
    else return max(p->val,pre(p->ch[1],x));
}

int nxt(node* p,int x)
{
    if(p==NULL) return inf;
    int d=p->cmp(x);
    if(d==-1||d==1) return nxt(p->ch[1],x);
    else return min(p->val,nxt(p->ch[0],x));
}

int main()
{
    n=read();
    while(n--)
    {
        int k=read(),x=read();
        if(k==1) ins(rt,x);
        else if(k==2) del(rt,x);
        else if(k==3) printf("%d\n",rank(rt,x));
        else if(k==4) printf("%d\n",kth(rt,x));
        else if(k==5) printf("%d\n",pre(rt,x));
        else if(k==6) printf("%d\n",nxt(rt,x));
    }
    return 0;
}
niiick
关注
专栏目录
Treap
wsyear的博客
03-02 372
Treap=Tree+Heap,介绍Treap思路及常用操作
平衡树 - treap
繁凡さん的博客
08-20 721
整理的算法模板合集： ACM模板 operator 1 : 插入一个数 operator 2 : 删除一个数 operator 3 : 通过数值找排名 operator 4 : 通过排名找数值 operator 5 : 找到严格小于key的最大数（前驱） operator 6 : 找到严格大于key的最小数（后继） /*P3369 【模板】普通平衡树*/ const int N = 100010, INF = 1e8 + 7; int n, m; struct node{ int l, r;//左
python高级算法与数据结构:treap用于构造平衡二叉树的算法分析
tyler_download的专栏
10-16 345
treap数据结构用于记录两个维度的索引，一个维度跟随二叉树性质，能做到完全排序，另一个维度跟随堆性质，能做到部分排序，实际上treap本质目的并不在于此，它的目的在于用来平衡二叉树。在某些情况下二叉树可能会变成链表，例如依次插入已经排好序的元素时，所有的元素会沿着节点的有孩子，这种二叉树就不具备lg(n)搜索效率。 很多方法用来解决这个问题，例如2-3树，红黑树等。这些方法存在问题在于操作相当复杂，你去搜索一下红黑树的插入或删除操作就能体会它们应用起来的复杂性。前几节详细描述了treap如何根据其节点优先
Treap树堆
weixin_57128596的博客
12-23 686
主要体现的思想是随机插入数字，会给每个数字赋予一个优先级——>目的是让插入的关键字满足二叉树（节点的性质满足=（关键字:优先级））特点：被旋转的节点的左子树会到原父节点的右子树上（节点左旋，那么节点的右子树还是一直挂着保护着的）2.后面发现关键字2的优先级
【数据结构】图文详解Treap平衡树
qq_49688477的博客
07-27 1713
一、前言 FHQ平衡树是一种树形数据结构，它是对二叉查找树的一种优化方式，但是学习的过程是真的非常的…痛苦。 二、二叉查找树的概念 首先，我们称具有以下3个性质的树为二叉查找树（BST） 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 如图 在这张图中我们可以发现，在二叉查找树中，从根结点开始查找一个点的时间复杂度为logn级别，在我们想对树进行插入查找的时候都非常方便。 但是很遗憾，二叉查找树是有着它的缺陷的
数据结构之Treap
cinience的专栏
04-20 727
作者:Dong | 可以转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明 网址:http://dongxicheng.org/structure/treap/ 1. 概述 同splay tree一样，treap也是一个平衡二叉树，不过Treap会记录一个额外的数据，即优先级。Treap在以关键码构成二叉搜索树的同时，还按优先级来满足堆的性质。因而，Treap=tre
平衡树之treap
xffyjq的博客
08-14 516
之前的博客中简单地阐述了二叉查找树的概念及简单应用，并介绍了平衡树。接下来我们便开始研究平衡树中实现较为简单的一种——treap的具体写法。一、treap简介介绍treap之前，先允许我来介绍一下笛卡尔树。这种树有两个值，如果只看第一个值（以下称为第一关键字），其满足二叉查找树的性质，而只看第二个值（以下称为第二关键字），其满足堆的性质（即某节点所有子树值比其大或小）。顾名思义，treap=tree
平衡树 - FHQ 学习笔记
EricQian的博客
03-31 2608
平衡树 - FHQ 学习笔记 主要参考万万没想到 的 FHQ-Treap学习笔记。 本片文章的姊妹篇：平衡树 - Splay 学习笔记。 感觉完全不会平衡树，又重新学习了一遍 FHQ，一口气把常见套路都学完了。 一、大致内容及分类 FHQ(???)，全称非旋转 Treap，是一种可以用于维护按权值、排名分裂的数据结构。它相比与 Splay 虽然常数较大，但是实现起来代码难度相对容易，而且由于它非...
平衡树学习笔记
Recalling_Clouds的博客
01-12 275
平衡树学不会的，这辈子都学不会的 一、前置芝士 平衡树本质上看是一种 BST（二叉排序树） 而 BST 其实是一种非常容易理解的良心数据结构 BST 保证了这颗树的中序遍历是单调上升的 举个例子： BST 支持插入、删除以及查询等多种操作，我们一一来讲述 插入 插入很简单 我们知道二叉排序树有一个性质：对于每一个结点，设它的点权为 valvalval，那么它的左子树中的每一个点权值必定小于 valvalval，它的右子树中的每一个点权值必定大于 valvalval 插入时我们对于当前访问到的点的权值
C/C++学习笔记：算法知识之平衡树学习笔记，收藏一波吧！
CodingPs的博客
11-29 237
平衡树存储： size就是节点的个数。 value是节点代表的权值。 权值相同的两个节点被视为一个，num记录折叠数量。 rand是随机数，用来维护平衡树。 son就是两个儿子。 平衡树size更新： 实际操作中，各个变量的值都是不断更新的，size也不例外。 函数体： 一个节点包括的节点个数用脚也能想到：左儿子size与右儿子size的和，加上这个节点折叠数量。 ...
treap代码实现
02-19
void Insert(Node * &o,int x){//0为左子树，1为右子树 if(o==NULL){o = new Node(); o->ch[0]=o->ch[1]=NULL;o->key=x;o->weight=rand();} else{ int d=o->cmp(x); Insert(o->ch[d],x); if(o->ch[d]->weight>o->weight) rotate(o,d^1); } }
【学习笔记】FHQ-Treap
Fight_for_NOIP的博客
07-24 724
FHQ-Treap，也称非旋Treap，顾名思义，就是不需要通过旋转，而是通过split和merge维护的Treap。与Treap有点不同，FHQ-Treap能可持久化
学习笔记：平衡树Treap（非旋转）维护序列
少主大人殿下的博客
02-17 581
前言 找了半天网上的资料，说实话真的不好找哎，然后对着硕果仅存的几篇博客理解了半天。。。。依旧没有弄出什么结论来。 于是嘛。。。就只有对着以前抄的代码理解咯。。发现还是有效果的 基本原理 如果你用平衡树维护集合都不会的话，那你可以出门左拐，看看我的其它平衡树学习笔记 这里造成的一个很大的理解障碍就是它的确和用平衡树维护集合有区别的，其中最大的区别就是维护序列的时候给每个结点挂了一个权...
数据结构（5） treap
weixin_64197656的博客
01-18 1314
Treap
【数据结构】Treap树堆
最新发布
qq_23096319的博客
05-06 638
Treap就是Tree+heap，首先有二叉搜索树（BST）的数据，treapCnt记录当前的节点总数，节点和键值的映射key，每个节点的左右儿子childs，以及一个键可能存在多个副本，用cnt记录副本数，size记录子树大小，用于查找第k大元素。堆相关的数据：每个节点的优先级priority，这个优先级在创建节点时随机生成，保证了Treap的深度不会太大。
Treap图文详解、效率分析与拓展应用——清华大学计算机系 郭家宝
良月澪二的博客
12-16 5132
一、什么是 Treap Treap=Tree+HeapTreap=Tree+HeapTreap=Tree+Heap TreapTreapTreap是一种平衡树 TreapTreapTreap发音为[tri:p] 这个单词的构造选取了TreeTreeTree(树)的前两个字符和HeapHeapHeap(堆)的后三个字符，Treap=Tree+HeapTreap=Tree+HeapTreap=Tree...
Treap(平衡树)入门
人工智能方向，计算机视觉
07-21 1804
首先，我们需要依次了解二叉搜索树和Treap的概念： 二叉搜索树简介 Treap 然后，给一道板子题：普通平衡树 PS. Treap，Splay，01trie，红黑树，替罪羊树等都可以，然而我只学了Treap???? 代码： #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> using namespace std; const int N = 1000
数据结构之平衡树(Treap)
热门推荐
long-long-ago
06-19 2万+
平衡树是二叉搜索树和堆合并构成的新数据结构，所以它的名字取了Tree和Heap各一半，叫做Treap。 堆和树的性质是冲突的，二叉搜索树满足左子树<根节点<右子树，而堆是满足根节点小于等于(或大于等于)左右儿子。因此在Treap的数据结构中，并不是以单一的键值作为节点的数据域。Treap每个节点的数据域包含2个值，key和weight。 key值，和原来的二叉搜索树一样，满足左子树<根节点<右子
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值