[Treap]普通平衡树（番外加强版）

最新推荐文章于 2024-01-23 06:00:00 发布
最新推荐文章于 2024-01-23 06:00:00 发布
阅读量131 收藏
点赞数
分类专栏： 模板 算法 题解 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49458360/article/details/114088053
版权
题解 同时被 3 个专栏收录
55 篇文章 0 订阅
订阅专栏
算法
33 篇文章 0 订阅
订阅专栏
模板
4 篇文章 0 订阅
订阅专栏

[Treap]普通平衡树（番外加强版）

题面

题目描述

您需要写一种数据结构，来维护一些数，其中需要提供以下操作：

  1. 插入 x \text{x} x数
  2. 删除 x \text{x} x数(若有多个相同的数，因只删除一个)
  3. 查询 x \text{x} x数的排名(排名定义为比当前数小的数的个数 +1 \text{+1} +1 )
  4. 查询排名为 x \text{x} x的数
  5. 求 x \text{x} x的前驱(前驱定义为小于 x \text{x} x，且最大的数)
  6. 求 x \text{x} x的后继(后继定义为大于 x \text{x} x，且最小的数)

输入格式

第一行为 n \text{n} n，表示操作的个数,下面 n \text{n} n 行每行有两个数 opt \text{opt} opt和 x x x， opt \text{opt} opt 表示操作的序号 ( 1 ≤ opt ≤ 6 ) ( 1 \leq \text{opt} \leq 6) (1≤opt≤6)

输出格式

对于操作 3,4,5,6 \text{3,4,5,6} 3,4,5,6 每行输出一个数，表示对应答案

样例数据

输入

10
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

输出

106465
84185
492737

数据范围

对于 100 % \text{100}\% 100% 的数据， 1 ≤ n ≤ 1 0 5 1\le n \le 10^5 1≤n≤105， ∣ x ∣ ≤ 1 0 7 |x| \le 10^7 ∣x∣≤107

算法解析

概念

Treap

树堆 \text{树堆} 树堆，在数据结构中也称 Treap \text{Treap} Treap，是指有一个随机附加域满足堆的性质的 二叉搜索树 [ 1 ] \text{二叉搜索树}^{[1]} 二叉搜索树[1]，其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为 O ( log ⁡ 2 n ) O(\log_{2}{n}) O(log2​n)。相对于其他的平衡二叉搜索树， Treap \text{Treap} Treap的特点是 实现简单 \text{实现简单} 实现简单，且能基本 实现随机平衡 \text{实现随机平衡} 实现随机平衡的结构。
Treap \text{Treap} Treap是一棵 二叉排序树 [ 1 ] \text{二叉排序树}^{[1]} 二叉排序树[1]，它的左子树和右子树分别是一个 Treap \text{Treap} Treap，和一般的二叉排序树不同的是， Treap \text{Treap} Treap纪录一个额外的数据，就是 优先级 \text{优先级} 优先级。 Treap \text{Treap} Treap在以关键码构成二叉排序树的同时，还满足 堆 \text{堆} 堆的性质(在这里我们假设节点的优先级大于该节点的孩子的优先级)。

二叉搜索树/二叉排序树

二 叉 搜 索 树 / 二 叉 排 序 树 [ 1 ] {二叉搜索树/二叉排序树}^{[1]} 二叉搜索树/二叉排序树[1]
二 叉 查 找 树 二叉查找树 二叉查找树（ B i n a r y S e a r c h T r e e Binary Search Tree BinarySearchTree），（又： 二 叉 搜 索 树 二叉搜索树 二叉搜索树， 二 叉 排 序 树 二叉排序树 二叉排序树）
它或者是一棵空树，或者是具有下列性质的二叉树：

  1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  3. 它的左、右子树也分别为二叉排序树。

应用

操作1

针对本题，我们可以先对数据进行处理建模：
例如像这组数据
12 5 18 2 9 15 19 17 16
就可以造成如图的树
在这里插入图片描述
做到这样只需要利用二叉搜索树的性质（上文提到）
递归找到节点所应该在的位置

#include<bits/stdc++.h>
#define INF 0x3fffffff
using namespace std;
int K,N,M,op,q,root,last,ans=0;
struct Node{//定义节点
	int val,l,r,cnt,size,f;
	//val是数值，l、r是左右儿子，cnt是当前值出现的个数，
	//size是当前节点和字数的个数，f是一个随机数
}node[10000039];
void pushup(int p){
	node[p].size=node[node[p].l].size+node[node[p].r].size+node[p].cnt;
	//所有的节点数是左儿子的节点数加右儿子的节点数加当前节点的个数
}
int newnode(int x){//新建节点（k为节点的个数）
	node[++K].val=x,node[K].cnt=node[K].size=1;//数值为x，cnt是1，子树和当前的总节点数是1
	node[K].f=rand();//f是一个随机数
	return K;
}
void insert(int &p,int x){//插入操作（操作1）
	if(!p)p=newnode(x);//找到空的位置就新建一个节点
	else if(x==node[p].val){node[p].cnt++,node[p].size++;}
	//如果这个节点已经有过就cnt++，并同时size++
	else if(x<node[p].val){insert(node[p].l,x);if(node[node[p].l].f<node[p].f)zag(p);}
	//如果x比当前值小，就向左边走
	else if(x>node[p].val){insert(node[p].r,x);if(node[node[p].r].f<node[p].f)zig(p);}
	//如果x比当前值大，就向右边走
	pushup(p);
}

0 x 3 f f f f f f f = 1073741823 0x3fffffff=1073741823 0x3fffffff=1073741823
0 x f f f f f f f f = 4294967295 = ? 0xffffffff=4294967295=? 0xffffffff=4294967295=?
(这两句话是拿来干嘛的

操作2

zag和zig是右旋和左旋
在这里插入图片描述

void zag(int &p){
	int k=node[p].l;
	node[p].l=node[k].r,node[k].r=p,p=k;
	pushup(node[p].r),pushup(p);
}
void zig(int &p){
	int k=node[p].r;
	node[p].r=node[k].l,node[k].l=p,p=k;
	pushup(node[p].l),pushup(p);
}
void erase(int &p,int x){
	if(node[p].val==x){//如果当前点与x相同
		if(node[p].cnt>1)node[p].cnt--;//个数大于1就直接cnt--
		else if(!node[p].l)p=node[p].r;//如果没有左儿子就向右
		else if(!node[p].r)p=node[p].l;//如果没有右儿子就向左
		//都有的话就看谁的f小，就往哪边转
		else if(node[node[p].l].f<node[node[p].r].f)zag(p),erase(node[p].r,x);
		else if(node[node[p].l].f>node[node[p].r].f)zig(p),erase(node[p].l,x);
	}
	else if(node[p].val>x)erase(node[p].l,x);
	else if(node[p].val<x)erase(node[p].r,x);
	//同样向左或向右
	pushup(p);
}

操作3、4

int getrank(int p,int x){
	if(!p)return 0;
	else if(node[p].val>x)return getrank(node[p].l,x);
	else if(node[p].val<x)return getrank(node[p].r,x)+node[node[p].l].size+node[p].cnt;
	else if(node[p].val==x)return node[node[p].l].size+1;
}
int getval(int p,int x){
	if(x<=node[node[p].l].size+node[p].cnt&&x>node[node[p].l].size)return node[p].val;
	else if(x<=node[node[p].l].size)return getval(node[p].l,x);
	else return getval(node[p].r,x-node[node[p].l].size-node[p].cnt);
}//自己理解吧

操作5、6

int get_pre(int p,int x){
	if(!p)return -INF;
	else if(x>node[p].val)return comp(node[p].val,get_pre(node[p].r,x),1);
	else return get_pre(node[p].l,x);
}
int get_nex(int p,int x){
	if(!p)return INF;
	else if(x<node[p].val)return comp(node[p].val,get_nex(node[p].l,x),0);
	else return get_nex(node[p].r,x);
}

主程序

int main(){
	srand((unsigned int)time(0));
	newnode(-INF),newnode(INF);
	root=1,node[1].r=2;pushup(1);
	scanf("%d",&N);
	while(N--){
		scanf("%d%d",&op,&q);
		if(op==1){insert(root,q);}
		if(op==2){erase(root,q);}
		if(op==3){printf("%d\n",getrank(root,q)-1);}
		if(op==4){printf("%d\n",getval(root,q+1));}
		if(op==5){printf("%d\n",get_pre(root,q));}
		if(op==6){printf("%d\n",get_nex(root,q));}
	}
	return 0;
}

完整代码

不要直接复制

#include<bits/stdc++.h>
#define INF 0xffffffff
using namespace std;
int K,N,op,q,root;
struct Node{int val,l,r,cnt,size,f;}node[100039];
int comp(int a,int b,bool x){return x?(a>b?a:b):(a>b?b:a);}
int newnode(int x){node[++K].val=x,node[K].cnt=node[K].size=1;node[K].f=rand();return K;}
void pushup(int p){node[p].size=node[node[p].l].size+node[node[p].r].size+node[p].cnt;}
void zag(int &p){
	int k=node[p].l;
	node[p].l=node[k].r,node[k].r=p,p=k;
	pushup(node[p].r),pushup(p);
}
void zig(int &p){
	int k=node[p].r;
	node[p].r=node[k].l,node[k].l=p,p=k;
	pushup(node[p].l),pushup(p);
}
void insert(int &p,int x){
	if(!p)p=newnode(x);
	else if(x==node[p].val){node[p].cnt++,node[p].size++;}
	else if(x<node[p].val){insert(node[p].l,x);if(node[node[p].l].f<node[p].f)zag(p);}
	else if(x>node[p].val){insert(node[p].r,x);if(node[node[p].r].f<node[p].f)zig(p);}
	pushup(p);
}
void erase(int &p,int x){
	if(node[p].val==x){
		if(node[p].cnt>1)node[p].cnt--;
		else if(!node[p].l)p=node[p].r;
		else if(!node[p].r)p=node[p].l;
		else if(node[node[p].l].f<node[node[p].r].f)zag(p),erase(node[p].r,x);
		else if(node[node[p].l].f>node[node[p].r].f)zig(p),erase(node[p].l,x);
	}
	else if(node[p].val>x)erase(node[p].l,x);
	else if(node[p].val<x)erase(node[p].r,x);
	pushup(p);
}
int getrank(int p,int x){
	if(!p)return 0;
	else if(node[p].val>x)return getrank(node[p].l,x);
	else if(node[p].val<x)return getrank(node[p].r,x)+node[node[p].l].size+node[p].cnt;
	else if(node[p].val==x)return node[node[p].l].size+1;
}
int getval(int p,int x){
	if(x<=node[node[p].l].size+node[p].cnt&&x>node[node[p].l].size)return node[p].val;
	else if(x<=node[node[p].l].size)return getval(node[p].l,x);
	else return getval(node[p].r,x-node[node[p].l].size-node[p].cnt);
}
int get_pre(int p,int x){
	if(!p)return -INF;
	else if(x>node[p].val)return comp(node[p].val,get_pre(node[p].r,x),1);
	else return get_pre(node[p].l,x);
}
int get_nex(int p,int x){
	if(!p)return INF;
	else if(x<node[p].val)return comp(node[p].val,get_nex(node[p].l,x),0);
	else return get_nex(node[p].r,x);
}
int main(){
	srand((unsigned int)time(0));
	newnode(-INF),newnode(INF);
	root=1,node[1].r=2;pushup(1);
	scanf("%d",&N);
	while(N--){
		scanf("%d%d",&op,&q);
		if(op==1){insert(root,q);}
		if(op==2){erase(root,q);}
		if(op==3){printf("%d\n",getrank(root,q)-1);}
		if(op==4){printf("%d\n",getval(root,q+1));}
		if(op==5){printf("%d\n",get_pre(root,q));}
		if(op==6){printf("%d\n",get_nex(root,q));}
	}
	return 0;
}

番外加强版

输入格式
第一行两个正整数 n,m \text{n,m} n,m，表示初始数的个数和操作的个数。

第二行 n \text{n} n个整数 a 1 , a 2 , a 3 , … , a n a_{1},a_{2},a_{3},\ldots,a_{n} a1​,a2​,a3​,…,an​ ，表示初始的数。
接下来 m \text{m} m行，每行有两个整数 opt \text{opt} opt 和 x x x 表示操作的序号 （ 1 ≤ opt ≤ 6 ） , x （1 \leq \text{opt} \leq 6）,x （1≤opt≤6）,x表示加密后的操作数。

我们记 last \text{last} last 表示上一次 3 , 4 , 5 , 6 3,4,5,6 3,4,5,6 操作的答案，则每次操作的 x x x 都要异或上 last \text{last} last才是真实的 x x x。初始 last \text{last} last 为 0 0 0。

输出格式
输出一行一个整数，表示所有 3 , 4 , 5 , 6 3,4,5,6 3,4,5,6 操作的答案的异或和。
样例
输入

6 7
1 1 4 5 1 4
2 1
1 9
4 1
5 8
3 13
6 7
1 4

输出

6

解析
只要把INF该大点
node开大点
再改亿 一下主程序

#include<bits/stdc++.h>
#define INF 0x7fffffff
using namespace std;
int K,N,M,op,q,root,last,p,ans;
struct Node{int val,l,r,cnt,size,f;}node[3000039];
template<typename item>
inline void read(register item &x){
	x=0;register char c=getchar();register bool f=0;
	while(c<'0'||c>'9'){if(c=='-')f=1;c=getchar();}
	while(c>='0'&&c<='9')x=(x<<3)+(x<<1)+(c^48),c=getchar();
	if(f)x=-x;
}
int comp(int a,int b,bool x){return x?(a>b?a:b):(a>b?b:a);}
int newnode(int x){node[++K].val=x,node[K].cnt=node[K].size=1;node[K].f=rand();return K;}
void pushup(int p){node[p].size=node[node[p].l].size+node[node[p].r].size+node[p].cnt;}
void zag(int &p){
	int k=node[p].l;
	node[p].l=node[k].r,node[k].r=p,p=k;
	pushup(node[p].r),pushup(p);
}
void zig(int &p){
	int k=node[p].r;
	node[p].r=node[k].l,node[k].l=p,p=k;
	pushup(node[p].l),pushup(p);
}
void insert(int &p,int x){
	if(!p)p=newnode(x);
	else if(x==node[p].val){node[p].cnt++,node[p].size++;}
	else if(x<node[p].val){insert(node[p].l,x);if(node[node[p].l].f<node[p].f)zag(p);}
	else if(x>node[p].val){insert(node[p].r,x);if(node[node[p].r].f<node[p].f)zig(p);}
	pushup(p);
}
void erase(int &p,int x){
	if(node[p].val==x){
		if(node[p].cnt>1)node[p].cnt--;
		else if(!node[p].l)p=node[p].r;
		else if(!node[p].r)p=node[p].l;
		else if(node[node[p].l].f<node[node[p].r].f)zag(p),erase(node[p].r,x);
		else if(node[node[p].l].f>node[node[p].r].f)zig(p),erase(node[p].l,x);
	}
	else if(node[p].val>x)erase(node[p].l,x);
	else if(node[p].val<x)erase(node[p].r,x);
	pushup(p);
}
int getrank(int p,int x){
	if(!p)return 1;
	else if(node[p].val>x)return getrank(node[p].l,x);
	else if(node[p].val<x)return getrank(node[p].r,x)+node[node[p].l].size+node[p].cnt;
	else if(node[p].val==x)return node[node[p].l].size+1;
	return 1;
}
int getval(int p,int x){
	if(x<=node[node[p].l].size+node[p].cnt&&x>node[node[p].l].size)return node[p].val;
	else if(x<=node[node[p].l].size)return getval(node[p].l,x);
	else return getval(node[p].r,x-node[node[p].l].size-node[p].cnt);
}
int getpre(int p,int x){
	if(!p)return -INF;
	else if(x>node[p].val)return comp(node[p].val,getpre(node[p].r,x),1);
	else return getpre(node[p].l,x);
}
int getnex(int p,int x){
	if(!p)return INF;
	else if(x<node[p].val)return comp(node[p].val,getnex(node[p].l,x),0);
	else return getnex(node[p].r,x);
}
int main(){
	//freopen("1.in","r",stdin);
	srand((unsigned int)time(0));
	newnode(-INF),newnode(INF);
	root=1,node[1].r=2;pushup(1);
	read(N);read(M);
	while(N--){read(q);insert(root,q);}
	while(M--){
		read(op),read(q);q^=last;
		if(op==1){insert(root,q);}
		if(op==2){erase(root,q);}
		if(op==3){last=getrank(root,q)-1;}
		if(op==4){last=getval(root,q+1);}
		if(op==5){last=getpre(root,q);}
		if(op==6){last=getnex(root,q);}
		if(op>=3){ans^=last;}
	}
	printf("%d\n",ans);
	return 0;
}
柴春阳
关注
专栏目录
第6章 平衡树Treap 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第6章 平衡树Treap 测试数据
【数据结构】图文详解Treap平衡树
qq_49688477的博客
07-27 1712
一、前言 FHQ平衡树是一种树形数据结构，它是对二叉查找树的一种优化方式，但是学习的过程是真的非常的…痛苦。 二、二叉查找树的概念 首先，我们称具有以下3个性质的树为二叉查找树（BST） 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 如图 在这张图中我们可以发现，在二叉查找树中，从根结点开始查找一个点的时间复杂度为logn级别，在我们想对树进行插入查找的时候都非常方便。 但是很遗憾，二叉查找树是有着它的缺陷的
二叉树——Treap树（平衡树）
linglingnana的博客
10-24 1069
什么是树形结构 树形结构是一层次的嵌套结构。一个树形结构的外层和内层有相似的结构，所以这种结构可以递归的表示。经典数据结构中的各种树状图是一种典型的树形结构：一棵树可以简单地表示为根、左子树、右子树。左子树、右子树又有自己的子树。 什么是二叉搜索树（Binary Search Tree） 每个元素有自己的键值，这些键值能比较大小。通常把键值放在BST的节点上。任意一个节点的键值，比它左子树的所有键值都大，比它右子树的所有键值都小——中序遍历就可以得到它的有序排列。 树形结构的作用——这里主要讲二叉搜索树 数
树堆（Treap）图文详解与实现
热门推荐
Dablelv 的博客专栏。
03-05 1万+
1.Treap的定义树堆（Treap）是二叉排序树（Binary Sort Tree）与堆（Heap）结合产生的一种拥有堆性质的二叉排序树。但是这里要注意两点，第一点是Treap和二叉堆有一点不同，就是二叉堆必须是完全二叉树，而Treap并不一定是；第二点是Treap并不严格满足平衡二叉排序树（AVL树）的要求，即树堆中每个节点的左右子树高度之差的绝对值可能会超过1，只是近似满足平衡二叉排序树的性质...
Treap树模板 hdu-4585
Lee's blog
09-13 564
目录 例题：hdu 4585 Treap树 1、Treap树的唯一性 2、Treap树的平衡问题 3、Treap树的数据结构 4、Treap树的插入 5、插入过程中维护堆的过程中用到的旋转 6、寻找第k大的数 O(logn) 7、查询某个数的名次 O(logn) 8、hdu 4585 AC代码 例题：hdu 4585 Treap树 是一种简单的平衡二叉搜索...
【图解Treap——平衡树】
coder-yhh的博客
06-03 535
Treap-平衡树的讲解纯个人理解
若干平衡树的C语言实现_C语言_平衡树_
09-29
在C语言中实现平衡树，通常会涉及到AVL树、红黑树或者Treap等经典的数据结构。 **AVL树** AVL树是最先被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名。AVL树的关键特性是...
史上最简单的平衡树——无旋Treap.pdf
01-14
### 最简平衡树——无旋Treap（fhq_treap）详解 #### 一、简介 无旋Treap（fhq_treap），由范浩强发明，是一种高效的平衡树数据结构。它综合了Treap与Splay树的优点，支持常见的平衡树操作如插入、删除、查找等，...
c++写的平衡树数据结构
03-24
平衡树的主要类型包括AVL树、红黑树、Splay树和Treap等。在这个C++实现中，我们可能看到的是AVL树或者红黑树，因为它们是最常见的平衡树类型，且都支持高效的插入和删除操作。AVL树以其严格的平衡条件（所有节点的...
treap(tree+heap就是二叉搜索树+堆)
hwdn3000的博客
02-23 642
1、Treap的定义 Treap是一棵二叉搜索树，只是每个节点多了一个优先级fix，对于每个节点，该节点的优先级小于等于其所有孩子的优先级。当然，引入优先级fix的目的就是防止退化成一条链，从而影响查找效率。 所以，这样看来就是：Treap中对于节点的关键字key来说，它是一棵二叉搜索树，而对于fix来说，它是一个最小堆，所以Treap可以看成是Tree+Heap，只是这里的Heap不一定是完全二......
浅析Treap——平衡树
weixin_30684743的博客
03-30 370
Treap，一种数据结构，支持插入节点、删除节点、求第x大的节点、求权值为x的节点的排名、求权值比x小的最大节点、求权值比x大的最小节点 提示：以下图片均由Powerpoint出品，请原谅丑陋无比的图 好吧图被吞了 【引子：二叉排序树和堆】 首先，我们要知道，Treap=Tree+Heap，Tree指的是二叉排序树，Heap则是指堆 1.Tree——二叉排序树 二叉排序树，是指根的左儿子比根小，右...
树：Treaps
最新发布
新华编程特战队
01-23 888
中完成，因为在每个节点上，人们可以根据比较删除树的一半，因此需要对数比较才能到达正确的节点（要添加或删除元素的位置）。函数在 BST 中搜索正确的位置，并在正确的位置添加节点，即根据 BST 和堆属性向右添加，并在添加后根据需要进行必要的旋转，对于旋转，将分别编写。（每个节点最多有 2 个子节点），这样左边的子节点存储的键小于根节点，右边的子节点存储的键大于根键，这对所有节点递归有效。是节点数，因为必须遍历路径中的所有节点才能到达正确的节点，在最坏的情况下可能是最后一个节点，例如，假设我们想在树中添加。
全网最强剖析平衡树Treap | 万字长文爆肝平衡树Treap
qq_45832461的博客
04-15 231
平衡树Treap 概念 Treap=Tree+Heap，是二叉搜索树和堆的结合体。Treap本身是一棵二叉搜索树，它的左子树和右子树也分别是一个Treap，和一般的二叉搜索树不同的是， Treap会记录一个额外的信息，就是优先级。Treap在以关键码构成二叉搜索树的同时，还满足堆的性质，具体来说它只满足堆的一个性质：对于大根堆，根节点的优先级大于左右孩子的优先级。对于小根堆，根节点的优先级小于左右孩子的优先级。 这些优先级是是在插入节点时，随机赋予的，Treap根据这些优先级满足堆的性质。因此，Treap是
普通平衡树（Treap）
~
10-29 484
普通平衡树Treap
平衡树——Treap讲解 + 例题：AcWing 253. 普通平衡树（长文详解 深入浅出）
Jacob0824的博客
04-16 1462
Treap（tree + heap） Treap 是 二叉搜索树 和 堆 两者的结合 ① 二叉搜索树（BST：Binary Search Tree） BST 中 每个节点均有权值 （一般情况下 BST 中无相同的权值，如果有相同权值，我们可以在每个节点上设置一个 计数器count，表示这个权值出现了多少次，这样就可以保证每个点的权值是不一样的，操作更加简便） BST 中 各个节点均满足： 当前节点 左子树中任意一点 的权值 严格小于 当前节点权值 当前节点 右子树中任意一点 的权值 严格大于 当前节点权值
Treap树堆C++实现
qq_44486439的博客
05-22 1535
Treap树堆C++实现 Treap Treap 树堆（Treap = Tree + Heap），指的是有一棵拥有键值、优先级两种权值且满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树，若每个结点的优先级事先给定且互不相等，那么整棵树的形态也唯一确定，与元素插入顺序无关，每个结点的优先级是随机确定的，因此个操作的时间复杂度也随机地，但插入、删除、查找的期望时间复杂度均为O(logn)，其左右子树也是Treap。通过使二叉搜索树满足堆的性质来尽量避免出现构造出单支树（时间复杂度退化为O(n)
数据结构-Treap(树堆) 详解
HeartFireY的博客
06-09 4831
Treap(树堆)是一种弱平衡的搜索树，与平衡树相同，Treap就是由Tree和Heap(树和堆)两种数据结构组合而成的数据结构。 Treap的每个节点上要额外储存一个值prioritypriority，代表每个节点的优先级。因此对于每个节点，不仅要满足二叉搜索树的基本性质，还需额外满足父节点的prioritypriority大于两个子节点的prioritypriority。实际上，这个prioriotypriorioty值又被称为"修正值"。
普通平衡树（treap）
bbbblzy的博客
07-21 6013
前言 您需要写一种数据结构，来维护一些数，其中需要提供一下的操作： 1.插入数值x 2.删除数值x（如果有多个，只删除一个） 3.查询数值x的排名（如有多个相同的数，应输出最小的排名） 4.查询排名为x的数值 5. 求数值x的前驱（小于x最大的数） 6.求数值x的后继（大于x最小的数） 首先我们引入一种数据结构叫二叉查找树（BST）。该树满足一下性质： 对于树的任意一个节点 ...
Treap：平衡二叉查找树的理论与实践
"郭家宝的平衡树讲稿：Treap的方法与应用，详细阐述了Treap数据结构，包括其平衡性、构造方法、优势及在信息学竞赛中的应用。" 本文详细介绍了Treap数据结构，一种结合了二叉查找树（Binary Search Tree, BST）和堆...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值