SPLAY树

最新推荐文章于 2019-06-25 09:14:13 发布
最新推荐文章于 2019-06-25 09:14:13 发布
阅读量846 收藏 3
点赞数 3
分类专栏： 算法模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C20191522TL/article/details/86696334
版权

前言

根据研究表明，90%的访问都是针对10%的元素。提高这90%的访问的效率，就明显改善了对整个访问的效率。
核心思想：把最近访问过的结点提升到根，后续访问的深度将减小。把这种提升结点的操作称为“伸展Splay”。以伸展操作为基础的二叉排序树也就相应称为伸展树（Splay Tree）。

开始

基于前言中十分有用（坑爹 ）的话，于是我们需要用SPLAY树来优化时间，即把刚操作的点引到根下，即SPLAY函数。
但又如何实现这样的操作呢？不妨看看下面的解释。

正文

区别与平衡树（Treap），SPLAY有着更广泛的用途，如线段树的区间修改等等。
现在介绍一下SPLAY树中的一些基本代码。

结构与初始化

struct node{
    node *ch[2],*fa;
    int val,siz;
}tree[MAXN];
node *ncnt,*NIL,*root;
/*
ch：指向该节点的两个儿子的指针
fa：指向该节点父亲的指针
siz：以该节点为根的子树大小
val：该节点的值
tree：指针总容量大小
ncnt：指针计数器
NIL：人工配置的指向空节点的指针
root：指向树的根的指针
*/
void Init(){
    NIL=ncnt=&tree[0];
    NIL->val=-INF;
    root=NIL->ch[0]=NIL->ch[1]=NIL->fa=NIL;
}
/*
NIL与ncnt先指向tree[0]。
即tree[0]为NIL点，tree为内存空间。
root在一来为NIL。
NIL的父亲儿子的是它自己。
*/

插入

node *NewNode(int v){
    node *ret=(++ncnt);
	ret->ch[0]=ret->ch[1]=ret->fa=NIL;
    ret->val=v;ret->siz=1;
    return ret;
}
/*
附上了v值，siz变为了1。
ncnt指向了tree[1],tree[2],tree[3],tree[4]....
*/
void Insert(node *&rt,node *p,int v){
    if(rt==NIL){
        rt=NewNode(v);
        rt->fa=p;
        Splay(rt,NIL);
        return ;
    }
    rt->siz++;
    int d=(rt->val<v);
    Insert(rt->ch[d],rt,v);
}
/*
根据v值不断左左右右（根据二叉查找树的性质）
找到NIL，丢进去。
*/

SPLAY

作为SPLAY树中最核心的函数，SPLAY的基本思想是通过不断不破坏原树秩序的旋转，将一个点旋到另一个点的下面。
而如何不破坏原树秩序的旋转呢？
如图
在这里插入图片描述
（圆圈为一个点，三角形为一颗子树）
现要将X旋转到Y的上面去，发现A<X<B<Y<C，那么旋转时，可将B接成Y的左子树，Y变成X的右儿子，即为

在这里插入图片描述
转化为代码（需要注意许多顺序与细节）：

void PushUP(node *x){
    x->siz=x->ch[0]->siz+x->ch[1]->siz+1;
}//PushUP很随意
void Rotato(node *x){
    node *y=x->fa;
    int d=(x==y->ch[0]);
    x->fa=y->fa;
    if(y->fa!=NIL)y->fa->ch[y==(y->fa->ch[1])]=x;
    y->ch[!d]=x->ch[d];
    if(x->ch[d]!=NIL)x->ch[d]->fa=y;
    x->ch[d]=y;y->fa=x;
    if(root==y)root=x;
    PushUP(y);
}

那么SPLAY函数就可以写了吗？
再由（坑爹的 ）前言可知SPLAY本身也是一种比较迷的算法，为了更加的优化，我们可以在SPLAY时，将单旋优化为双旋，等下再来谈谈双旋为毛更优。
双旋，故名思意，单旋两次。
但旋哪些点才能更优，就很有讲究了，得视情况而定。

第一种情况一字型：
在这里插入图片描述
即：将Z选到根如何旋更优。
策略：先旋转父节点，再旋转当前节点。（先Y后Z）

第二种情况之字型：
在这里插入图片描述
策略：先旋它自己，再旋它自己。

等下再来谈谈的为毛双旋更优

那么，学习了双旋，SPLAY代码也就出来了。

void Splay(node *x,node *rt){
    node *y,*z;
    while(x->fa!=rt){
        y=x->fa;z=y->fa;
        if(z==rt)Rotato(x);
        else{
            if((x==y->ch[0])^(y==z->ch[0]))
                Rotato(x);
            else Rotato(y);
            Rotato(x);
        }
    }
    PushUP(x);
}

查找系列(+SPLAY优化)

node *Find(node *rt,int v){//第一个值为v的节点
    node *p;
    if(rt==NIL)return NIL;
    if(v==rt->val){
        p=rt->ch[0];
        while(p!=NIL&&p->val==v)
            rt=p,p=p->fa;
        Splay(rt,NIL);
        return rt;
    }
    if(rt->val>v)p=Find(rt->ch[0],v);
    else p=Find(rt->ch[1],v);
    if(p==NIL){p=rt;Splay(rt,NIL);}
    return p;
}
node *FindPrev(node *rt,int v){//v的前驱
    node *p;
    if(rt==NIL)return NIL;
    if(rt->val>=v)
		p=FindPrev(rt->ch[0],v);
	else{
		p=FindPrev(rt->ch[1],v);
		if(p==NIL){p=rt;Splay(p,NIL);}
	}
    return p;
}
node *FindNext(node *rt,int v){//v的后继
    node *p;
    if(rt==NIL)return NIL;
    if(rt->val<=v)
		p=FindNext(rt->ch[1],v);
	else{
		p=FindNext(rt->ch[0],v);
		if(p==NIL){p=rt;Splay(p,NIL);}
	}
    return p;
}
node *FindMax(node *rt){//最大值
    if(rt==NIL)return NIL;
    node *p=rt;
    while(p->ch[1]!=NIL)p=p->ch[1];
    Splay(p,NIL);
    return p;
}
node *FindMin(node *rt){//最小值
    if(rt==NIL)return NIL;
    node *p=rt;
    while(p->ch[0]!=NIL)p=p->ch[0];
    Splay(p,NIL);
    return p;
}
int GetRank(node *rt,int v){//v的排名
    if(rt==NIL)return 1;
    if(rt->val<v)return GetRank(rt->ch[1],v)+(rt->ch[0]->siz)+1;
    else return GetRank(rt->ch[0],v);
}
node *Select(int k,node *f){//排名为k的值
    node *p=root;int lsz;
    while(1){
        lsz=p->ch[0]->siz;
		if(k==lsz+1)break;
		if(lsz>=k)p=p->ch[0];
		else k=k-lsz-1,p=p->ch[1];
    }
	Splay(p,f);
	return p;
}

删点

//无哨兵版本

void Delete(node *rt,int v){
	int k=GetRank(rt,v);
	node *p,*q;
	if(k!=1&&k!=cnt){
		p=Select(k-1,NIL);
		q=Select(k+1,p);
	}
	else{
		if(k==cnt){
			q=Select(k-1,NIL);
			q->ch[1]=NIL;
		}
		else{
			q=Select(2,NIL);
			q->ch[0]=NIL;
		}
		return ;
	}
	q->ch[0]=NIL;
	Splay(q,NIL);
}
/*
将v的前驱SPLAY到根，v的后继SPLAY到根的儿子。
再更掉v的fa的ch，那么v的fa就与v失去了联系，即删除掉了v。
*/

完整代码与版题

版题

#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=500005;
const int INF=0X3F3F3F3F;
int n,opt,x,cnt;
struct node{
    node *ch[2],*fa;
    int val,siz;
}tree[MAXN];
node *ncnt,*NIL,*root;
void PushUP(node *x){
    x->siz=x->ch[0]->siz+x->ch[1]->siz+1;
}
void Rotato(node *x){
    node *y=x->fa;
    int d=(x==y->ch[0]);
    x->fa=y->fa;
    if(y->fa!=NIL)y->fa->ch[y==(y->fa->ch[1])]=x;
    y->ch[!d]=x->ch[d];
    if(x->ch[d]!=NIL)x->ch[d]->fa=y;
    x->ch[d]=y;y->fa=x;
    if(root==y)root=x;
    PushUP(y);
}
void Splay(node *x,node *rt){
    node *y,*z;
    while(x->fa!=rt){
        y=x->fa;z=y->fa;
        if(z==rt)Rotato(x);
        else{
            if((x==y->ch[0])^(y==z->ch[0]))
                Rotato(x);
            else Rotato(y);
            Rotato(x);
        }
    }
    PushUP(x);
}
node *Find(node *rt,int v){
    node *p;
    if(rt==NIL)return NIL;
    if(v==rt->val){
        p=rt->ch[0];
        while(p!=NIL&&p->val==v)
            rt=p,p=p->fa;
        Splay(rt,NIL);
        return rt;
    }
    if(rt->val>v)p=Find(rt->ch[0],v);
    else p=Find(rt->ch[1],v);
    if(p==NIL){p=rt;Splay(rt,NIL);}
    return p;
}
node *FindPrev(node *rt,int v){
    node *p;
    if(rt==NIL)return NIL;
    if(rt->val>=v)
		p=FindPrev(rt->ch[0],v);
	else{
		p=FindPrev(rt->ch[1],v);
		if(p==NIL){p=rt;Splay(p,NIL);}
	}
    return p;
}
node *FindNext(node *rt,int v){
    node *p;
    if(rt==NIL)return NIL;
    if(rt->val<=v)
		p=FindNext(rt->ch[1],v);
	else{
		p=FindNext(rt->ch[0],v);
		if(p==NIL){p=rt;Splay(p,NIL);}
	}
    return p;
}
node *FindMax(node *rt){
    if(rt==NIL)return NIL;
    node *p=rt;
    while(p->ch[1]!=NIL)p=p->ch[1];
    Splay(p,NIL);
    return p;
}
node *FindMin(node *rt){
    if(rt==NIL)return NIL;
    node *p=rt;
    while(p->ch[0]!=NIL)p=p->ch[0];
    Splay(p,NIL);
    return p;
}
node *NewNode(int v){
    node *ret=(++ncnt);
	ret->ch[0]=ret->ch[1]=ret->fa=NIL;
    ret->val=v;ret->siz=1;
    return ret;
}
void Insert(node *&rt,node *p,int v){
    if(rt==NIL){
        rt=NewNode(v);
        rt->fa=p;
        Splay(rt,NIL);
        return ;
    }
    rt->siz++;
    int d=(rt->val<v);
    Insert(rt->ch[d],rt,v);
}
void Init(){
    NIL=ncnt=&tree[0];
    NIL->val=-INF;
    root=NIL->ch[0]=NIL->ch[1]=NIL->fa=NIL;
}
int GetRank(node *rt,int v){
    if(rt==NIL)return 1;
    if(rt->val<v)return GetRank(rt->ch[1],v)+(rt->ch[0]->siz)+1;
    else return GetRank(rt->ch[0],v);
}
node *Select(int k,node *f){
    node *p=root;int lsz;
    while(1){
        lsz=p->ch[0]->siz;
		if(k==lsz+1)break;
		if(lsz>=k)p=p->ch[0];
		else k=k-lsz-1,p=p->ch[1];
    }
	Splay(p,f);
	return p;
}
void Delete(node *rt,int v){
	int k=GetRank(rt,v);
	node *p,*q;
	if(k!=1&&k!=cnt){
		p=Select(k-1,NIL);
		q=Select(k+1,p);
	}
	else{
		if(k==cnt){
			q=Select(k-1,NIL);
			q->ch[1]=NIL;
		}
		else{
			q=Select(2,NIL);
			q->ch[0]=NIL;
		}
		return ;
	}
	q->ch[0]=NIL;
	Splay(q,NIL);
}
int main(){
    Init();
    scanf("%d",&n);
    while(n--){
        scanf("%d%d",&opt,&x);
        switch(opt){
            case 1:Insert(root,NIL,x);cnt++;break;
            case 2:Delete(root,x);cnt--;break;
            case 3:printf("%d\n",GetRank(root,x));break;
            case 4:printf("%d\n",Select(x,NIL)->val);break;
            case 5:printf("%d\n",FindPrev(root,x)->val);break;
            case 6:printf("%d\n",FindNext(root,x)->val);break;
        }
    }
}

后记

提取区间操作

假如我们要提取一个区间[a,b]
我们可以将a-1号节点提取到树根，b+1提取到树根的右儿子。
那么a-1即树根的左子树为（1~a-2），
b+1的右子树为（b+2~n），
则根（a-1）的右儿子（b+1）的左子树即为要提取的区间[a,b]。
提取后可以实现线段树的区间操作。

下传与上传

不过多解释。。。
可以自行加些其他要维护的变量。

void PushUP(node *x){ 
    x->siz=x->ch[0]->siz+x->ch[1]->siz+1; 
} 
void PushDown(node *rt){ 
    if(rt==NIL)return ; 
    if(rt->lazy==0)return ; 
    swap(rt->ch[0],rt->ch[1]); 
    if(rt->ch[0]!=NIL)rt->ch[0]->lazy^=1; 
    if(rt->ch[1]!=NIL)rt->ch[1]->lazy^=1;
	rt->lazy=0;
}

哨兵

在Delete与另外一些操作里，常常需要用到x-1与x+1。
但如果x为第一或最后一个节点时，便会出现RE的情况。
于是我们可以在插入前后分别加一个哨兵节点，以防RE的情况。
但要注意的是哨兵的存在不能影响其他的操作。
（如提取区间时，就提取x与y+2了）

写在后记之后

SPLAY毕竟很迷，有时双旋也过不了。
那么，你就随便SPLAY一些随机的节点吧。
SPLAY总是可以降低树的深度的，不要问我为什么。

FTOTL
关注
专栏目录
Splay树(伸展树)
不忘初心
07-23 1093
伸展树（Splay Tree），是一种二叉平衡搜索树，时间复杂度均摊为O(logN)，即splay树做m次操作的复杂度为O(mlogN)。 在伸展树上的一般操作都基于伸展操作/提根操作： 假设想要对一个二叉搜索树执行一系列的查找操作，为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法， 在每次查找之后对树进行重构，把被查找的条目搬移到离树根近
Splay树详细图解
最新发布
SunnyYuanJiawei的博客
03-29 124
Splay树详细图解。
Splay Tree
热门推荐
changtao381的专栏
05-16 2万+
类别：二叉排序树 空间效率：O(n) 时间效率：O(log n)内完成插入、查找、删除操作 创造者：Daniel Sleator和Robert Tarjan 优点：每次查询会调整树的结构，使被查询频率高的条目更靠近树根。 注：所有图片来自wiki。 http://blog.csdn.net/cyberzhg/article/details/8058208 Tree R
纸上谈兵: 伸展树 (splay tree)
weixin_33847182的博客
03-24 105
作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！    我们讨论过，树的搜索效率与树的深度有关。二叉搜索树的深度可能为n，这种情况下，每次搜索的复杂度为n的量级。AVL树通过动态平衡树的深度，单次搜索的复杂度为log(n) (以上参考纸上谈兵 AVL树)。我们下面看伸展树(splay tree)，它对于m次连续搜索操作有很好的...
Splay tree
花落知多少
06-25 300
Splay tree 将被查找的节点置于根的位置 deletion find x remove x findmax ( TLT_LTL​ ) make TRT_RTR​ the right child of the root of TLT_LTL​ https://blog.csdn.net/Woolseyyy/article/details/51512589 ...
Splay树
and1403的博客
03-30 230
对于被AVL虐得像那啥一样的我们，Splay的到来是无疑是拯（huo）救（shang）人（jiao）民（you）。 Splay树，又称伸展树，事实上，它根本就不是平衡树！然而它的平均时间复杂度确是O(log n)。 唯一和AVL树一样的是：转转转，转转转…… #----------------------------------------------------------...
Splay树题解1
08-03
【Splay树题解1】 Splay树是一种自调整的二叉查找树，它通过“旋转”操作使得频繁访问的节点更容易接近根节点，从而提高查找效率。这种数据结构能够高效地处理各种操作，包括查找、插入、删除以及一些特定的区间...
一个简单的 AVL树、splay树、以及二叉搜索树的代码实现
05-04
一个简单的 AVL树、splay树、以及二叉搜索树的代码实现 也可在我的github仓库中下载： https://github.com/yunwei37/myClassNotes
Splay树及其应用_朱全民.ppt
09-14
Splay树是一种自调整的二叉查找树，由丹尼尔·艾兹格(Daniel Sleator)和罗伯特·塔潘(Robert Tarjan)于1985年提出。这种数据结构针对二叉查找树在最坏情况下操作效率低下的问题进行了优化，其核心思想是每次对树进行...
Splay Tree(伸展树)
09-25 2万+
二叉查找树（BinarySearchTree）能够支持多种动态集合操作。因此，在信息学竞赛中，二叉排序树起着非常重要的作用，它可以被用来表示有序集合、建立索引或优先队列等。 作用于二叉查找树上的基本操作的时间是与树的高度成正比的。对一个含n各节点的完全二叉树，这些操作的最坏情况运行时间为O(logn)。但如果树是含n个节点的线性链，则这些操作的最坏情况运行时间为O(n)。而有些二叉查找树的
伸展树(Splay Tree)
12-17
伸展树（Splay Tree）是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
[Splay伸展树]splay树入门级教程
SKY的C
02-28 1万+
本弱鸟对于SPLAY树的一些理解。。。
伸展树(splay tree)
weixin_30611509的博客
10-16 558
对于二叉查找树而言，每次操作的最坏时间复杂度是O(N)。（当树退化为链表的时候）。为了解决这个问题，我们给树附加了一个平衡条件。平衡条件限制了任何节点的深度都不能过深。其中一种限制条件是：一颗二叉查找树的左子树和右子树的高度差不能超过1，这个条件限制产生了AVL树。 二叉查找树的最坏操作是O(N)。但是这样的操作并不常见。所以累加起来的时间就变得比单次操作时间的...
查找——图文翔解SplayTree（伸展树）
菜鸟的自留地-mooyang
05-27 8586
伸展树 伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它由Daniel Sleator和Robert Tarjan创造，后者对其进行了改进。 假设想要对一个二叉查找树执行一系列的查找操作。为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法，在每次查找之后对树进行重构，把被查找的条目搬移到离树根近一些的地方。splaytre
hihocoder #1329 : 平衡树·Splay
hexianhao的博客
10-10 1108
#1329 : 平衡树·Splay 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 小Ho：小Hi，上一次你跟我讲了Treap，我也实现了。但是我遇到了一个关键的问题。 小Hi：怎么了？ 小Ho：小Hi你也知道，我平时运气不太好。所以这也反映到了我写的Treap上。 小Hi：你是说你随机出来的权值不太好，从而
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值