P3369 【模板】普通平衡树 Treap树堆学习笔记

最新推荐文章于 2023-06-09 11:52:38 发布
最新推荐文章于 2023-06-09 11:52:38 发布
阅读量542 收藏 2
点赞数
文章标签： Treap树堆 平衡树 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31036127/article/details/109749460
版权

文章目录

Treap = Tree + Heap (树堆 = 树 + 堆)

大佬的博客https://www.luogu.com.cn/blog/HOJQVFNA/qian-xi-treap-ping-heng-shu

简介 : 本质上是一种使用 随机权值维护堆的性质的二叉查找树, 通过基础的树旋转维持堆的性质,
由随机权值保证树高度为 logN

具体做法 : 插入或删除后, 若不满足 堆的性质 则旋转
优点 : 防止 退化成链表 简单好写, 是最好写的平衡树之一, 好理解
缺点 : 常数大

在这里插入图片描述

1. 例题1 洛谷P3369 【模板】普通平衡树

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：

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

1. 结构体定义如下
#define lson(u) (tree[u].chl[0])
#define rson(u) (tree[u].chl[1])
struct Node {
	int chl[2],     //chl[0]是左儿子 , chl[1]是右儿子
		val,        //节点值
		sz,         //以该节点的为根节点个数
		recy,       //该节点重复了几次
		rnd;        //随机优先级 
} tree[MAXN<<4];
2. 向上更新以u为根的树的节点个数
  1. 当前节点u的sz = 左子树sz + 右子树sz + u的重复次数recy(U)
inline void push_up(int u) {
	//更新节点以u为根的树的节点个数
	tree[u].sz = tree[lson(u)].sz + tree[rson(u)].sz + tree[u].recy;
}
3. 旋转操作 route
  1. 我们可以把左旋和右旋合并成为一个统一的函数
  2. 通过传入的操作数cmd实现相应的旋转
#define LROUTE 0
#define RROUTE 1
void route(int& u, int cmd) { //cmd=0左旋, cmd=1右旋
	int tmp = tree[u].chl[cmd^1];
	tree[u].chl[cmd^1] = tree[tmp].chl[cmd];
	tree[tmp].chl[cmd] = u;
	push_up(u), push_up(tmp); //不要忘了更新对应的sz
	u = tmp;
}
4. 插入操作 insert
  1. 和普通BST一样的插入, 并建立随机权值即可
  2. 插入后, 需要向上更新节点的 以该节点的为根节点个数sz
void insert(int& u, int key) {
	if(!u) { //走到叶子就新建节点
		u = ++tot;
		tree[u].sz = tree[u].recy = 1;
		tree[u].val = key;
		tree[u].rnd = rand(); //随机权值
		return ;
	}

	tree[u].sz ++;
	if(key == tree[u].val) { tree[u].recy ++; return ; }
	int cmd = (key > tree[u].val); //大于则向右插入
	insert(tree[u].chl[cmd], key);

	//插入后维护大根堆的性质
	//失衡的时候, 往与插入相反的方向旋转
	if(tree[u].rnd < tree[tree[u].chl[cmd]].rnd)
		route(u, cmd^1);
	push_up(u);
}
5. 删除操作 del
  1. 和普通的BST一样的删除, 分为 4种情况
    1. 没有这值为 key 的节点, 直接返回
    2. 当前根和key不相等, 就去相应的子节点解决
    3. 叶子节点, 直接删除
    4. 有左儿子, 没有右儿子, 右旋并去右儿子解决 (因为右旋后root转到了rig)
    5. 没有左儿子, 有右儿子, 左旋并去左儿子解决(因为左旋后root转到了lef)
    6. 左右都有, 就把 大的转上来 并去 另一个儿子 解决
  2. 使用 堆删除的方式, 把key 旋转到叶子 节点后删除
void del(int& u, int key) {
	if(!u) return ;

	if(key < tree[u].val) del(lson(u), key);
	else if(key > tree[u].val) del(rson(u), key);
	else { //4种删除情况
		if(!lson(u) && !rson(u)) { //叶子节点直接删除
			tree[u].sz --,
			tree[u].recy --;
			if(tree[u].recy == 0) u = 0;
		} else if(lson(u) && !rson(u)) { //只有左节点
			route(u, 1);
			del(rson(u), key);
		} else if(!lson(u) && rson(u)) { //只有右节点
			route(u, 0);
			del(lson(u), key);
		} else if(lson(u) && rson(u)) { //左右都有
			//把大的那个转上来，并去另一个子树解决
			int cmd = (tree[lson(u)].rnd > tree[rson(u)].rnd);
			route(u, cmd);
			del(tree[u].chl[cmd], key);
		}
	}
	push_up(u);
}
6. 查询排名rand_x
  1. 还是比较key, 小于往左, 大于往右
  2. 往右说明 root的左儿子中的所有节点都 小于key
    所以排名应加上 左儿子的节点的个数 和 根节点的重复次数
int rank_x(int u, int key) { //求key的排名
	if(!u) return 0;
	if(key == tree[u].val) //返回左子树个数 + 1
		return tree[lson(u)].sz + 1;
	else if(key < tree[u].val) //小于就去左子树找
		return rank_x(lson(u), key);
	else //大于就去右子树, 类似于权值线段树
		return   tree[lson(u)].sz +
				 tree[u].recy +
				 rank_x(rson(u), key);
}
7. 查询 K 小值 kth
  1. 如果左子树节点个数大于等于 k , 说明 k 小值还在左子树
  2. 如果左子树的节点个数加上根的重复次数仍然小于 k, 说明k小值在右子树
int kth(int u, int k) { //查询k小值
	if(!u) return 0;
	if(tree[lson(u)].sz >= k) return kth(lson(u), k);
	else if(tree[lson(u)].sz + tree[u].recy < k)
		return kth(rson(u), k-tree[lson(u)].sz-tree[u].recy);
	else return tree[u].val;
}
8. 求key的前驱 get_pre
  1. 只要根仍然大于等于key, 就向左子树找
  2. 向右走记得取max, 前驱定义为小于key，且最大的数
int get_pre(int u, int key) {
	if(!u) return -INF;
	if(key <= tree[u].val) 
		return get_pre(lson(u), key);
	else
		return max(tree[u].val, get_pre(rson(u), key));
}
9. 求key的后继 get_suf
int get_suf(int u, int key) {
	if(!u) return INF;
	if(key >= tree[u].val) 
		return get_suf(rson(u), key);
	else
		return min(tree[u].val, get_suf(lson(u), key));
}
完整代码
// #define debug
#ifdef debug
#include <time.h>
#include "win_majiao.h"
#endif

#include <iostream>
#include <algorithm>
#include <vector>
#include <string.h>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <math.h>

#define MAXN ((int)1e5+7)
#define ll long long int
#define INF (0x7f7f7f7f)
#define QAQ (0)

using namespace std;
typedef vector<vector<int> > VVI;

#define show(x...) \
	do { \
		cout << "[" << #x << " -> "; \
		err(x); \
	} while (0)

void err() { cout << "]" << endl; }
template<typename T, typename... A>
void err(T a, A... x) { cout << a << ' '; err(x...); }

namespace FastIO{

	char print_f[105];
	void read() {}
	void print() { putchar('\n'); }

	template <typename T, typename... T2>
	   inline void read(T &x, T2 &... oth) {
		   x = 0;
		   char ch = getchar();
		   ll f = 1;
		   while (!isdigit(ch)) {
			   if (ch == '-') f *= -1; 
			   ch = getchar();
		   }
		   while (isdigit(ch)) {
			   x = x * 10 + ch - 48;
			   ch = getchar();
		   }
		   x *= f;
		   read(oth...);
	   }
	template <typename T, typename... T2>
	   inline void print(T x, T2... oth) {
		   ll p3=-1;
		   if(x<0) putchar('-'), x=-x;
		   do{
				print_f[++p3] = x%10 + 48;
		   } while(x/=10);
		   while(p3>=0) putchar(print_f[p3--]);
		   putchar(' ');
		   print(oth...);
	   }
} // namespace FastIO
using FastIO::print;
using FastIO::read;

int n, m, Q, K, root, tot;

#define lson(u) (tree[u].chl[0])
#define rson(u) (tree[u].chl[1])
struct Node {
	int chl[2], //chl[0]是左儿子 , chl[1]是右儿子
		val, //节点值
		sz, //该节点的为根节点个数
		recy, //该节点重复了几次
		rnd; //随机优先级 
} tree[MAXN<<4];


void push_up(int u) {
	//更新节点以u为根的树的节点个数
	tree[u].sz = tree[lson(u)].sz + tree[rson(u)].sz + tree[u].recy;
}

#define LROUTE 0
#define RROUTE 1
void route(int& u, int cmd) { //cmd=0左旋, cmd=1右旋
	int tmp = tree[u].chl[cmd^1];
	tree[u].chl[cmd^1] = tree[tmp].chl[cmd];
	tree[tmp].chl[cmd] = u;
	push_up(u), push_up(tmp);
	u = tmp;
}

void insert(int& u, int key) {
	if(!u) {
		u = ++tot;
		tree[u].sz = tree[u].recy = 1;
		tree[u].val = key;
		tree[u].rnd = rand(); //随机权值
		return ;
	}

	tree[u].sz ++;
	if(key == tree[u].val) { tree[u].recy ++; return ; }
	int cmd = (key > tree[u].val); //大于则向右插入
	insert(tree[u].chl[cmd], key);

	//插入后维护大根堆的性质
	//失衡的时候, 往与插入相反的方向旋转
	if(tree[u].rnd < tree[tree[u].chl[cmd]].rnd)
		route(u, cmd^1);
	push_up(u);
}

void del(int& u, int key) {
	if(!u) return ;

	if(key < tree[u].val) del(lson(u), key);
	else if(key > tree[u].val) del(rson(u), key);
	else { //4种删除情况
		if(!lson(u) && !rson(u)) { //叶子节点直接删除
			tree[u].sz --,
			tree[u].recy --;
			if(tree[u].recy == 0) u = 0;
		} else if(lson(u) && !rson(u)) { //只有左节点
			route(u, 1);
			del(rson(u), key);
		} else if(!lson(u) && rson(u)) { //只有右节点
			route(u, 0);
			del(lson(u), key);
		} else if(lson(u) && rson(u)) { //左右都有
			//把大的那个转上来，并去另一个子树解决
			int cmd = (tree[lson(u)].rnd > tree[rson(u)].rnd);
			route(u, cmd);
			del(tree[u].chl[cmd], key);
		}
	}
	push_up(u);
}

int rank_x(int u, int key) { //求key的排名
	if(!u) return 0;
	if(key == tree[u].val) //返回左子树个数 + 1
		return tree[lson(u)].sz + 1;
	else if(key < tree[u].val) //小于就去左子树找
		return rank_x(lson(u), key);
	else //大于就去右子树, 类似于权值线段树
		return   tree[lson(u)].sz +
				 tree[u].recy +
				 rank_x(rson(u), key);
}

int kth(int u, int k) { //查询k大值
	if(!u) return 0;
	if(tree[lson(u)].sz >= k) return kth(lson(u), k);
	else if(tree[lson(u)].sz + tree[u].recy < k)
		return kth(rson(u), k-tree[lson(u)].sz-tree[u].recy);
	else return tree[u].val;
}

int get_pre(int u, int key) {
	if(!u) return -INF;
	if(key <= tree[u].val) 
		return get_pre(lson(u), key);
	else
		return max(tree[u].val, get_pre(rson(u), key));
}

int get_suf(int u, int key) {
	if(!u) return INF;
	if(key >= tree[u].val) 
		return get_suf(rson(u), key);
	else
		return min(tree[u].val, get_suf(lson(u), key));
}

signed main() {
#ifdef debug
	freopen("test.txt", "r", stdin);
	clock_t stime = clock();
#endif

	read(n);
	int cmd, val, ans;
	for(int i=1; i<=n; i++) {
		read(cmd, val);
		switch (cmd) {
		case 1:
			insert(root, val);
			break;
		case 2:
			del(root, val);
			break;
		case 3:
			ans = rank_x(root, val);
			printf("%d\n", ans);
			break;
		case 4:
			ans = kth(root, val);
			printf("%d\n", ans);
			break;
		case 5:
			ans = get_pre(root, val);
			printf("%d\n", ans);
			break;
		case 6:
			ans = get_suf(root, val);
			printf("%d\n", ans);
			break;
		default:
			break;
		}
	}
#ifdef debug
	clock_t etime = clock();
	printf("rum time: %lf 秒\n",(double) (etime-stime)/CLOCKS_PER_SEC);
#endif 
	return 0;
}

扩展应用

1. 线段树套平衡树，求区间前驱后继排名(就是线段树的每个节点都是一个平衡树)
2. 伸展树, 区间反转分割
3. 双端优先队列的实现 (可以 取最大最小值的堆)
  1. 使用Treap实现取出最大最小值即可
4. 游戏排名系统 (动态数据容器) 原文链接https://blog.csdn.net/yang_yulei/article/details/46005845
  1. 实现三种操作
    • 上传一条得分记录
    • 查看当前排名
    • 返回区间 [L,R] 内的排名记录
马角的逆袭
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第6章 平衡树Treap 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第6章 平衡树Treap 测试数据
二叉平衡树treap详解
05-30
平衡树treap的思想
对顶堆详解
最新发布
m0_69596371的博客
06-09 891
我们都知道，堆是一种及其有用的数据结构，他可以在短时间内维护出区间最值，但普通的堆能起到的作用毕竟是有限的，但我们可以考虑变形，解决更多的问题，例如今天我们要讲的对顶堆。顾名思义，对顶堆是两个堆，一个大根堆，一个小根堆组成的特殊的数据结构。
对顶堆
Happig的博客
03-31 3483
对顶堆 所谓对顶堆，有点想双栈对顶那样，一个是小根堆，另一个是大根堆。假设g是大根堆，l是小根堆，那么观察下图不难发现，两堆中间的元素，左边都是小于它的，且g.top()是小于它的最大值，右边都是大于它的，且l.top()是大于它的最小值 中位数问题 现在有一个序列动态输入，求每次输入后的中位数 利用上述对顶堆的思想，中位数肯定是中间的数，那么g和l维护的两个数就是动态输入时最中间的两个数，因此...
神奇的东西——对顶堆
Lucas_FC_的博客
04-16 634
一.定义   就是一个大根堆与一个小根堆的结合，可以用来解决动态区间第k大的问题。可以通过下图来理解。  那么我们如何建一个对顶堆呢？  上文说到，对顶堆是一种基于大根堆和小根堆的数据结构。最开始的时候，由于两者都是空的堆，我们随便将其插入进去即可。之后每一步操作边与大根堆的最大值相互比较，将其插入至正确的位置。  不过有些时候，实际情况中我们运用对顶堆最后得到的结果多数在堆顶附近，所以我们还需要对对顶堆进行调整，来达到实际的目的。  以中位数问题为例  现在有一个序列动态输入，求每次输入后的中位数  利
P3369 【模板】普通平衡树
SSL_WCR
03-10 135
题目 题目 思路 因为Erase函数没加&，改了3H…… 垂死病中惊坐起，小丑竟是我自己 code: #include<iostream> #include<cstdio> #include<algorithm> #include<cstdlib> using namespace std; struct Treap{ int l,r;//左右子编号 int v,d;//v权值（真），d随机值（旋转用） int cnt,size;//cnt重复
洛谷 P3369 【模板】普通平衡树
whisperlzw的博客
02-21 156
原题地址：https://www.luogu.org/problemnew/show/P3369 题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入xx数 删除xx数(若有多个相同的数，因只删除一个) 查询xx数的排名(排名定义为比当前数小的数的个数+1+1。若有多个相同的数，因输出最小的排名) 查询排名为xx的数 求xx的前驱(前驱定义为小...
若干平衡树的C语言实现_C语言_平衡树_
09-29
在C语言中实现平衡树，通常会涉及到AVL树、红黑树或者Treap等经典的数据结构。 **AVL树** AVL树是最先被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名。AVL树的关键特性是...
带测试用例的平衡树算法
03-22
常见的平衡树有AVL树、红黑树、Treap等。在这个项目中，我们关注的是C++实现的平衡树算法，它具有可测试性，意味着它可以方便地进行单元测试，确保各种操作的正确性。 首先，`OurCSCE310Tree.cpp`和`OurCSCE310Tree...
c++写的平衡树数据结构
03-24
平衡树的主要类型包括AVL树、红黑树、Splay树和Treap等。在这个C++实现中，我们可能看到的是AVL树或者红黑树，因为它们是最常见的平衡树类型，且都支持高效的插入和删除操作。AVL树以其严格的平衡条件（所有节点的...
P3369 【模板】普通平衡树（treap）
常胜将军的博客
09-05 375
题目：点击打开链接 题意：中文题，不解释。 分析：这题是平衡树操作的裸题，用treap或者splay都行，我这里用的是treap。treap入门推荐https://www.cnblogs.com/MyStringIsNotNull/p/9165675.html，写的非常详细，代码参考https://www.cnblogs.com/candy99/p/6105347.html。 代码： #...
splay普通平衡树coedvs4543
Loi_cgold
08-18 246
题目描述您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：插入x数删除x数(若有多个相同的数，因只删除一个)查询x数的排名(排名定义为比当前数小的数的个数+1。若有多个相同的数，因输出最小的排名)查询排名为x的数求x的前驱(前驱定义为小于x，且最大的数)求x的后继(后继定义为大于x，且最小的数) 输入输出格式输入格式：第一行为n，表示操作的个数,下面n行每行有两个数opt
P3369 【模板】普通平衡树(Splay)
weixin_33835690的博客
02-22 228
题目链接：https://www.luogu.org/problemnew/show/P3369 修改了一下之前的模板，支持重复数值的存储 1 #include<bits/stdc++.h> 2 using namespace std; 3 struct node 4 { 5 int val; 6 node *father;...
洛谷P3369 普通平衡树(Treap/Splay)
Ab.Ever
04-17 1785
题目描述您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的数，因只删除一个) 3. 查询x数的排名(若有多个相同的数，因输出最小的排名) 4. 查询排名为x的数 5. 求x的前驱(前驱定义为小于x，且最大的数) 6. 求x的后继(后继定义为大于x，且最小的数)输入输出格式输入格式：第一行为n，表示操作的个数,
P3369 【模板】普通平衡树（有序表做法）
WINDZLY的博客
10-21 247
题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入xx数 删除xx数(若有多个相同的数，因只删除一个) 查询xx数的排名(排名定义为比当前数小的数的个数+1+1。若有多个相同的数，因输出最小的排名) 查询排名为xx的数 求xx的前驱(前驱定义为小于xx，且最大的数) 求xx的后继(后继定义为大于xx，且最小的数) 输入输出格式 输入格式： ...
P3369 【模板】普通平衡树(FHQ_treap平衡树)
一个小菜鸡的博客
07-16 225
// #pragma GCC optimize(2) #include <algorithm> #include <iostream> #include <sstream> #include <cstring> #include <cstdio> #include <random> #include <cctype> #include <bitset> #include <string> #incl.
P3369 【模板】普通平衡树（Treap/SBT）
sdfzrlt的博客
04-07 335
splay
P3369 （Splay树模板）
Kuricip的博客
10-05 303
题目传送门 普通平衡树 题目大意 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入 xx 数 删除 xx 数(若有多个相同的数，因只删除一个) 查询 xx 数的排名(排名定义为比当前数小的数的个数 +1+1 ) 查询排名为 xx 的数 求 xx 的前驱(前驱定义为小于 xx，且最大的数) 求 xx 的后继(后继定义为大于 xx，且最小的数) 思路 Splay模板题，Splay的详细讲解可以参考大佬讲解 Splay树详解 仅用此题记录模板 AC Code /* 插入数值x。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值