splay【模板】

最新推荐文章于 2022-02-24 15:26:19 发布
最新推荐文章于 2022-02-24 15:26:19 发布
阅读量1.3k 收藏 1
点赞数 2
文章标签： splay 平衡树 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wpx18182323/article/details/81668874
版权

题目描述

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

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

输入输出格式

输入格式：

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

输出格式：

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

 

 

好吧，我承认我是从洛谷P3369上抄的题目，不过get了splay这个新技能我非常开心（尽管我并没有弄明白区间翻转），希望我也能把这个技能分享给大家。

先解释一下各个数组的含义：(N代表一共要开几个点，视情况改变）

1.son[N][2]

顾名思义，son[x][0]——x的左儿子，son[x][1]——x的右儿子。

因为splay是一棵搜索树，所以满足x的左儿子的权值比x的权值小，x的右儿子的权值比x的权值大。

2.f[N]

同上，f[x]就代表在这颗搜索树中x的父节点。

3.key[N]

key[x]代表x节点的权值。

4.cou[N]

因为是二叉搜索树，所以不能出现权值相同的点，所以cou[x]代表x节点的权值出现的次数。

5.siz[N]

siz[x]代表以x为根节点的子树大小（包括其本身）。

6.root

就是当前树的根节点（因为splay会不断旋转，所以根也不定）。

7.sz

动态开点的指针（不懂动态开点我也没办法……）。

 

好，那接下来就从splay中一个个函数说起吧。

1.clear（）

没啥太大用处，就是在删除函数中用来清除某个点的。

代码：

void clear(int x) {
	son[x][0]=son[x][1]=cou[x]=f[x]=siz[x]=key[x]=0;
}

2.get（）

就是判断x是它父节点的左儿子还是右儿子。

代码：

bool get(int x) {
	return son[f[x]][1]==x;//是就返回1，否则返回0.
}

3.update（）

在这道题里也就是更改一下siz[x]，不同的题里不同，视题而定。

代码：

void update(int x) {
	if(x) {//如果x不是虚拟父节点
		siz[x]=cou[x];
		if(son[x][0])siz[x]+=siz[son[x][0]];
		if(son[x][1])siz[x]+=siz[son[x][1]];
	}
}

4.rotate（）

这才是splay的核心！！

因为普通的二叉搜索树很容易被卡，比如对于2、15、42、63、75、89、97,

如果建成这样

是最理想的，时间复杂度刚好O(log(n)）;

但是如果……

那就跟暴力搜索没啥区别了，时间复杂度很容易被卡成O(n).

所以，我们就需要在建树的过程中不断的改变根节点，才能保证时间复杂度（但是要求严格的证明我可不会，你们还是找其他大佬吧）。

然后怎么旋转呢？

（正常应该是有左旋和右旋的，然而我懒，就写成一个函数了……）

举个例子（就拿右旋来说吧）

先画个图：

现在是A < y < B < z < C < x

然后呢我们希望把z旋转到y处，怎么办呢？

首先我们先让B变成y的右儿子，B的父亲变成y，

然后我们在讲y变成z的左儿子，y的父亲变成z，

最后我们将x的左儿子改为z，z的父亲改为x（前提是x不是虚拟父节点）。

改一下，就是

现在我们再来看，大小关系还是满足A < y < B < z < C < x.

非常完美，然后呢我们就可以随便改变节点的位置，同时还不改变大小关系。

（左旋同理）

这样我们就可以避免被卡成链的情况

代码：

void rotate(int x) {
	int old=f[x],oldf=f[old],whichson=get(x);
	son[old][whichson]=son[x][whichson^1],f[son[old][whichson]]=old;
	son[x][whichson^1]=old,f[old]=x;
	f[x]=oldf;
	if(oldf) {
		son[oldf][son[oldf][1]==old]=x;
	}
	update(old);//这时old为x的儿子，所以先update（old）。
	update(x);
}

（不太懂的可以自己模拟一下，毕竟手画那么多图很累……）

5.splay（）

这个函数就是旋转节点的。（注意如果x,f[x],f[f[x]]在一条链上，要先rotate（f[x]）,然后在rotate（x），据说只rotate（x）会被卡）。

代码：

void splay(int x,int goal) {//将x旋转为goal的儿子
	for(int fa; (fa=f[x])!=goal; rotate(x)) {
		if(f[fa]!=goal) {
			rotate((get(x)==get(fa))?fa:x);
		}
	}
	if(!goal)root=x;
}

（其实这道题可以偷个懒，我们可以直接将x旋转成根节点，这样有利于下面做题）

偷懒代码：

void splay(int x) {
	for(int fa; (fa=f[x]); rotate(x)) {
		if(f[fa]) {
			rotate((get(x)==get(fa))?fa:x);
		}
	}
	root=x;
}

6.insert（）

加入节点。

1.如果root=0，说明树为空，特判加入即可。

2.如果不为空，则：

          （1）.如果存在于x权值相同的节点，那么cou[节点标号]++，再用splay维护一下siz

          （2）.如果不存在，那么新开一个节点，再用splay维护一下siz

代码：

void insert(int x) {
	if(root==0) {
		sz++;
		son[sz][0]=son[sz][1]=f[sz]=0;
		key[sz]=x;
		cou[sz]=siz[sz]=1;
		root=sz;
		return;
	}
	int now=root,fa=0;
	while(1) {
		if(x==key[now]) {
			cou[now]++;
			update(now);
			update(fa);
			splay(now);
			break;
		}
		fa=now;
		now=son[now][key[now]<x];//判断x在now的左儿子里还是右儿子里
		if(now==0) {
			sz++;
			f[sz]=fa;
			son[sz][0]=son[sz][1]=0;
			cou[sz]=siz[sz]=1;
			son[fa][key[fa]<x]=sz;
			key[sz]=x;
			update(fa);
			splay(sz);
			break;
		}
	}
}

7.find（）

寻找x的排名

1.如果x小于key[now],就寻找now的左儿子

2.如果x等于key[now],就直接return (ans+1) 

3.如果x大于key[now],那么ans+=siz[son[now][0]]+cou[now],然后寻找now的右儿子

代码:

int find(int x) {
	int now=root,ans=0;
	while(1) {
		if(x<key[now]) {
			now=son[now][0];
		} else {
			ans+=(son[now][0]?siz[son[now][0]]:0);
			if(x==key[now]) {
				splay(now);
				return ans+1;
			}
			ans+=cou[now];
			now=son[now][1];
		}
	}
}

8.findx（）

寻找第x大的元素

1.如果now左儿子的大小>x，则直接寻找now的左儿子

2.如果now左儿子的大小和now的大小之和大于等于x，则key[now]就是答案

3.如果now左儿子的大小和now的大小之和小于x，则x-=now左儿子的大小和now的大小之和，然后在now右子树里寻找第x大的元素

代码：

int findx(int x) {
	int now=root;
	while(1) {
		if(son[now][0] && x<=siz[son[now][0]]) {
			now=son[now][0];
		} else {
			int temp=(son[now][0]?siz[son[now][0]]:0)+cou[now];
			if(x<=temp)return key[now];
			x-=temp;
			now=son[now][1];
		}
	}
}

9.pre（），next（）

就是找到x的前驱和后继，这时候就体现出偷懒代码的好处了！

我们先不管有没有x这个节点，先暴力加入，然后把x旋转到根节点

这个时候我们利用二叉搜索树的性质：

想一下，想在x的左儿子的右儿子的右儿子的右儿子……的值不就是x的前驱吗？

同理x的右儿子的左儿子的左儿子的左儿子……的值不就是x的后继吗？

然后我们找到了所求值，再把x删掉就好啦！

代码：

int pre() {
	int now=son[root][0];
	while(son[now][1])now=son[now][1];
	return now;
}
int next() {
	int now=son[root][1];
	while(son[now][0])now=son[now][0];
	return now;
}

10.del（）

最后一个函数了！！

我们先把x旋转到根节点，然后

1.如果cou[x]>1，那就cou[x]--，在update一下就行了

2.如果现在root既没有左儿子有没有右儿子（就是只剩root一个节点了），那就clear（root）就行了

3.如果现在root没有左儿子，那就把root变成现在root的右儿子，clear（原来的root）

4.如果现在root没有右儿子，那就把root变成现在root的左儿子，clear（原来的root）

5.如果不是以上几种情况，那就先找到x的前驱，把x的前驱旋转为根节点，然后此时x一定没有左儿子，那么直接将x的右儿子变成x前驱的右儿子，再clear（x）

代码：

void del(int x) {
	int whatever=find(x);
	if(cou[root]>1) {
		cou[root]--;
		update(root);
		return;
	}
	if(!son[root][0] && !son[root][1]) {
		clear(root);
		root=0;
		return;
	}
	if(!son[root][0]) {
		int oldroot=root;
		root=son[root][1];
		f[root]=0;
		clear(oldroot);
		return;
	}
	if(!son[root][1]) {
		int oldroot=root;
		root=son[root][0];
		f[root]=0;
		clear(oldroot);
		return;
	}
	int leftbig=pre(),oldroot=root;
	splay(leftbig);
	son[root][1]=son[oldroot][1];
	f[son[root][1]]=root;
	clear(oldroot);
	update(root);
	return;
}

 

OK，所有函数就都解释完了，最后贴一份完整代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<map>
#include<algorithm>
#include<queue>
#define N 1000000
#define mes(a,b) memset(a,b,sizeof(a))
using namespace std;
int son[N][2],f[N],cou[N],siz[N],key[N];
int root,sz;
void clear(int x) {
	son[x][0]=son[x][1]=cou[x]=f[x]=siz[x]=key[x]=0;
}
bool get(int x) {
	return son[f[x]][1]==x;
}
void update(int x) {
	if(x) {
		siz[x]=cou[x];
		if(son[x][0])siz[x]+=siz[son[x][0]];
		if(son[x][1])siz[x]+=siz[son[x][1]];
	}
}
void rotate(int x) {
	int old=f[x],oldf=f[old],whichson=get(x);
	son[old][whichson]=son[x][whichson^1],f[son[old][whichson]]=old;
	son[x][whichson^1]=old,f[old]=x;
	f[x]=oldf;
	if(oldf) {
		son[oldf][son[oldf][1]==old]=x;
	}
	update(old);
	update(x);
}
void splay(int x) {
	for(int fa; (fa=f[x]); rotate(x)) {
		if(f[fa]) {
			rotate((get(x)==get(fa))?fa:x);
		}
	}
	root=x;
}
void insert(int x) {
	if(root==0) {
		sz++;
		son[sz][0]=son[sz][1]=f[sz]=0;
		key[sz]=x;
		cou[sz]=siz[sz]=1;
		root=sz;
		return;
	}
	int now=root,fa=0;
	while(1) {
		if(x==key[now]) {
			cou[now]++;
			update(now);
			update(fa);
			splay(now);
			break;
		}
		fa=now;
		now=son[now][key[now]<x];
		if(now==0) {
			sz++;
			f[sz]=fa;
			son[sz][0]=son[sz][1]=0;
			cou[sz]=siz[sz]=1;
			son[fa][key[fa]<x]=sz;
			key[sz]=x;
			update(fa);
			splay(sz);
			break;
		}
	}
}
int find(int x) {
	int now=root,ans=0;
	while(1) {
		if(x<key[now]) {
			now=son[now][0];
		} else {
			ans+=(son[now][0]?siz[son[now][0]]:0);
			if(x==key[now]) {
				splay(now);
				return ans+1;
			}
			ans+=cou[now];
			now=son[now][1];
		}
	}
}
int findx(int x) {
	int now=root;
	while(1) {
		if(son[now][0] && x<=siz[son[now][0]]) {
			now=son[now][0];
		} else {
			int temp=(son[now][0]?siz[son[now][0]]:0)+cou[now];
			if(x<=temp)return key[now];
			x-=temp;
			now=son[now][1];
		}
	}
}
int pre() {
	int now=son[root][0];
	while(son[now][1])now=son[now][1];
	return now;
}
int next() {
	int now=son[root][1];
	while(son[now][0])now=son[now][0];
	return now;
}
void del(int x) {
	int whatever=find(x);
	if(cou[root]>1) {
		cou[root]--;
		update(root);
		return;
	}
	if(!son[root][0] && !son[root][1]) {
		clear(root);
		root=0;
		return;
	}
	if(!son[root][0]) {
		int oldroot=root;
		root=son[root][1];
		f[root]=0;
		clear(oldroot);
		return;
	}
	if(!son[root][1]) {
		int oldroot=root;
		root=son[root][0];
		f[root]=0;
		clear(oldroot);
		return;
	}
	int leftbig=pre(),oldroot=root;
	splay(leftbig);
	son[root][1]=son[oldroot][1];
	f[son[root][1]]=root;
	clear(oldroot);
	update(root);
	return;
}
int main() {
//freopen("add.in","r",stdin);
//freopen("add.out","w",stdout);
	int n;
	scanf("%d",&n);
	int op,x;
	for(int i=1;i<=n;i++){
		scanf("%d%d",&op,&x);
		switch(op){
			case 1:insert(x);break;
			case 2:del(x);break;
			case 3:printf("%d\n",find(x));break;
			case 4:printf("%d\n",findx(x));break;
			case 5:insert(x);printf("%d\n",key[pre()]);del(x);break;
			case 6:insert(x);printf("%d\n",key[next()]);del(x);break;
		}
	}
	return 0;
}

搞定，希望我的讲解能对你有帮助！！！

wpx18182323
关注
【模板】Splay
lsy_41的博客
03-10 260
Splay
splay模板基本操作
Hunter_HunterL的博客
08-04 402
Splay模板指针实现 splay中序遍历维护原序列下标的顺序，翻转后这个顺序会改变，但是splay中第x个数代表变换后序列中第x个数 这样就可以直接查找变换后的序列 重在代码 文艺平衡树 #include #include #include #include #define INF 0x3f3f3f3f using namespace std; struct node { no
splay 模板
09-05
splay经典代码,hdu1890,经典入门题,可作为模板
Splay（splay模板）
li_wen_zhuo的博客
04-08 404
题目描述 给定一个长度为 n 的整数序列，初始时序列为 {1,2,…,n−1,n}。 序列中的位置从左到右依次标号为 1∼n。 我们用 [l,r] 来表示从位置 l 到位置 r 之间（包括两端点）的所有数字构成的子序列。 现在要对该序列进行 m 次操作，每次操作选定一个子序列 [l,r]，并将该子序列中的所有数字进行翻转。 例如，对于现有序列 1 3 2 4 6 5 7，如果某次操作选定翻转子序列为 [3,6]，那么经过这次操作后序列变为 1 3 5 6 4 2 7。 请你求出经过 m 次操作后的序列。
Splay模板
dk810510的博客
01-07 84
打LCT的时候发现Splay很不熟, 因此这里贴一下模板 洛谷P3369 https://www.luogu.org/problem/show?pid=3369#sub /* 提一些要注意的点: 1. 注意判断边界, 不要访问到空节点 2. 每一次操作或访问完以后, 记得要splay到root 3. insert操作只要update当前节点和父亲节点即可, ...
splay模板
蒟蒻 lxw的博客
01-21 166
https://li-fish.github.io/categories/ACM/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/Splay/
splay模板（功能最全）
huzujun的博客
08-03 3758
回想起来splay大概是高中时的噩梦吧，手敲splay的确挑战太大了，不过到了acm时期，其实应该是不用惧怕splay的，把板子准备好就问题不大。 poj3580 虽然不是最简单的题，但是可以作为板子题 https://vjudge.net/problem/POJ-3580 题目大意： 要求实现一种数据结构，支持对一个数字序列的 6 种操作： ADD x y val：第 x...
Splay模板 Splay题型大荟萃
snowy_smile的博客
01-21 806
以HDU4453为例，整理了一些Splay的题型 /* 【算法介绍】 Splay叫做伸展树，是一种二叉搜索树，也可以说是一种平衡树结构。 其可以维护节点的左右次序值，也就是说，我们在Splay上做中序遍历的次序输出节点，得到的便是所有节点的左右次序。 【数据结构】 int ch[N][2], fa[N]; //节点的链接关系 int num[N], sz[N]; //节点个数与子树大小 1
Luogu P2234营业额统计（Splay模板题）
稚始稚终的博客
02-09 226
P2234 [HNOI2002]营业额统计 AC Code #include<bits/stdc++.h> using namespace std; const int N=5e4+10; int root,tot; struct splay_tree { int ff,cnt,ch[2],val,size; }tr[N]; void update(int x) { tr[x].size=tr[tr[x].ch[0]].size+tr[tr[x].ch[1]].size+tr[
Splay（伸展树）模板
01-10
Splay模板包括旋转，主函数Splay，插入，删除，最大值，最小值，查询k大，查询排名
Splay模板及部分理解
addmission的博客
02-24 627
Splay模板及部分理解 理解 Splay树在所有的操作中，其实都没有对于val进行比较，它维护的是一个序列的中序遍历，这满足一个的左根右的顺序，那么只要我们在插入时以左根右顺序找位置插入，那么最后的结果就是，中序遍历是一个从小到大的过程，即也维护了左小右大。（个人理解，不知正确与否） 代码模板 #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> usin
SplayBZOJ1208
qq_36876305的博客
01-11 198
题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1208 #include using namespace std; const int N = 1E5 + 7, MOD = 1000000; int size[N], cnt[N], key[N], ch[N][2], f[N]; int sz, rt; void c
Splay 模板
Object_的博客
03-08 166
模板题：https://www.luogu.org/problemnew/show/P3391 #include&lt;bits/stdc++.h&gt; using namespace std; const int N=100005; int ch[N][2],par[N],val[N],cnt[N],size[N],rev[N],root,ncnt; int n,m,x,y; bool c...
Splay树模板应用：区间操作题解
"Splay树题解1" Splay树是一种自调整的二叉搜索树，它的核心特性在于每次访问某个节点时，通过一系列的...在本题中，这种灵活性得到了很好的体现，通过统一的模板代码就能处理多种操作，简化了代码设计和维护的工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值