经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C++ » 查看文章
[Splay][学习笔记]
来源：cnblogs　　作者：wxyww　　时间：2018/12/10 9:46:14　　对本文有异议

胡扯

因为先学习的treap，而splay与treap中有许多共性，所以会有很多地方不会讲的很细致。关于treap和平衡树可以参考这篇博客

关于splay

splay,又叫伸展树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。伸展树是一种自调整形式的二叉查找树，它会沿着从某个节点到树根之间的路径，通过一系列的旋转把这个节点搬移到树根去。

splay与其他平衡树相比功能更加强大，可以处理区间问题。可以说其他平衡树可以做的splay几乎都能做。所以很多大佬都说平衡树会写splay就好了。唯一的缺点可能就是常数要比treap大。

定义

  1. struct node {
  2.     int ch[2],val,siz,cnt,pre;
  3. }TR[N];

ch[0/1]分别为当前节点的两个儿子。val为当前节点的值。siz为以当前节点为根的子树大小，cnt为当前节点的值出现的次数。pre为当前节点的父亲节点

旋转

splay也是通过旋转来保持平衡的。spaly的旋转也是挺易懂的

如图，现在我们把4旋转到2这个位置。也就是说要把4号节点旋转上去。

第一步：将2-4这条边断开，将8变为2的右儿子。

第二步：将1-2这条边断开，将4变为1的右儿子。

第三步：将2变为4的左儿子

第四步：更新4号节点和2号节点，完成旋转

  1. void rotate(int cur) {
  2.     int f = getwh(cur),fa = TR[cur].pre,gr = TR[fa].pre;
  3.     TR[gr].ch[getwh(fa)] = cur;
  4.     TR[cur].pre = gr;
  5.     TR[fa].ch[f] = TR[cur].ch[f ^ 1];
  6.     TR[TR[cur].ch[f ^ 1]].pre = fa;
  7.     TR[fa].pre = cur;
  8.     TR[cur].ch[f ^ 1] = fa;
  9.     up(fa);
  10.     up(cur);
  11. }

其中getwh是用来得到当前点是其父亲的左儿子还是右儿子，fa是当前点的父亲，gr是当前点的爷爷

getwh代码如下

  1. int getwh(int cur) {
  2.     return TR[TR[cur].pre].ch[1] == cur;
  3. }

伸展

与treap相比，splay多了一种非常重要的操作——伸展操作。

所谓伸展，就是通过一系列旋转，将一个节点挪到一个想让他到达的位置(这个位置一般为根)。

splay的伸展总共可以分为三种情况(伸展到底有什么用后面会提到，现在只需知道他的作用如上即可)。

第一种情况：

如图，x结点要挪到他的爷爷结点下面，这种情况只要将x点旋转一次即可

第二种情况

x结点要挪到他爷爷的节点以上的节点下面，并且他的爷爷，和他的父亲，和他在同一直线上。

啥叫在同一直线上？？？

如图，现在g，p，x就在同一直线上，然后要将x转到右面的情况，只要现将p旋转上去，然后再讲x旋转上去即可

第三种情况，

x结点要挪到他爷爷的节点以上的节点下面，并且他的爷爷，和他的父亲，和他不在同一直线上。

如图，现在只要先将x旋转到p的位置，然后再将x旋转到g的位置即可

PS

经博主实践证明，第二和第三种情况都可以通过第三种情况的操作方式进行，至于为什么第二类不如此操作，大概是为了保持树的平衡。但是反而更慢

综上所述

我们可以得到伸展的代码(to为0时就是旋转成根)

  1. void splay(int cur,int to) {
  2.     while(TR[cur].pre != to) {
  3.         if(TR[TR[cur].pre].pre != to) {
  4.              if(getwh(cur) == getwh(TR[cur].pre)) rotate(TR[cur].pre);
  5.              else rotate(cur);
  6.         }
  7.         rotate(cur);
  8.     }
  9.     if(!to) rt = cur;
  10. }

插入

splay的插入和treap的插入类似。就是不断地寻找当前点恰当的位置，如果以前已经有了，就将cnt++即可，否则新建一个节点。

最后不要忘记将新插入的节点伸展为根。

  1. void insert(int cur,int val,int lst) {
  2.     if(!cur) {
  3.         cur = ++tot;
  4.         TR[cur].pre = lst;
  5.         TR[cur].siz = TR[cur].cnt = 1;
  6.         TR[cur].val = val;
  7.         TR[lst].ch[val > TR[lst].val] = cur;
  8.         splay(cur,0);
  9.         return;
  10.     }
  11.     TR[cur].siz++;
  12.     if(val == TR[cur].val) {TR[cur].cnt++;return;}
  13.     if(val > TR[cur].val) insert(rs,val,cur);
  14.     else insert(ls,val,cur);
  15. }

合并

合并操作也是treap种所没有了。splay中的合并主要是为了删除操作做准备

所谓合并也就是将两棵子树合成一棵。两棵子树能合并的前提是其中一个中的所有元素大于另一棵的所有元素。

其实很简单，假如说现在x子树中的所有元素都小于y子树中的所有元素，那么只需找到x种最靠右的(也就是最大的)节点，然后将y变为此节点的右孩子即可。

最后还是要把y节点或者是x子树中最大的那个节点伸展为根。

  1. void merge(int cur,int y) {
  2.     if(TR[cur].val > TR[y].val) swap(cur,y);
  3.     if(!cur) {
  4.         rt = y;
  5.         return;
  6.     }
  7.     while(rs) cur = rs;
  8.     splay(cur,0);
  9.     rs = y;
  10.     TR[y].pre = cur;
  11.     up(cur);
  12. }

查找节点

这也是一个用来辅助其他操作的操作。作用是查找权值为val的节点。

很简单，就是在二叉搜索树上查找操作，如果比当前节点大就去查右子树，否则查左子树。和当前节点一样大了就范围即可。

  1. int getpos(int cur,int val) {
  2.     int lst;
  3.     while(cur) {
  4.         lst = cur;
  5.         if(TR[cur].val == val) return cur;
  6.         cur = TR[cur].ch[val > TR[cur].val];
  7.     }
  8.     return lst;
  9. }

删除

有了合并操作，删除就很好完成了。首先找到要删除的节点，然后将此节点伸展为根。然后将这个节点的左右子树合并即可。

  1. void del(int cur,int val) {
  2.     cur = getpos(rt,val);
  3.     if(!cur) return;
  4.     if(TR[cur].val != val) return;
  5.     splay(cur,0);
  6.     if(TR[cur].cnt > 1) {TR[cur].cnt--;TR[cur].siz--;return;}
  7.     TR[ls].pre = TR[rs].pre = 0;
  8.     merge(ls,rs);
  9. }

查询排名

用查找操作找到当前节点，然后旋转为根，左子树的大小+1就是这个节点的排名

查询第k大

与treap一样，如果k大于左子树大小+当前节点个数，就在右子树中查找k-左子树大小-当前节点个数。如果k<=左子树大小，那么直接在左子树中查找第k大。否则返回当前点即可。

  1. int kth(int cur,int x) {
  2.     while(cur) {
  3.         if(x <= TR[ls].siz) cur = ls;
  4.         else if(x > TR[ls].siz + TR[cur].cnt) x -= TR[cur].cnt + TR[ls].siz,cur = rs;
  5.         else return TR[cur].val;
  6.     }
  7.     return cur;
  8. }

前驱

找到要查询的点伸展为根。然后在左子树中查找最大值即可。

  1. int pred(int cur,int val) {
  2.     cur = getpos(rt,val);
  3.     if(TR[cur].val < val) return TR[cur].val;
  4.     splay(cur,0);
  5.     cur = ls;
  6.     while(rs) cur = rs;
  7.     return TR[cur].val;
  8. }

后继

找到要查询的点伸展为根。然后在右子树中查找最小值即可。

  1. int nex(int cur,int val) {
  2.     cur = getpos(rt,val);
  3.     if(TR[cur].val > val) return TR[cur].val;
  4.     splay(cur,0);
  5.     cur = rs;
  6.     while(ls) cur = ls;
  7.     return TR[cur].val;
  8. }

区间操作

关于splay的区间操作，可以参考这篇博客

完整代码

  1. #include<cstdio>
  2. #include<iostream>
  3. using namespace std;
  4. typedef long long ll;
  5. const int N = 100000 + 100;
  6. #define ls TR[cur].ch[0]
  7. #define rs TR[cur].ch[1]
  8. ll read() {
  9.     ll x = 0,f = 1;char c = getchar();
  10.     while(c < '0' || c > '9') {
  11.         if(c == '-') f = -1;
  12.         c = getchar();
  13.     }
  14.     while(c >= '0' && c <= '9') {
  15.         x = x * 10 + c -'0';
  16.         c = getchar();
  17.     }
  18.     return x * f;
  19. }
  20. int rt;
  21. struct node {
  22.     int ch[2],val,siz,cnt,pre;
  23. }TR[N];
  24. void up(int cur) {
  25.     TR[cur].siz = TR[ls].siz + TR[rs].siz + TR[cur].cnt;
  26. }
  27. int getwh(int cur) {
  28.     return TR[TR[cur].pre].ch[1] == cur;
  29. }
  30. void rotate(int cur) {
  31.     int f = getwh(cur),fa = TR[cur].pre,gr = TR[fa].pre;
  32.     TR[gr].ch[getwh(fa)] = cur;
  33.     TR[cur].pre = gr;
  34.     TR[fa].ch[f] = TR[cur].ch[f ^ 1];
  35.     TR[TR[cur].ch[f ^ 1]].pre = fa;
  36.     TR[fa].pre = cur;
  37.     TR[cur].ch[f ^ 1] = fa;
  38.     up(fa);
  39.     up(cur);
  40. }
  41. void splay(int cur,int to) {
  42.     while(TR[cur].pre != to) {
  43.         if(TR[TR[cur].pre].pre != to) {
  44.             // if(getwh(cur) == getwh(TR[cur].pre)) rotate(TR[cur].pre);
  45.             // else 
  46.                 rotate(cur);
  47.         }
  48.         rotate(cur);
  49.     }
  50.     if(!to) rt = cur;
  51. }
  52. int tot;
  53. void insert(int cur,int val,int lst) {
  54.     if(!cur) {
  55.         cur = ++tot;
  56.         TR[cur].pre = lst;
  57.         TR[cur].siz = TR[cur].cnt = 1;
  58.         TR[cur].val = val;
  59.         TR[lst].ch[val > TR[lst].val] = cur;
  60.         splay(cur,0);
  61.         return;
  62.     }
  63.     TR[cur].siz++;
  64.     if(val == TR[cur].val) {TR[cur].cnt++;return;}
  65.     if(val > TR[cur].val) insert(rs,val,cur);
  66.     else insert(ls,val,cur);
  67. }
  68. void merge(int cur,int y) {
  69.     if(TR[cur].val > TR[y].val) swap(cur,y);
  70.     if(!cur) {
  71.         rt = y;
  72.         return;
  73.     }
  74.     while(rs) cur = rs;
  75.     splay(cur,0);
  76.     rs = y;
  77.     TR[y].pre = cur;
  78.     up(cur);
  79. }
  80. int getpos(int cur,int val) {
  81.     int lst;
  82.     while(cur) {
  83.         lst = cur;
  84.         if(TR[cur].val == val) return cur;
  85.         cur = TR[cur].ch[val > TR[cur].val];
  86.     }
  87.     return lst;
  88. }
  89. void del(int cur,int val) {
  90.     cur = getpos(rt,val);
  91.     if(!cur) return;
  92.     if(TR[cur].val != val) return;
  93.     splay(cur,0);
  94.     if(TR[cur].cnt > 1) {TR[cur].cnt--;TR[cur].siz--;return;}
  95.     TR[ls].pre = TR[rs].pre = 0;
  96.     merge(ls,rs);
  97. }
  98. int Rank(int cur,int val) {
  99.     cur = getpos(rt,val);
  100.     splay(cur,0);
  101.     return TR[ls].siz + 1;
  102. }
  103. int kth(int cur,int x) {
  104.     while(cur) {
  105.         if(x <= TR[ls].siz) cur = ls;
  106.         else if(x > TR[ls].siz + TR[cur].cnt) x -= TR[cur].cnt + TR[ls].siz,cur = rs;
  107.         else return TR[cur].val;
  108.     }
  109.     return cur;
  110. }
  111. int pred(int cur,int val) {
  112.     cur = getpos(rt,val);
  113.     if(TR[cur].val < val) return TR[cur].val;
  114.     splay(cur,0);
  115.     cur = ls;
  116.     while(rs) cur = rs;
  117.     return TR[cur].val;
  118. }
  119. int nex(int cur,int val) {
  120.     cur = getpos(rt,val);
  121.     if(TR[cur].val > val) return TR[cur].val;
  122.     splay(cur,0);
  123.     cur = rs;
  124.     while(ls) cur = ls;
  125.     return TR[cur].val;
  126. }
  127. int main() {
  128.     int n = read();
  129.     while(n--) {
  130.         int opt = read(),x = read();
  131.         if(opt == 1) insert(rt,x,0);
  132.         if(opt == 2) del(rt,x);
  133.         if(opt == 3) printf("%d\n",Rank(rt,x));
  134.         if(opt == 4) printf("%d\n",kth(rt,x));
  135.         if(opt == 5) printf("%d\n",pred(rt,x));
  136.         if(opt == 6) printf("%d\n",nex(rt,x));
  137.     }
  138.     return 0;
  139. }
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C++热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C++推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号