253. 普通平衡树(平衡树,@Treap，@无旋Treap,模板题，* * )

已于 2024-06-17 22:11:50 修改
阅读量370 收藏 3
点赞数 1
分类专栏： # 平衡树 文章标签： 算法
于 2024-04-28 21:07:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Landing_on_Mars/article/details/138291184
版权
本文介绍了如何使用Treap（结合堆和二叉搜索树特性的一种数据结构）解决一个包含插入、删除、查询前驱后继等操作的问题，它在ACWing题库中用于高效维护数值并支持特定查询操作。
摘要由CSDN通过智能技术生成

253. 普通平衡树 - AcWing题库

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

  1. 插入数值 x。
  2. 删除数值 x(若有多个相同的数，应只删除一个)。
  3. 查询数值 x 的排名(若有多个相同的数，应输出最小的排名)。
  4. 查询排名为 x 的数值。
  5. 求数值 x 的前驱(前驱定义为小于 x 的最大的数)。
  6. 求数值 x 的后继(后继定义为大于 x 的最小的数)。

注意： 数据保证查询的结果一定存在。

输入格式

第一行为 n，表示操作的个数。

接下来 n 行每行有两个数 opt 和 x，opt 表示操作的序号(1≤opt≤6)。

输出格式

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

数据范围

1≤n≤100000,所有数均在 −107 到 107 内。

输入样例：
8
1 10
1 20
1 30
3 20
4 2
2 10
5 25
6 -1
输出样例：
2
20
20
20

解析： 

treap = tree+heap(相对其他树操作比较少)
红黑树(代码太长)
splay(比较难)
AVL

1 binary search tree BST 二叉搜索树
   val in root.left<root.val<val in root.right
中序遍历 是从小到大的
左中右
BST就是动态维护一个有序序列/有序集合

            5
           / \
          4   8
         /   / \
        2   6   9
       / \   \ 
      1   3   7

1 插入操作
1.1插入已有的值 以3为例
        2   
       / \    
      1   3
           \
            3
            3.cnt++
1.2插入没有的值 以10为例
            5
           / \
          4   8
         /   / \
        2   6   9
       / \   \   \
      1   3   7   10

2删除操作
2.1删除中间节点(把中间节点转为叶子节点)
2.2删除叶子节点(直接删)

3找前驱后继
3.1找前驱(前驱:中序遍历中在当前节点的前一个位置的节点)
3.1.1 如果当前节点root存在左子树  
      左子树root.left中的最大值(从root.left一直往右走)就是root的前驱
      left = root.left
      while(left.right) left = left.right
3.1.2 如果当前节点root不存在左子树
      就找父节点fa
      如果父节点是右爸爸 root=fa.left 那么root.val<fa.val 所以父节点fa不是root的前驱
          则继续看右爸爸的爸爸 fa.fa,直到出现左爸爸(当前节点是父节点右儿子)时,
          说明该父节点比当前节点以及当前节点的所有儿子都小
  (比答案小)o   o(比答案以及答案的所有子节点都大,不满足小于p)
             \ /
              o(答案,小于p的节点中的最大值)
               \ 
                o(第一个出现左爸爸的节点)
               /
              o(出发点p,只有右爸爸)
3.2找后继(后继:中序遍历中在当前节点的后一个位置的节点)

4 找最大/最小 end() begin()

1->4就是set()

5 求某个值的排名

6 求排名是k的数是哪个

7 比某个数小的最大值/比某个数大的最小值 

treap 让BST尽量随机(使得高度接近logn)

node
{
    int l,r;左儿子编号 右儿子编号
    int key,val;排序序号(BST,有序) 优先级(大根堆heap里的)
}tr[N]
root.val >= root.left.val 
root.val >= root.right.val
val取随机,则树的结构就随机(高度的平均就接近logn)

加两个哨兵
-∞  +∞ 处理边界
1 插入
    先递归到插进去再说(回溯时类似堆的回溯,如果当前p.val>fa.val 交换p和fa的位置)
    实现过程->左旋 & 右旋
     x               y
    / \  右旋zig    / \
   y   tt   ->     hh  x
  / \      <-         / \
 hh  z   左旋zag     z   tt
 hh,tt分别在整个序列的最前和最后 在旋转前后没有变化
 同时 中序遍历(递增序列)的结构在旋转前后都是 hh y z x tt 
     p               q
    / \  右旋zig    / \
   q   c   ->      a   p
  / \      <-         / \
 a   b   左旋zag     b   c
2 删除
    类似堆 把当前节点x交换到tt的位置,然后删除
    只不过在这里的操作是通过右旋
    可以发现每次右旋x就到了x.right的位置
    所以我们可以一直右旋直到x变为叶子节点,然后删除

作者：仅存老实人
链接：https://www.acwing.com/solution/content/20092/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
#include<sstream>
#include<deque>
#include<unordered_map>
#include<unordered_set>
#include<bitset>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<long long, long long> PLL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int INF = 0x3f3f3f3f;
const LL Mod = 2147483648;
const int N = 1e5 + 10, M = N * 25;
int n;
struct Node {
	int l, r;
	int key,val;
	int cnt, size;
}tr[N];
int root, idx;

void pushup(int& p) {
	tr[p].size = tr[tr[p].l].size + tr[tr[p].r].size + tr[p].cnt;
}

int get_node(int key) {
	tr[++idx].key = key;
	tr[idx].val = rand();
	tr[idx].cnt = tr[idx].size = 1;
	return idx;
}


void zig(int& p) {//right
	int q = tr[p].l;
	tr[p].l = tr[q].r;
	tr[q].r = p;
	p = q;
	pushup(tr[p].r);
	pushup(p);
}

void zag(int& p) {//left
	int q = tr[p].r;
	tr[p].r = tr[q].l;
	tr[q].l = p;
	p = q;
	pushup(tr[p].l);
	pushup(p);
}

void build() {
	root = get_node(-INF);
	tr[root].r = get_node(INF);
	pushup(root);
	if (tr[root].val < tr[tr[root].r].val) {
		zag(root);
	}
}

void insert(int&p,int key) {
	if (!p) {
		p = get_node(key);
	}
	else if (tr[p].key == key) {
		tr[p].cnt++;
	}
	else if (tr[p].key > key) {
		insert(tr[p].l, key);
		if (tr[tr[p].l].val > tr[p].val)zig(p);
	}
	else {
		insert(tr[p].r, key);
		if (tr[tr[p].r].val > tr[p].val)zag(p);
	}
	pushup(p);
}

void remove(int&p,int key) {
	if (!p)return;
	if (tr[p].key == key) {
		if (tr[p].cnt > 1)tr[p].cnt--;
		else if (tr[p].l || tr[p].r) {
			if (!tr[p].r || tr[tr[p].l].val > tr[tr[p].r].val) {
				zig(p);
				remove(tr[p].r, key);
			}
			else {
				zag(p);
				remove(tr[p].l, key);
			}
		}
		else {
			p = 0;
		}
	}
	else if(tr[p].key>key){
		remove(tr[p].l, key);
	}
	else {
		remove(tr[p].r, key);
	}
	pushup(p);
}

int get_rank_by_key(int p,int key) {
	if (!p)return 0;
	if (tr[p].key == key) {
		return tr[tr[p].l].size + 1;
	}
	if (tr[p].key > key)return get_rank_by_key(tr[p].l, key);
	return tr[tr[p].l].size + tr[p].cnt + get_rank_by_key(tr[p].r, key);
}

int get_key_by_rank(int p,int rank) {
	if (!p)return INF;
	if (tr[tr[p].l].size >= rank)return get_key_by_rank(tr[p].l, rank);
	if (tr[tr[p].l].size + tr[p].cnt >= rank)return tr[p].key;
	return get_key_by_rank(tr[p].r, rank - tr[tr[p].l].size - tr[p].cnt);
}

int get_pre(int p, int key) {
	if (!p)return -INF;
	if (tr[p].key >= key)return get_pre(tr[p].l, key);
	return  max(tr[p].key, get_pre(tr[p].r, key));
}

int get_next(int p, int key) {
	if (!p)return INF;
	if (tr[p].key <= key)return get_next(tr[p].r, key);
	return min(tr[p].key, get_next(tr[p].l, key));
}


int main() {
	cin >> n;
	build();
	int op, x;
	for (int i = 1; i <= n; i++) {
		scanf("%d%d", &op, &x);
		if (op == 1) {
			insert(root,x);
		}
		else if (op == 2) {
			remove(root,x);
		}
		else if (op == 3) {
			printf("%d\n", get_rank_by_key(root,x)-1);
		}
		else if (op == 4) {
			printf("%d\n", get_key_by_rank(root,x+1));
		}
		else if (op == 5) {
			printf("%d\n", get_pre(root,x));
		}
		else {
			printf("%d\n", get_next(root,x));
		}
	}	
	return 0;
}

无旋Treap：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
#include<sstream>
#include<deque>
#include<unordered_map>
#include<unordered_set>
#include<bitset>
#include<stdio.h>
using namespace std;
typedef long long LL;
//#define int LL
typedef unsigned long long ULL;
typedef pair<long long, long long> PLL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int inf = 0x3f3f3f3f;
const int INF = 0x3f3f3f3f3f3f3f3f;
const LL Mod = 998244353;
const int N = 1e5 + 10, M = 1 << 15;
int n, m;
int rt;
struct Treap {
	int son[N][2], s[N],w[N],pro[N];
	int idx;
	//bool fl[N];
	int build(int x) {
		w[++idx] = x, s[idx] = 1, pro[idx] = rand();
		return idx;
	}
	void up(int u) {
		s[u] = s[son[u][1]] + s[son[u][0]] + 1;
	}
	//void pushdown(int u) {
	//	swap(son[u][1], son[u][0]);
	//	int l = son[u][0], r = son[u][1];
	//	if (l)fl[l] ^= 1;
	//	if (r)fl[r] ^= 1;
	//	fl[u] = 0;
	//}
	int merge(int l, int r) {
		if (!l || !r) {
			return l + r;
		}
		if (pro[l] < pro[r]) {
			//if (fl[l])pushdown(l);
			son[l][1] = merge(son[l][1], r);
			up(l);
			return l;
		}
		//if (fl[r])pushdown(r);
		son[r][0] = merge(l, son[r][0]);
		up(r);
		return r;
	}
	void split(int u,int k,int &l,int&r) {
		if (!u) {
			l = r = 0;
			return;
		}
		//if (fl[u])pushdown(u);
		int &lch = son[u][0],& rch = son[u][1];
		if (k >= w[u]) {
			l = u;
			split(rch, k, rch, r);
		}
		else {
			r = u;
			split(lch, k, l, lch);
		}
		up(u);
	}
	int insert(int u, int x) {
		int l, r;
		split(u, x, l, r);
		return merge(merge(l, build(x)), r);
	}
	int delet(int u, int x) {
		int a, b, c;
		split(u, x, a, b);
		split(a, x - 1, a, c);
		c = merge(son[c][0], son[c][1]);
		return merge(merge(a, c), b);
	}
	int get_rank(int u, int x) {
		int a, b;
		split(u, x - 1, a, b);
		int ret = s[a]+1;
		merge(a, b);
		return ret;
	}
	int get_num(int u, int x) {
		while (1) {
			if (x > s[son[u][0]] + 1) {
				x -= s[son[u][0]] + 1;
				u = son[u][1];
			}
			else if (x <= s[son[u][0]]) {
				u = son[u][0];
			}
			else {
				return w[u];
			}
		}
	}	
}tr;

signed main() {

	int T;
	cin >> T;
	int x=0, y=0, z=0;
	while (T--) {
		int op, num;
		scanf("%d%d", &op, &num);
		if (op == 1) {
			rt = tr.insert(rt, num);
		}
		else if (op == 2) {
			rt=tr.delet(rt, num);
		}
		else if (op == 3) {
			printf("%d\n", tr.get_rank(rt, num));
		}
		else if(op==4) {
			printf("%d\n", tr.get_num(rt, num));
		}
		else if (op == 5) {
			int a, b;
			tr.split(rt, num - 1, a, b);
			printf("%d\n", tr.get_num(a, tr.s[a]));
			rt=tr.merge(a, b);
		}
		else {
			int a, b;
			tr.split(rt, num, a, b);
			printf("%d\n", tr.get_num(b, 1));
			rt = tr.merge(a, b);
		}
	}
	return 0;
}

Landing_on_Mars
关注
专栏目录
无旋treap（可持久化，区间操作），解决普通平衡树、文艺平衡树
avenLJY的博客
05-23 826
无旋treap 普通平衡树tyvj1728（treap模板） 如果想看旋转treap怎么写戳这儿 无旋treap代码： #include<bits/stdc++.h> using namespace std; const int N=5e5+5; struct node{ int val,ch[2],size,rd; #define l(x) t[x].ch[0] #define...
【Treap】普通平衡树
Maple的博客
08-18 179
平衡树模板Treap
平衡树——Treap讲解 + 例题：AcWing 253. 普通平衡树（长文详解 深入浅出）
Jacob0824的博客
04-16 1469
Treap（tree + heap） Treap 是 二叉搜索树 和 堆 两者的结合 ① 二叉搜索树（BST：Binary Search Tree） BST 中 每个节点均有权值 （一般情况下 BST 中无相同的权值，如果有相同权值，我们可以在每个节点上设置一个 计数器count，表示这个权值出现了多少次，这样就可以保证每个点的权值是不一样的，操作更加简便） BST 中 各个节点均满足： 当前节点 左子树中任意一点 的权值 严格小于 当前节点权值 当前节点 右子树中任意一点 的权值 严格大于 当前节点权值
P3391 【模板】文艺平衡树（@无旋Treap,* *）
Landing_on_Mars的博客
06-17 219
其中需要提供以下操作：翻转一个区间，例如原有序序列是 5 4 3 2 1，翻转区间是 [2,4] 的话，结果是 5 2 3 4 1。第一行两个正整数 𝑛,𝑚n,m，表示序列长度与操作个数。序列中第 𝑖i 项初始为 𝑖i。输出一行 𝑛n 个正整数，表示原始序列经过 𝑚m 次变换后的结果。对于 100% 的数据，1≤𝑛,𝑚≤100000，1≤𝑙≤𝑟≤𝑛。接下来 𝑚m 行，每行两个正整数 𝑙,𝑟l,r，表示翻转的区间。您需要写一种数据结构（可参考题目标题），来维护一个有序数列。
P3369-[模板]普通平衡树【无旋Treap】
QuantAsk
01-09 340
正题 题目链接:https://www.luogu.com.cn/problem/P3369 题目大意 一个空可重集，要求支持 插入一个数xxx 删除一个数xxx 询问一个数xxx的排名 询问排名第xxx的数字 询问xxx的前驱 询问xxx的后继 1≤n≤105,1≤∣x∣≤1071\leq n\leq 10^5,1\leq |x|\leq 10^71≤n≤105,1≤∣x∣≤107 解题思路 拖了两年的FHQ终于还是写了（还有二逼平衡树拖到现在还没写）。 看的是别人博客学的：https://www
Acwing253. 普通平衡树(treap=tree+heap) 晕乎乎的平衡树
weixin_54562114的博客
04-12 514
先来介绍一下平衡树吧，从博客的标题我们其实就能看出来了，平衡树实际上就是二叉搜索树和堆的一个结合，那为啥要把他们两个结合到一块呢？首先我们来看二叉搜索树，二叉搜索树就是满足左子树的所有值严格小于根节点，右子树的所有值都严格大于根节点性质的一棵树，如果我们对这棵树进行中序遍历就能够得到这序列的从小到大的排列，我们知道给定n个数来建立二叉搜索树，得到的数的高度是logn级别的，但是不乏会有一些极端情况会使得我们构建出来的二叉搜索树是一个单链，那它的高度就是n了，这样的情况我们很不想让它出现，所以我们引入...
【AcWing 253. 普通平衡树 】 treap
weixin_51979465的博客
04-01 776
题目链接 题意： 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入数值 x。 删除数值 x(若有多个相同的数，应只删除一个)。 查询数值 x 的排名(若有多个相同的数，应输出最小的排名)。 查询排名为 x 的数值。 求数值 x 的前驱(前驱定义为小于 x 的最大的数)。 求数值 x 的后继(后继定义为大于 x 的最小的数)。 注意： 数据保证查询的结果一定存在。 分析： 现在先来介绍一下平衡树是什么吧，其实平衡树就是一棵二叉搜索树，对于学过数据结构的童鞋对这个二叉搜索树的概
平衡树之FHQ Treap（无旋）
m0_53373033的博客
01-16 1354
平衡树——FHQ TreapFHQ\ TreapFHQ Treap（无旋） 学习 fhq Treapfhq\ Treapfhq Treap 之前，要先了解普通的 TreapTreapTreap 是怎么回事。 TreapTreapTreap ，就是 TreeTreeTree 加 HeapHeapHeap 。 它让平衡树上的每一个结点存放两个信息：值和一个随机的索引。其中值满足二叉搜索树的性质，索引满足堆的性质，结合二叉搜索树和二叉堆的性质来使树平衡。这也是 TreapT
平衡树——AcWing 253. 普通平衡树
u014114223的博客
07-15 705
平衡树是一种自平衡的二叉搜索树，它在进行插入和删除操作后能够自动调整其结构，以保持树的高度尽可能低，从而保证树的查找、插入和删除操作能够在对数时间内完成。最著名的平衡树有AVL树和红黑树。AVL树：是一种严格的平衡树，任何节点的两个子树的高度最多相差1。因此，AVL树是最严格的平衡树之一，保证了树的平衡性，但这也意味着在进行插入和删除操作时可能需要较多的旋转操作来维持平衡。红黑树。
史上最简单的平衡树——无旋Treap.pdf
01-14
### 最简平衡树——无旋Treap（fhq_treap）详解 #### 一、简介 无旋Treap（fhq_treap），由范浩强发明，是一种高效的平衡树数据结构。它综合了Treap与Splay树的优点，支持常见的平衡树操作如插入、删除、查找等，...
第6章 平衡树Treap 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第6章 平衡树Treap 测试数据
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 386
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 857
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 249
25[0, 105]
904. 水果成篮
最新发布
YQ20210216的博客
09-27 250
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
python 实现harmonic series调和级数算法
luthane的博客
09-24 902
Hn∑k1n1kHn​k1∑n​k1​其中，𝑛n 是正整数。这个级数是由调和数列（Harmonic sequence）的各元素相加所得的和。调和级数的名字源于泛音及泛音列，即一条振动的弦的泛音的波长依次是基本波长的12131421​31​41​等。调和级数的性质发散性：调和级数是一个发散的无穷级数，也就是说，它的部分和随着项数的增加而无限增长。
Hello Algorithm：Capture 1，2 初识算法
m0_62716099的博客
09-27 495
能力有限，欢迎大家一同交流讨论！
Treap：平衡二叉查找树的理论与实践
"郭家宝的平衡树讲稿：Treap的方法与应用，详细阐述了Treap数据结构，包括其平衡性、构造方法、优势及在信息学竞赛中的应用。" 本文详细介绍了Treap数据结构，一种结合了二叉查找树（Binary Search Tree, BST）和堆...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值