初识splay tree （三）

最新推荐文章于 2022-01-27 00:03:30 发布
最新推荐文章于 2022-01-27 00:03:30 发布
阅读量624 收藏
点赞数
分类专栏： 算法入门 伸展树 数据结构 文章标签： splay 伸展树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014316038/article/details/45646263
版权

以 [NOI 2005 维护序列][1]为例，说明一下具体的splay tree 的代码编写和实现技巧。
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

翻转真的是一个BT的操作~~
一步一步来，首先，结构体定义：

typedef struct node{
        struct node *pre,*ch[2];
        int size,value,sums,maxs,maxl,maxr;
        bool rev,cover;
}node;
node *root,*nill,buf[MAXN],*stk[MAXN];
int bufsize,stksize;

root指向树根节点 nill指向所有的空叶子节点
buf和stk则是用来进行节点的预分配和回收，原题目只给了64MB内存，不回收会MLE。
sums代表子区间的和，maxs代表该子区间的最大子段和，
maxl代表该子区间左起最大的累加和
maxr代表该子区间右起最大的累加和

新建空树，初始化过程如下：

node *getnode(int value,node *fa){
        node *p=NULL;
        if(bufsize<MAXN){
            p=&buf[bufsize++];
        }else if(stksize>0){
            p=stk[--stksize];
            if(p->ch[0]!=nill) stk[stksize++]=p->ch[0];
            if(p->ch[1]!=nill) stk[stksize++]=p->ch[1];
        }else {
            p=(node*)malloc(sizeof(node));
        } p->size=1;
        p->value=p->sums=p->maxs=p->maxl=p->maxr=value;
        p->rev=p->cover=false; p->pre=fa; p->ch[0]=p->ch[1]=nill;
        return p;
}
int init(){
        bufsize=stksize=0;
        nill=getnode(-INF,NULL);
        nill->ch[0]=nill->ch[1]=nill->pre=NULL;
        nill->size=nill->sums=0;
        root=getnode(-INF,nill);
        root->ch[1]=getnode(-INF,root);
        update(root);
        return 0;
}

这里实现涉及了两个小技巧：
增加nill节点，不对nill进行update操作，将其sums和size置0，可以省去边界叶子节点判断的麻烦。
同时，为整个splay树增加了两个边界节点，value设为负无穷，方便区间边界的处理。

查找第POS位置的节点，并提取到根：

int select(int pos,node *fa){
        node *rt=root;
        while(rt!=nill){
            pushdown(rt);
            if(rt->ch[0]->size+1 == pos) break;
            else if(rt->ch[0]->size >= pos) rt=rt->ch[0];
            else {pos-=rt->ch[0]->size+1; rt=rt->ch[1];}
        }
        splay(rt,fa);
        return 0;
    }

这里，size域起到了作用，代表了该区间所有节点的总数，
注意到附加的全局叶子结点nill->size域为0，因此，nill不会影响到size域的计数。
而两个边界节点的size初始为1,是参与计数的。
查找方法很简单，判断当前节点左边孩子数量是否等于pos-1，若是此时的当前节点就是我们要找的，否则若小于pos-1,则往左走，再否则往右走。
同时每次访问前都要pushdown操作时必须的。

Splay(rt,fa),将rt伸展到指定的 祖先 fa下面：

int pushdown(node *x){
        if(x==nill || x==NULL) return 0;
        if(x->rev){
            x->rev=false;
            x->ch[0]->rev = !x->ch[0]->rev;
            x->ch[1]->rev = !x->ch[1]->rev;
            node *tmp=x->ch[0]; x->ch[0]=x->ch[1]; x->ch[1]=tmp;
            int t=x->maxl; x->maxl=x->maxr; x->maxr=t;
        }
        if(x->cover){
            x->cover=false;
            x->ch[0]->cover= x->ch[1]->cover=true;
            x->ch[0]->value= x->ch[1]->value=x->value;
            x->maxl=x->maxr=x->maxs=x->sums=x->value*x->size;
            if(x->value<0) x->maxl=x->maxr=x->maxs=x->value;
        }
        return 0;
}
    int update(node *x){
        if(x==nill || x==NULL) return 0;
        pushdown(x->ch[0]); pushdown(x->ch[1]); //must pushdown when you visited it
        x->size = x->ch[0]->size + x->ch[1]->size + 1;
        x->sums = x->ch[0]->sums + x->ch[1]->sums + x->value;
        x->maxl = max(x->ch[0]->maxl,x->ch[0]->sums+x->value);
        x->maxl = max(x->maxl,x->ch[0]->sums+x->value+x->ch[1]->maxl);
        x->maxl = max(x->maxl,x->ch[0]->sums+x->value+x->ch[1]->sums);
        x->maxr = max(x->ch[1]->maxr,x->ch[1]->sums+x->value);
        x->maxr = max(x->maxr,x->ch[1]->sums+x->value+x->ch[0]->maxr);
        x->maxr = max(x->maxr,x->ch[1]->sums+x->value+x->ch[0]->sums);
        x->maxs = max(x->value, x->ch[0]->maxs);
        x->maxs = max(x->maxs, x->ch[1]->maxs);
        x->maxs = max(x->maxs, x->ch[0]->maxr+x->value);
        x->maxs = max(x->maxs, x->ch[1]->maxl+x->value);
        x->maxs = max(x->maxs, x->ch[0]->maxr + x->value + x->ch[1]->maxl);
        return 0;
}
int rotateto(node *x,int to){
        node *xp=x->pre;
        //
        //pushdown(xp); pushdown(x);
        xp->ch[to^1] = x->ch[to];
        xp->ch[to^1]->pre = xp;
        x->pre = xp->pre;
        if(xp->pre->ch[0] == xp) xp->pre->ch[0]=x;
        else xp->pre->ch[1]=x;
        xp->pre=x; x->ch[to]=xp;
        update(xp);//update(x) is not needed
        if(xp == root) root=x;
        return 0;
    }
    int splay(node *x,node *fa){
        pushdown(x);//this is must needed,note : cover && reverse
        while(x->pre!=fa){
            if(x->pre->pre == fa){
                if(x->pre->ch[0] == x) rotateto(x,1);
                else rotateto(x,0);
            }else{
                if(x->pre->pre->ch[0]==x->pre){
                    if(x->pre->ch[0] == x) {rotateto(x->pre,1);rotateto(x,1);}
                    else {rotateto(x,0);rotateto(x,1);}
                }else{
                    if(x->pre->ch[1] == x) {rotateto(x->pre,0);rotateto(x,0);}
                    else {rotateto(x,1);rotateto(x,0);}
                }
            }
        }
        update(x);
        return 0;
}

其中pushdown和update操作的功能是明确区分开的：

  1. pushdown负责将当前节点的标记落实，并传递给孩子节点，最后清除自己的标记信息。
  2. update负责根据左右孩子节点（一定是从左右孩子处获取最新信息，因为旋转过程会使得左右孩子发生变化）更新自己。

这里就是splay的核心操作，旋转操作将x节点不断旋转到祖先fa下面，
注意到：

  1. 每次旋转都会将X提高一层，x的父节点xp随之下降一层
  2. 每次提升x，必须update(xp)，因为其左右孩子发生了变化。
  3. update(x)可以在所有rotateto之后执行
  4. splay方法结束时，无需update(fa)
  5. 每次select操作都会从root到x的路径上执行pushdown，所以select内部的splay、rotateto操作中pushdown可以节省掉
  6. 同时splay则对应了一条upadate路径，select的最后调用了splay()，这意味着select结束时，从root出发的某一条路径是没有lazy
    tag的。
  7. 这意味着，当我们select之后，再次访问（只读取，不修改）这条路径上的某个节点时，无需再次进行pushdown。
  8. 但是，对于7，如果我们不仅访问，并且修改了这条路径上的某个节点，此时splay该节点，则必须进行pushdown。

其余的操作，插入，更新，删除，等：

int insert(int pos,int tot){
        node *p,*q;
        int s;
        scanf("%d",&s);
        p=q=getnode(s,nill);
        for(int i=1;i<tot;i++){
            scanf("%d",&s);
            p=p->ch[1]=getnode(s,p);
        }
        select(pos+1,nill);
        select(pos+2,root);
        root->ch[1]->ch[0]=q;
        q->pre=root->ch[1];
        splay(p,nill);
        return 0;
    }
    int insert(int pos,int tot,int *s){
        node *p,*q;
        p=q=getnode(s[0],nill);
        for(int i=1;i<tot;i++){
            p=p->ch[1]=getnode(s[i],p);
        }
        select(pos+1,nill);
        select(pos+2,root);
        root->ch[1]->ch[0]=q;
        q->pre=root->ch[1];
        splay(p,nill);
        return 0;
    }
    int remove(int pos,int tot){
        select(pos,nill);
        select(pos+tot+1,root);
        if(root->ch[1]->ch[0]!=nill) stk[stksize++]=root->ch[1]->ch[0];
        root->ch[1]->ch[0]=nill;
        splay(root->ch[1],nill);
        return 0;
    }
    int reverse(int pos,int tot){
        select(pos,nill);
        select(pos+tot+1,root);
        root->ch[1]->ch[0]->rev=!root->ch[1]->ch[0]->rev;
        pushdown(root->ch[1]->ch[0]);
        //need pushdown first
        splay(root->ch[1]->ch[0],nill);
        return 0;
    }
    int cover(int pos,int tot,int c){
        select(pos,nill);
        select(pos+tot+1,root);
        root->ch[1]->ch[0]->cover=true;
        root->ch[1]->ch[0]->value=c;
        pushdown(root->ch[1]->ch[0]);
        //need pushdown first
        splay(root->ch[1]->ch[0],nill);

        return 0;
    }
    int getsums(int pos,int tot){
        select(pos,nill);
        select(pos+tot+1,root);
        //pushdown(root->ch[1]->ch[0]);
        //update(root->ch[1]->ch[0]);
        return root->ch[1]->ch[0]->sums;
    }
    int maxsum(){
        //select(1,nill);
        //select(root->size,root);
        pushdown(root);
        update(root);
        return root->maxs;
    }
区间操作的前提都是一样的，首先通过旋转操作，
将目标区间转移到root->ch[1]->ch[0]位置。

插入操作很简单，先建立一条链，挂到root->ch[1]->ch[0]位置，
然后将链末尾节点splay到root。
注意到：

  1. 提取区间的两次select操作保证了root->ch[1]->ch[0]这条链是update过的，因此splay之前不需要pushdown操作
  2. 同时，新建立的链没有标记信息，也不需要pushdown操作
  3. 这样，只需要对链末尾节点执行一次splay(x,root)，就会在链末节点不断上升的过程中，一次更新整条链的所有节点（包括了root和root->ch[0])
  4. 这里3代表了前面的第7点，即对于select方法之外的splay调用而言，其内部的pushdown仍然是可以节省的
  5. 对于cover和reverse操作，因为select提取区间之后，执行了修改操作，splay时必须先pushdown，对应前面第8点。

到这里全部说完了这道题目的关键点。
可以看出，select，insert，splay，rotateto基本是通用的模板，关键在于update和pushdown操作的设计要根据具体的题目。

全部代码：

#define __LOCAL__DEBUG__

#include <cstdlib>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <list>
#include <stdexcept>
#include <functional>
#include <utility>
#include <ctime>
using namespace std;

#define PB push_back
#define MP make_pair

#define REP(i,n) for(i=0;i<(n);++i)
#define FOR(i,l,h) for(i=(l);i<=(h);++i)
#define FORD(i,h,l) for(i=(h);i>=(l);--i)

#define LEFT    0
#define RIGHT   1
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<double> VD;
typedef long long LL64;
typedef unsigned long long LL65;
typedef pair<int,int> PII;
#define MAXN 510000
#define INF 1001

typedef struct splaytree{
    typedef struct node{
        struct node *pre,*ch[2];
        int size,value,sums,maxs,maxl,maxr;
        bool rev,cover;
    }node;
    node *root,*nill,buf[MAXN],*stk[MAXN];
    int bufsize,stksize;
    node *getnode(int value,node *fa){
        node *p=NULL;
        if(bufsize<MAXN){
            p=&buf[bufsize++];
        }else if(stksize>0){
            p=stk[--stksize];
            if(p->ch[0]!=nill) stk[stksize++]=p->ch[0];
            if(p->ch[1]!=nill) stk[stksize++]=p->ch[1];
        }else {
            p=(node*)malloc(sizeof(node));
        } p->size=1;
        p->value=p->sums=p->maxs=p->maxl=p->maxr=value;
        p->rev=p->cover=false; p->pre=fa; p->ch[0]=p->ch[1]=nill;
        return p;
    }
    int pushdown(node *x){
        if(x==nill || x==NULL) return 0;
        if(x->rev){
            x->rev=false;
            x->ch[0]->rev = !x->ch[0]->rev;
            x->ch[1]->rev = !x->ch[1]->rev;
            node *tmp=x->ch[0]; x->ch[0]=x->ch[1]; x->ch[1]=tmp;
            int t=x->maxl; x->maxl=x->maxr; x->maxr=t;
        }
        if(x->cover){
            x->cover=false;
            x->ch[0]->cover= x->ch[1]->cover=true;
            x->ch[0]->value= x->ch[1]->value=x->value;
            x->maxl=x->maxr=x->maxs=x->sums=x->value*x->size;
            if(x->value<0) x->maxl=x->maxr=x->maxs=x->value;
        }
        return 0;
    }
    int update(node *x){
        if(x==nill || x==NULL) return 0;
        pushdown(x->ch[0]); pushdown(x->ch[1]); //must pushdown when you visited it
        x->size = x->ch[0]->size + x->ch[1]->size + 1;
        x->sums = x->ch[0]->sums + x->ch[1]->sums + x->value;
        x->maxl = max(x->ch[0]->maxl,x->ch[0]->sums+x->value);
        x->maxl = max(x->maxl,x->ch[0]->sums+x->value+x->ch[1]->maxl);
        x->maxl = max(x->maxl,x->ch[0]->sums+x->value+x->ch[1]->sums);
        x->maxr = max(x->ch[1]->maxr,x->ch[1]->sums+x->value);
        x->maxr = max(x->maxr,x->ch[1]->sums+x->value+x->ch[0]->maxr);
        x->maxr = max(x->maxr,x->ch[1]->sums+x->value+x->ch[0]->sums);
        x->maxs = max(x->value, x->ch[0]->maxs);
        x->maxs = max(x->maxs, x->ch[1]->maxs);
        x->maxs = max(x->maxs, x->ch[0]->maxr+x->value);
        x->maxs = max(x->maxs, x->ch[1]->maxl+x->value);
        x->maxs = max(x->maxs, x->ch[0]->maxr + x->value + x->ch[1]->maxl);
        return 0;
    }
    int init(){
        bufsize=stksize=0;
        nill=getnode(-INF,NULL);
        nill->ch[0]=nill->ch[1]=nill->pre=NULL;
        nill->size=nill->sums=0;
        root=getnode(-INF,nill);
        root->ch[1]=getnode(-INF,root);
        update(root);
        return 0;
    }
    int rotateto(node *x,int to){
        node *xp=x->pre;
        //this is not must needed : because
        //pushdown(xp); pushdown(x);
        xp->ch[to^1] = x->ch[to];
        xp->ch[to^1]->pre = xp;
        x->pre = xp->pre;
        if(xp->pre->ch[0] == xp) xp->pre->ch[0]=x;
        else xp->pre->ch[1]=x;
        xp->pre=x; x->ch[to]=xp;
        update(xp);
        if(xp == root) root=x;
        return 0;
    }
    int splay(node *x,node *fa){
        pushdown(x);//is this must needed ?
        while(x->pre!=fa){
            if(x->pre->pre == fa){
                if(x->pre->ch[0] == x) rotateto(x,1);
                else rotateto(x,0);
            }else{
                if(x->pre->pre->ch[0]==x->pre){
                    if(x->pre->ch[0] == x) {rotateto(x->pre,1);rotateto(x,1);}
                    else {rotateto(x,0);rotateto(x,1);}
                }else{
                    if(x->pre->ch[1] == x) {rotateto(x->pre,0);rotateto(x,0);}
                    else {rotateto(x,1);rotateto(x,0);}
                }
            }
        }
        update(x);//update(x->pre) is not needed
        return 0;
    }
    int select(int pos,node *fa){
        node *rt=root;
        while(rt!=nill){
            pushdown(rt);
            if(rt->ch[0]->size+1 == pos) break;
            else if(rt->ch[0]->size >= pos) rt=rt->ch[0];
            else {pos-=rt->ch[0]->size+1; rt=rt->ch[1];}
        }
        splay(rt,fa);
        return 0;
    }
    int insert(int pos,int tot){
        node *p,*q;
        int s;
        scanf("%d",&s);
        p=q=getnode(s,nill);
        for(int i=1;i<tot;i++){
            scanf("%d",&s);
            p=p->ch[1]=getnode(s,p);
        }
        select(pos+1,nill);
        select(pos+2,root);
        root->ch[1]->ch[0]=q;
        q->pre=root->ch[1];
        splay(p,nill);
        return 0;
    }
    int insert(int pos,int tot,int *s){
        node *p,*q;
        p=q=getnode(s[0],nill);
        for(int i=1;i<tot;i++){
            p=p->ch[1]=getnode(s[i],p);
        }
        select(pos+1,nill);
        select(pos+2,root);
        root->ch[1]->ch[0]=q;
        q->pre=root->ch[1];
        splay(p,nill);
        return 0;
    }
    int remove(int pos,int tot){
        select(pos,nill);
        select(pos+tot+1,root);
        if(root->ch[1]->ch[0]!=nill) stk[stksize++]=root->ch[1]->ch[0];
        root->ch[1]->ch[0]=nill;
        splay(root->ch[1],nill);
        return 0;
    }
    int reverse(int pos,int tot){
        select(pos,nill);
        select(pos+tot+1,root);
        root->ch[1]->ch[0]->rev=!root->ch[1]->ch[0]->rev;
        splay(root->ch[1]->ch[0],nill);
        return 0;
    }
    int cover(int pos,int tot,int c){
        select(pos,nill);
        select(pos+tot+1,root);
        root->ch[1]->ch[0]->cover=true;
        root->ch[1]->ch[0]->value=c;
        splay(root->ch[1]->ch[0],nill);
        return 0;
    }
    int getsums(int pos,int tot){
        select(pos,nill);
        select(pos+tot+1,root);
        //pushdown(root->ch[1]->ch[0]);
        //update(root->ch[1]->ch[0]);
        return root->ch[1]->ch[0]->sums;
    }
    int maxsum(){
        //select(1,nill);
        //select(root->size,root);
        pushdown(root);
        update(root);
        return root->maxs;
    }
}splaytree;

int main(){
#ifndef __LOCAL__DEBUG__
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
#else
    freopen("sequence3.in","r",stdin);
    freopen("out.txt","w",stdout);
#endif
    int i,n,m,c;
    int pos,tot;
    splaytree *stree=new splaytree;
    stree->init();
    char s[30];

    scanf("%d%d",&n,&m);
    stree->insert(0,n);
    for(i=0;i<m;i++){
        scanf("%s",s);
        if(s[0]=='I'){
            scanf("%d%d",&pos,&tot);
            stree->insert(pos,tot);
        }else if(s[0]=='D'){
            scanf("%d%d",&pos,&tot);
            stree->remove(pos,tot);
        }else if(s[0]=='R'){
            scanf("%d%d",&pos,&tot);
            stree->reverse(pos,tot);
        }else if(s[0]=='G'){
            scanf("%d%d",&pos,&tot);
            printf("%d\n",stree->getsums(pos,tot));
        }else if(s[2]=='K'){
            scanf("%d%d%d",&pos,&tot,&c);
            stree->cover(pos,tot,c);
        }else {
            printf("%d\n",stree->maxsum());
        }
    }
    delete stree;
    return 0;
}

[1]：http://www.lydsy.com/JudgeOnline/problem.php?id=1500

扫码关注作者，定期分享技术、算法类文章
这里写图片描述

榴莲泡芙2018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
伸展树Splay Tree
peanWang的博客
08-28 385
伸展树 伸展树是自平衡的二叉查找树，伸展树不像AVL树，要时刻保持平衡。伸展树通过分摊保持查找的高效率。 伸展树的基本思想：当一个节点被访问后，它就要进过一系列AVL树旋转被放在根上。 数据局部性 可视化伸展树 http://www.link.cs.cmu.edu/splay/ 这个网站是伸展树的创始人做到一个project。将伸展树可视化。学伸展树的时候可以看看。...
Splay Tree(伸展树)
09-25 2万+
二叉查找树（BinarySearchTree）能够支持多种动态集合操作。因此，在信息学竞赛中，二叉排序树起着非常重要的作用，它可以被用来表示有序集合、建立索引或优先队列等。 作用于二叉查找树上的基本操作的时间是与树的高度成正比的。对一个含n各节点的完全二叉树，这些操作的最坏情况运行时间为O(logn)。但如果树是含n个节点的线性链，则这些操作的最坏情况运行时间为O(n)。而有些二叉查找树的
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
splaytree.zip
04-23
展树（Splay Tree）是一种二叉搜索树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
splay-tree：快速的splay-tree数据结构
02-05
快速八叉树 ：（非递归）和简单（<1000行代码）实现是直接从Wikipedia改编而成的，使用与相同的API来针对其他树运行基准测试。 该树基于D.Sleator自上而下的展开...S splaytree import SplayTree from 'splaytree'
erl-splay-tree：Erlang中的splay-tree实现
02-05
**Erlang中的Splay Tree实现** Erlang是一种功能强大的并发编程语言，以其轻量级进程、消息传递和容错能力而闻名。在Erlang中实现数据结构可以帮助优化性能，特别是在处理大量数据时。Splay Tree是一种自调整的二叉...
SplayTree详细解释
09-24
### SplayTree（伸展树）详细解释 #### 基本概念 SplayTree，又称伸展树，是一种自调整的二叉搜索树。它虽然不像其他平衡二叉搜索树那样严格限制树的形状，但通过一种叫做伸展的操作，在访问节点后将其提升到根节点...
伸展树(splay tree)
weixin_30611509的博客
10-16 550
对于二叉查找树而言，每次操作的最坏时间复杂度是O(N)。（当树退化为链表的时候）。为了解决这个问题，我们给树附加了一个平衡条件。平衡条件限制了任何节点的深度都不能过深。其中一种限制条件是：一颗二叉查找树的左子树和右子树的高度差不能超过1，这个条件限制产生了AVL树。 二叉查找树的最坏操作是O(N)。但是这样的操作并不常见。所以累加起来的时间就变得比单次操作时间的...
SPLAY树
TL的博客
01-30 826
前言 根据研究表明，90%的访问都是针对10%的元素。提高这90%的访问的效率，就明显改善了对整个访问的效率。 核心思想：把最近访问过的结点提升到根，后续访问的深度将减小。把这种提升结点的操作称为“伸展Splay”。以伸展操作为基础的二叉排序树也就相应称为伸展树（Splay Tree）。 开始 基于前言中十分有用（坑爹 ）的话，于是我们需要用SPLAY树来优化时间，即把刚操作的点引到根下，即S...
Splay tree
花落知多少
06-25 283
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 ...
查找——图文翔解SplayTree（伸展树）
菜鸟的自留地-mooyang
05-27 8505
伸展树 伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它由Daniel Sleator和Robert Tarjan创造，后者对其进行了改进。 假设想要对一个二叉查找树执行一系列的查找操作。为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法，在每次查找之后对树进行重构，把被查找的条目搬移到离树根近一些的地方。splaytre
伸展树(Splay Tree)
Bruce
04-12 1539
伸展树(Splay Tree)，又称分裂树,是一种在AVL树基础上进一步放松平衡条件的二叉排序树,它能够在O(log n)时间复杂度内完成插入、查找和删除操作。伸展树上的一般操作都是基于伸展操作的，还可以说伸展树是一种自调整形式的二叉查找树，他会沿着从某个节点到树根之间的路径，将当前访问的节点通过一系列的旋转操作迁移到树根。很重要的一点是：伸展树不需要维护平衡因子。它由丹尼尔·斯立特Daniel S
016.Splay Tree
dosdiosas_的博客
04-19 232
下面介绍一种二叉平衡搜索树 Splay树       伸展树（英语：Splay Tree）是一种能够自我平衡的二叉查找树，它能在均摊O(logn)的时间内完成基于伸展（Splay）操作的插入、查找、修改和删除操作。它是由丹尼尔·斯立特（Daniel Sleator）和罗伯特·塔扬在1985年发明的。    ...
【数据结构】详细解读 Splay Tree（附完整代码）
qq_25426559的博客
01-27 2718
本鱼干最近在家忙着玩，大脑许久不怎么用。昨日闲来无事，遂翻看书籍。正巧《机器学习》决策树这一块不是太熟悉。本打算品茶而观之，但发现有一树名Treap，觉得挺好玩，遂实现了一下，做了几个相关题目（用的STL中的map...因为懒），又深入发现了一种名为Splay的树，更加好玩，可苦于没有办法用STL里的东西代替它，遂于今日下午深入了解，并写成博客~~水经验~~ 分享之。
Splay Tree详解：图解与实践
Splay Tree通过三种基本操作：旋转（rotate）、zig-zig和zig-zag来维护其特性。当进行查找操作时，首先找到目标节点，然后根据查找路径对树进行一系列调整，使目标节点上移到根节点附近。插入和删除操作后也会类似...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值