Splay树小结

最新推荐文章于 2025-07-17 21:49:03 发布
最新推荐文章于 2025-07-17 21:49:03 发布
阅读量387 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Splay树 *******数据结构******* 文章标签： Splay树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u014610830/article/details/47863249

http://blog.youkuaiyun.com/acm_cxlove/article/details/7815019 附上cxlove大神的博客链接，最近是跟着上面的题目做的。

刚学的时候感觉好难，显示照着大白皮上面敲的模板，然后网上各种看论文，感觉指针写还是太繁琐，还是直接数组写的精炼。感觉Splay树确实强大，可以解决好多序列问题。感觉Splay树的核心是Key_Tree = ch[ch[root][1]][0]这个东西的使用，因为这棵子树就代表了你当前要修改，或者查询的区间，当然单点修改也可以这样做。

Splay树的核心操作有两个：一个是Splay操作（把当前点转到根节点的操作），一个是把第k个点转到根（其实不一定是根）。

下面附上这两种操作的模板：

kind == 0 表示左旋，kind == 1表示右旋
    void Rotate(int x,int kind){
        int y = pre[x];
        Push_Down(y);
        Push_Down(x);
        ch[y][!kind] = ch[x][kind];
        pre[ch[x][kind]] = y;
        if(pre[y]){
            ch[pre[y]][ch[pre[y]][1] == y] = x;
        }
        pre[x] = pre[y];
        ch[x][kind] = y;
        pre[y] = x;
        Push_Up(y);
    }
    //把x节点旋转到goal下面
    void Splay(int x,int goal){
        Push_Down(x);
        while(pre[x] != goal){
            Push_Down(pre[pre[x]]); Push_Down(pre[x]);  Push_Down(x);
            if(pre[pre[x]] == goal){
                Rotate(x,ch[pre[x]][0] == x);
            }
            else{
                int y = pre[x];
                int kind = (ch[pre[y]][0] == y);
                if(ch[y][kind] == x){
                    Rotate(x,!kind);
                    Rotate(x,kind);
                }
                else{
                    Rotate(y,kind);
                    Rotate(x,kind);
                }
            }
        }
        Push_Up(x);
        if(!goal)   root = x;
    }
    ///把第k个节点转到goal下面
    void RotateTo(int k,int goal){
        int x = root;
        Push_Down(x);
        while(sz[ch[x][0]] != k){
            if(k < sz[ch[x][0]]){
                x = ch[x][0];
            }
            else{
                k -= (sz[ch[x][0]]+1);
                x = ch[x][1];
            }
            Push_Down(x);
        }
        Splay(x,goal);
    }
上面的模板入门不能好好理解得话，画几张图就会了。

区间操作的时候，查询或者修改[l,r]这段区间，那么我们把RotateTo(l-1,0),RotateTo(r+1,root)那么，此时Key_Tree的子树就代表这段要查询或者修改的区间。这个是伸展树里面区间操作的核心的核心！！！

然后区间操作还有一个关键的地方就是：Push_Up,Push_Down操作，和线段树很像。还有就是初始化了，一般我都是在序列头，序列尾多加一个节点，这样就能保证不会越界了，还有就是初始化的时候最好把0这种节点的值附为一个不会影响答案的值。

下面附上几道题目（可以跟着练手）：

HYSBZ 1588 营业额统计：

营业额统计

HDU 3436 Queue_jumpers

这题主要要把一个区间缩成一个点。写起来可能稍微麻烦一点

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <map>
#define LL long long
#define FOR(i,x,y)  for(int i = x;i < y;i ++)
#define IFOR(i,x,y) for(int i = x;i > y;i --)
#define Key_Tree ch[ch[root][1]][0]
#define MAXN 110000

using namespace std;

int n,m;
int TQ[MAXN],cnt_TQ;
int N,ssz[MAXN],l[MAXN];
map <int,int> mat;

struct Commends{
    char str[10];
    int num;
}cmd[MAXN];

struct SplayTree{
    int ch[MAXN][2],sz[MAXN],pre[MAXN],key[MAXN],root,tot,sum[MAXN],val[MAXN],pos[MAXN];
    int flip[MAXN];

    void Rotate(int x,int kind){
        int y = pre[x];
        Push_Down(y);
        Push_Down(x);
        ch[y][!kind] = ch[x][kind];
        pre[ch[x][kind]] = y;
        if(pre[y]){
            ch[pre[y]][ch[pre[y]][1] == y] = x;
        }
        pre[x] = pre[y];
        ch[x][kind] = y;
        pre[y] = x;
        Push_Up(y);
    }

    void Splay(int x,int goal){
        Push_Down(x);
        while(pre[x] != goal){
            Push_Down(pre[pre[x]]); Push_Down(pre[x]);  Push_Down(x);
            if(pre[pre[x]] == goal){
                Rotate(x,ch[pre[x]][0] == x);
            }
            else{
                int y = pre[x];
                int kind = (ch[pre[y]][0] == y);
                if(ch[y][kind] == x){
                    Rotate(x,!kind);
                    Rotate(x,kind);
                }
                else{
                    Rotate(y,kind);
                    Rotate(x,kind);
                }
            }
        }
        Push_Up(x);
        if(!goal)   root = x;
    }

    void RotateTo(int k,int goal){
        int x = root;
        Push_Down(x);
        while(sz[ch[x][0]] != k){
            if(k < sz[ch[x][0]]){
                x = ch[x][0];
            }
            else{
                k -= (sz[ch[x][0]]+1);
                x = ch[x][1];
            }
            Push_Down(x);
        }
        Splay(x,goal);
    }


    //debug部分copy from hh
    void Treaval(int x) {
        if(x) {
            Treaval(ch[x][0]);
            printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d ,key = %2d,sum = %2d,val = %2d \n",x,ch[x][0],ch[x][1],pre[x],sz[x],key[x],sum[x],val[x]);
            Treaval(ch[x][1]);
        }
    }
    void debug() {printf("%d\n",root);Treaval(root);}
    //以上debug

    void NewNode(int& x,int father,int k,int v){
        x = ++tot;
        pre[x] = father;
        key[x] = k;
        val[x] = v;
        ch[x][0] = ch[x][1] = 0;
        sz[x] = 1;
        flip[x] = 0;
    }

    void Push_Up(int x){
        sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + 1;
        sum[x] = sum[ch[x][0]]+ sum[ch[x][1]] + val[x];
    }

    void Push_Down(int x){
        if(flip[x]){
            flip[ch[x][0]] ^= 1;
            flip[ch[x][1]] ^= 1;
            flip[x] = 0;
            swap(ch[x][1],ch[x][0]);
        }
    }

    void Build(int& x,int l,int r,int father){
        if(l > r)   return;
        int mid = (l+r) >> 1;
        NewNode(x,father,mid,ssz[mid]);
        pos[mid] = x;
        Build(ch[x][0],l,mid-1,x);
        Build(ch[x][1],mid+1,r,x);
        Push_Up(x);
    }

    void Init(){
        root = tot = 0;
        ch[0][1] = ch[0][0] = pre[0] = sz[0] = 0;
        NewNode(root,0,0,1);
        NewNode(ch[root][1],root,0,1);
        sz[root] = 2;
        Build(Key_Tree,1,N,ch[root][1]);
        Push_Up(ch[root][1]);
        Push_Up(root);
    }

    void UpDate(int x){
        ch[x][1] = ch[x][0] = 0;
        sz[x] = 1;
        sum[x] = val[x];
    }

    void Top(int x){
        RotateTo(0,0);
        Splay(x,root);
        int a = Get_Pre(x);
        if(a == -1) return;
        Splay(a,x);
        pre[Key_Tree] = root;
        pre[ch[ch[root][1]][1]] = Key_Tree;
        ch[Key_Tree][1] = ch[ch[root][1]][1];
        ch[root][1] = Key_Tree;
        Push_Up(ch[root][1]);
        Push_Up(root);
        UpDate(x);
        RotateTo(1,root);
        pre[x] = ch[root][1];
        Key_Tree = x;
        Push_Up(ch[root][1]);
        Push_Up(root);
    }

    int Query(int x){
        //debug();
        Splay(x,root);
        return sum[Key_Tree]+1;
    }

    int Rank(int x,int k){
        if(k >= sum[ch[x][0]] && k < sum[ch[x][0]] + val[x])
            return (l[key[x]] + k - (sum[ch[x][0]]));
        if(k < sum[ch[x][0]])
            return Rank(ch[x][0],k);
        return Rank(ch[x][1],k - (sum[ch[x][0]] + val[x]));
    }

    void solve(){
        //debug();
        FOR(i,0,m){
            if(cmd[i].str[0] == 'T')    {Top(pos[mat[cmd[i].num]]);}
            else if(cmd[i].str[0] == 'Q')   {printf("%d\n",Query(pos[mat[cmd[i].num]]));}
            else {printf("%d\n",Rank(root,cmd[i].num));}
        }
    }

    int Get_Pre(int x){
        Push_Down(x);
        x = ch[x][0];
        while(x){
            Push_Down(x);
            while(ch[x][1]){
                x = ch[x][1];
                Push_Down(x);
            }
            return x;
        }
        return -1;
    }

    int Get_Next(int x){
        Push_Down(x);
        x = ch[x][1];
        while(x){
            Push_Down(x);
            while(ch[x][0]){
                x = ch[x][0];
                Push_Down(x);
            }
            return x;
        }
        return -1;
    }
}spt;

void Read(){
    cnt_TQ = 0;
    FOR(i,0,m){
        scanf("%s%d",cmd[i].str,&cmd[i].num);
        if(cmd[i].str[0] != 'R'){
            TQ[cnt_TQ ++] = cmd[i].num;
        }
    }
    sort(TQ,TQ+cnt_TQ);
    N = 0;
    if(TQ[0] == 1){
        mat[1] = 1;
        ssz[++N] = 1;
        l[N] = 1;
    }
    else{
        ssz[++N] = TQ[0]-1;
        l[N] = 1;
        mat[TQ[0]] = ++N;
        ssz[N] = 1;
        l[N] = TQ[0];
    }
    FOR(i,1,cnt_TQ){
        if(TQ[i] == TQ[i-1])    continue;
        if(TQ[i] == TQ[i-1] + 1){
            mat[TQ[i]] = ++N;
            ssz[N] = 1;
            l[N] = TQ[i];
        }
        else{
            ssz[++N] = TQ[i] - TQ[i-1]-1;
            l[N] = TQ[i-1] + 1;
            mat[TQ[i]] = ++N;
            ssz[N] = 1;
            l[N] = TQ[i];
        }
    }
    if(TQ[cnt_TQ-1] != n){
        ssz[++N] = n - TQ[cnt_TQ-1];
        l[N] = TQ[cnt_TQ-1] + 1;
    }
}

int main()
{
    //freopen("test.in","r",stdin);
    int T,tCase = 0;
    scanf("%d",&T);
    while(T--){
        printf("Case %d:\n",++tCase);
        scanf("%d%d",&n,&m);
        Read();
        spt.Init();
        spt.solve();
    }
    return 0;
}
HDU 1890 Robotic Sort

Robotic Sort

HDU 3487 Play With Chain

没什么难的地方：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#define LL long long
#define FOR(i,x,y)  for(int i = x;i < y;i ++)
#define IFOR(i,x,y) for(int i = x;i > y;i --)
#define Key_Tree ch[ch[root][1]][0]
#define MAXN 330000

using namespace std;

int n,m,num[MAXN],cnt;
char cmd[10];

struct SplayTree{
    int ans[MAXN];
    int ch[MAXN][2],sz[MAXN],pre[MAXN],key[MAXN],root,tot;
    int flip[MAXN];

    void Rotate(int x,int kind){
        int y = pre[x];
        Push_Down(y);
        Push_Down(x);
        ch[y][!kind] = ch[x][kind];
        pre[ch[x][kind]] = y;
        if(pre[y]){
            ch[pre[y]][ch[pre[y]][1] == y] = x;
        }
        pre[x] = pre[y];
        ch[x][kind] = y;
        pre[y] = x;
        Push_Up(y);
    }

    void Splay(int x,int goal){
        Push_Down(x);
        while(pre[x] != goal){
            Push_Down(pre[pre[x]]); Push_Down(pre[x]);  Push_Down(x);
            if(pre[pre[x]] == goal){
                Rotate(x,ch[pre[x]][0] == x);
            }
            else{
                int y = pre[x];
                int kind = (ch[pre[y]][0] == y);
                if(ch[y][kind] == x){
                    Rotate(x,!kind);
                    Rotate(x,kind);
                }
                else{
                    Rotate(y,kind);
                    Rotate(x,kind);
                }
            }
        }
        Push_Up(x);
        if(!goal)   root = x;
    }

    void RotateTo(int k,int goal){
        int x = root;
        Push_Down(x);
        while(sz[ch[x][0]] != k){
            if(k < sz[ch[x][0]]){
                x = ch[x][0];
            }
            else{
                k -= (sz[ch[x][0]]+1);
                x = ch[x][1];
            }
            Push_Down(x);
        }
        Splay(x,goal);
    }


    //debug部分copy from hh
    void Treaval(int x) {
        if(x) {
            Treaval(ch[x][0]);
            printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d ,val = %2d \n",x,ch[x][0],ch[x][1],pre[x],sz[x],key[x]);
            Treaval(ch[x][1]);
        }
    }
    void Debug() {printf("%d\n",root);Treaval(root);}
    //以上debug


    void Build(int& x,int l,int r,int father){
        if(l > r)   return;
        int mid = (l+r) >> 1;
        NewNode(x,father,num[mid]);
        Build(ch[x][0],l,mid-1,x);
        Build(ch[x][1],mid+1,r,x);
        Push_Up(x);
    }

    void Init(){
        root = tot = 0;
        ch[0][1] = ch[0][0] = pre[0] = sz[0] = 0;
        NewNode(root,0,0);
        NewNode(ch[root][1],root,0);
        sz[root] = 2;
        Build(Key_Tree,0,n-1,ch[root][1]);
        Push_Up(ch[root][1]);
        Push_Up(root);
    }


    int Get_Pre(int x){
        Push_Down(x);
        x = ch[x][0];
        while(x){
            Push_Down(x);
            while(ch[x][1]){
                x = ch[x][1];
                Push_Down(x);
            }
            return x;
        }
        return -1;
    }

    int Get_Next(int x){
        Push_Down(x);
        x = ch[x][1];
        while(x){
            Push_Down(x);
            while(ch[x][0]){
                x = ch[x][0];
                Push_Down(x);
            }
            return x;
        }
        return -1;
    }

    void NewNode(int& x,int father,int k){
        x = ++tot;
        pre[x] = father;
        key[x] = k;
        ch[x][0] = ch[x][1] = 0;
        sz[x] = 1;
        flip[x] = 0;
    }

    void Push_Up(int x){
        sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + 1;
    }

    void Push_Down(int x){
        if(flip[x]){
            flip[ch[x][0]] ^= 1;
            flip[ch[x][1]] ^= 1;
            flip[x] = 0;
            swap(ch[x][1],ch[x][0]);
        }
    }

    void Flip(int l,int r){
        RotateTo(l-1,0);
        RotateTo(r+1,root);
        flip[Key_Tree] ^= 1;
    }

    void Cut(int l,int r,int k){
        RotateTo(l-1,0);
        RotateTo(r+1,root);
        int p = Key_Tree;
        ch[ch[root][1]][0] = 0;
        sz[ch[root][1]] = sz[ch[ch[root][1]][1]] + 1;
        Push_Up(root);
        //Debug();
        RotateTo(k,0);
        RotateTo(k+1,root);
        pre[p] = ch[root][1];
        ch[ch[root][1]][0] = p;
        Push_Up(ch[root][1]);
        Push_Up(root);
    }

    void Print(int x){
        Push_Down(x);
        if(ch[x][0])    {Print(ch[x][0]);}
        if(cnt == 0 && key[x] != 0)  {printf("%d",key[x]);cnt++;}
        else if(key[x] != 0)
            {printf(" %d",key[x]);cnt++;}
        if(ch[x][1])    {Print(ch[x][1]);}
    }

}spt;

int main()
{
    //freopen("test.in","r",stdin);
    while(~scanf("%d%d",&n,&m) && (n >= 0 || m >= 0)){
        FOR(i,0,n)  num[i] = i+1;
        spt.Init();
        //spt.Debug();
        FOR(i,0,m){
            scanf("%s",cmd);
            int l,r,k;
            if(cmd[0] == 'C'){
                scanf("%d%d%d",&l,&r,&k);
                spt.Cut(l,r,k);
                //spt.Debug();
            }
            else{
                scanf("%d%d",&l,&r);
                spt.Flip(l,r);
            }
        }
        cnt = 0;
        spt.Print(spt.root);
        printf("\n");
    }
    return 0;
}
POJ 3580 SuperMemo

SuperMemo

NOI 2005 维修数列

非常BT的一题

维修数列

Splay树(伸展树)
不忘初心
07-23 1212
伸展树（Splay Tree），是一种二叉平衡搜索树，时间复杂度均摊为O(logN)，即splay树做m次操作的复杂度为O(mlogN)。 在伸展树上的一般操作都基于伸展操作/提根操作： 假设想要对一个二叉搜索树执行一系列的查找操作，为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法， 在每次查找之后对树进行重构，把被查找的条目搬移到离树根近
Treap和Splay学习小结
Occult
02-25 4617
最近真的是花了很大的力气来学习平衡树的内容，因为之前在弄偏序的时候提到了平衡树的内容，真的是开了一个大坑啊。 先说说treap吧，网上的资料很多，描述的也很详细，我就不细说了，这里简单的谈谈我的看法，treap就是在二叉树的基础上加了一个随机域来保证堆的性质 这样可以把树的高度维护到期望的logn级别，其他的就是一棵二叉排序树，并没有什么特别的。 我实现了指针版和数组版两种，但是说实话，在写
纸上谈兵: 伸展树 (splay tree)
weixin_33847182的博客
03-24 150
作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！    我们讨论过，树的搜索效率与树的深度有关。二叉搜索树的深度可能为n，这种情况下，每次搜索的复杂度为n的量级。AVL树通过动态平衡树的深度，单次搜索的复杂度为log(n) (以上参考纸上谈兵 AVL树)。我们下面看伸展树(splay tree)，它对于m次连续搜索操作有很好的...
【学习笔记】数据结构
最新发布
xujiabin194的博客
07-17 953
本人总结的数据结构笔记，不定期更新
Splay树
and1403的博客
03-30 283
对于被AVL虐得像那啥一样的我们，Splay的到来是无疑是拯（huo）救（shang）人（jiao）民（you）。 Splay树，又称伸展树，事实上，它根本就不是平衡树！然而它的平均时间复杂度确是O(log n)。 唯一和AVL树一样的是：转转转，转转转…… #----------------------------------------------------------...
SPLAY树
TL的博客
01-30 919
前言 根据研究表明，90%的访问都是针对10%的元素。提高这90%的访问的效率，就明显改善了对整个访问的效率。 核心思想：把最近访问过的结点提升到根，后续访问的深度将减小。把这种提升结点的操作称为“伸展Splay”。以伸展操作为基础的二叉排序树也就相应称为伸展树（Splay Tree）。 开始 基于前言中十分有用（坑爹 ）的话，于是我们需要用SPLAY树来优化时间，即把刚操作的点引到根下，即S...
splay树
H煊的博客
08-27 288
splay树（伸展树）： 概述：二叉查找树的一种改进数据结构，是可以随意翻转的二叉树 平摊时间复杂度：O（logn） 基本操作：类似AVL数操作，分为3种情况： （1）zig         （2）zig-zag         （3）zig-zig
平衡树(Splay) 服务:第一弹——旋转的艺术
artalter的博客
03-20 857
平衡树(Splay) 服务:第一弹——旋转的艺术 0.前言 本蒟蒻前不久刚学SPLAY，有了一点心得，想要巩固下来。同时也觉得网上的神犇们实在太强了，有的内容并不能很好的让我这样的蒟蒻理解，因此便有了我这篇RBQ级服务的博客。我的splay是看自有风月马前卒学的，因此部分代码可能有些相似。自有风月马前卒是一位高产的神犇，强烈推荐大家看他的博客 1.引入：何为平衡树 平衡树，大家一定都听说过（毕竟没听说过也不会来找Splay博客），那么，平衡树到底是怎么回事呢？就让小编一起带大家来看看吧 平衡树是一种 二叉搜
AVL、Splay和性能分析（伪）
__hao__的博客
12-23 1447
先说明一下，这个玩意是学校数据结构课的作业。完全是赶着ddl写完的，所以后面我都有点不知道自己在写什么。gprof也不太会，瞎弄的。主要放这里做个归档，如果对大家有帮助就更好了。当然，有问题也欢迎大家批评指正。 平衡二叉搜索树性能分析 问题描述 在AVL、Splay和红黑树三种平衡二叉搜索树中至少实现两种，需要支持以下操作：元素插入、删除和查询。在题目中，所有数据均为非负整数。查询时给出一非负整数xxx，需要求出树中满足y≤xy\le xy≤x的最大整数yyy；若树中不存在满足条件的yyy，查询返回-1.
Splay Tree伸展树
Shine__Wong的博客
10-24 505
伸展树基本概念 伸展树的基本思想。 伸展树完全是基于局部性原理(locality)的。 局部性原理是计算机科学中非常重要的原理，很多设计，比如说多级存储器，缓存，都是基于局部性原理。简单说来就是<刚访问过的数据，在一段时间内极有可能再次被访问>。因此，对于物理存储器而言，会将刚刚访问过的数据，转移存储到更高级的存储介质中，比如内存或者缓存，以便下次访问这些数据时可以高效地进行。而对...
FHQ大战Splay
蒟蒻QMQ
08-15 935
文章目录前言Splay例题学习Splay翻转splay求x的排名求排名为x的数字前驱后继插点删点代码区间操作小结FHQ Treap例题学习FHQ Treap每个点都有些什么分裂合并查询k的排名查询排名为k的数字前驱后继插入删除代码区间操作可持久化FHQ！！！例题学习可持久化分裂合并建链优化具体实现查询排名为x的数前驱后继代码残忍树套树练习12题面题解345（一道贼恶心的区间题）题面题解6题面题解 ...
伸展树(Splay Tree)
12-17
伸展树（Splay Tree）是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
Splay tree
花落知多少
06-25 355
Splay tree 将被查找的节点置于根的位置 deletion find x remove x findmax ( TLT_LTL​ ) make TRT_RTR​ the right child of the root of TLT_LTL​ https://blog.youkuaiyun.com/Woolseyyy/article/details/51512589 ...
Splay 树
黑码
04-15 363
http://blog.youkuaiyun.com/niuox/article/details/8018280结一下最近学习的Splay tree。万事开头难啊，像这种神一样的数据结构，刚学是很痛苦的，建议之前要把平衡树，SBT之类的数据结构先学学。 资料都是网上乱翻的，前一两道题，代码主要追随别人，后面慢慢的调整，成为自己的东西。 Splay tree意为伸展树，和别的不同的正是在于它的伸展操作。 在
伸展树（Splay树）
CODER-GODV的博客
10-28 557
首先找到要删除的元素并把它伸展至根结点，然后判断它的右子树是否为空，如果为空，就直接删除；如果不为空，就找到根结点最近的后继，然后将他们的值互换，把那个后继的右子树赋值为当前值，然后删除那个后继
查找——图文翔解SplayTree（伸展树）
菜鸟的自留地-mooyang
05-27 8762
伸展树 伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它由Daniel Sleator和Robert Tarjan创造，后者对其进行了改进。 假设想要对一个二叉查找树执行一系列的查找操作。为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法，在每次查找之后对树进行重构，把被查找的条目搬移到离树根近一些的地方。splaytre
伸展树(splay tree)
Wenqi's Blog
08-20 1076
什么是伸展树？首先，伸展树(splay tree)是一颗二叉搜索树，它的定义是建立在二叉搜索树之上，并且它是基于类似程序局部性原理的假设：一个节点在一次被访问后，这个节点很可能不久再次被访问。那么伸展树的做法就是在每次一个节点被访问后，我们就把它推到树根的位置。正像程序局部性原理的实际效率被广泛证明一样，伸展树在实际的搜索效率上也是非常高效的。尽管存在最坏情况下单次操作会花费O(N)的时间，但是这种
掌握基础：AVL树、Splay树与二叉搜索树的实现代码
标题中提到的AVL树、splay树和二叉搜索树（BST）都是在计算机科学中广泛使用的树形数据结构，它们在存储和搜索数据方面有各自的应用场景和优势。 AVL树是一种自平衡二叉搜索树，由Adelson-Velsky和Landis在1962年...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值