在洛谷3369 Treap模板题 中发现的Splay详解
本题的Splay写法（无指针Splay超详细）
前言
首先来讲。。。终于调出来了55555。。。调了整整3天。。。。。
看到大部分大佬都是用指针来实现的Splay。小的只是按照Splay的核心思想和原理来进行的。可能会有不妥之处，还请大佬们指出，谢谢！
那么这个题解存在的意义就是让不会敲Splay的人额。。。会敲Splay啦。。。
基本思想
数据结构
对于Splay，我定义了一个class类（当成struct就行啦。。。个人习惯不同啦），定义名称为“Splay”。
之后在类中，我定义了Splay的主体，即数组e。
e的类型是node类型，包含节点值（v）、父级节点（father）、左孩子（ch[0]）、右孩子（ch[1]）、包含自己在内的下面共有多少元素（sum）（注意是元素啊！！！不是节点！！！）、该节点所表示的元素出现的次数（recy）。
之后，还在类中定义了n代表当前已经使用的数组编号。points代表整个树总共有多少元素（注意是元素啊！！！不是节点！！！）。
另外，整棵树中，有一个超级根e[0]，其右孩子即为树的根。
宏定义了e[0].ch[1]为root，方便访问、理解。并在类的末尾取消定义root，确保外部再定义root变量时不会出现问题，维持其模块性质。
class Splay//存储规则：小左大右，重复节点记录
{
#define root e[0].ch[1] //该树的根节点
private:
class node
{
public:
int v,father;//节点值，父级节点
int ch[2];//左孩子=0，右孩子=1
int sum;//自己+自己下级有多少节点。在根节点为1。
int recy;//记录自己被重复了几次
};
node e[MAXL];//Splay树主体
int n,points;//使用存储数,元素数
……
#undef root
};功能全解
更新当前节点sum值（update）
就是在进行了连接、插入、删除等操作以后使用的一个维护性质的函数。用来确定被update的节点的sum值。
void update(int x)
{
e[x].sum=e[e[x].ch[0]].sum+e[e[x].ch[1]].sum+e[x].recy;
}获取父子关系（identify）
用来确定当前节点到底是父亲的左孩子（0）还是右孩子（1）。
int identify(int x)
{
return e[e[x].father].ch[0]==x?0:1;
}建立父子关系（connect）
用来连接两个点，其中一个点为另一个点的孩子。
注意，这个操作并不能将其他的父子关系一并断开。因为他们与被操作的两个点没有直接的数据联系。例如下图：
图表明尽管B的父亲已经不是x，但是x的右孩子依旧是B，没有被更新。因此使用过程中应当有更巧妙的设计来避免这样导致的错误发生。
void connect(int x,int f,int son)//连接函数。用法：connect(son,father,左儿子（0）或右儿子（1）)
{
e[x].father=f;
e[f].ch[son]=x;
}//作用：将x连接在f的下方。连接方向由son的值决定。旋转节点（rotate）
着重注意的一个函数。这个函数同时实现了左旋和右旋。
所谓的旋转，其实就是指将被指定的节点向上移动一级，并将原有的父级节点作为自己的儿子。如下图：
我们可以通过下图原理论证来确定只需要三次connect即可完成旋转。
上图代表了右旋。
在图中，A、B、C代表三个子树（可以是空的），x和y代表被旋转的节点。R为y的上级节点，与旋转没有直接关系，但是它的右孩子要进行相应的改变。
在进行完connect函数后，再进行update函数即可完成旋转。
但是旋转总共有两种类型的操作（即左旋和右旋）。在这里，我们需要配合位运算直接达到自动判断和旋转方向决断的目的。
我们知道，对于任意一个自然数，与1进行逻辑异或运算，会得到这样的结果：
0^1=1 1^1=0 2^1=3 3^1=2 4^1=5 5^1=4 ……
也就是说，0对应1，2对应3，4对应5，向后依次推。
既然这样，那么我们的左右儿子节点所代表的编号分别是0和1。也就是说对其中一个取逻辑异或，会得到另一个儿子的标号（即对0取逻辑异或得1，对1取逻辑异或得0）。
通过左旋右旋的性质可以知道，实际改变了父子关系的节点是上图的：x、y、B节点。因为实际上，A、C节点的父子关系并没有发生任何改变。
并且我们能够注意到，x与y节点的连接方向一定是与x和B的连接方向不同的。
那么，我们只需要先通过“identify”函数确定x与y的父子关系，确定到底要向那一边旋转（如果x是y的左孩子，那么就向右旋转。如果x是y的右孩子，那么就向左旋转），然后通过逻辑异或来确定子树“B”究竟应当被连接在y的哪一侧。
void rotate(int x)
{
int y=e[x].father;
int mroot=e[y].father;
int mrootson=identify(y);
int yson=identify(x);
int B=e[x].ch[yson^1];
connect(B,y,yson);connect(y,x,(yson^1));connect(x,mroot,mrootson);
update(y);update(x);
}伸展操作（Splay）
其实就是考虑上旋节点的方式。
在这里，一开始我使用了一种较为偷懒的旋转方式，即能向上旋转就向上旋转。并不考虑上面的状况到底怎样。
其实，标准的写法中，需要考虑两种情况。如下图：
为了防止造成误导，我将不再介绍直接上旋的操作。但事实上，无论是直接上旋还是先判断再上旋，都会有可能进化或者退化原本的树形结构。
我也曾举出过两种操作模式各自进化或者退化树的例子。但是根据交题情况，在洛谷的模板题中，直接上旋的速度更快。然而在湖南的一道省选题中，使用直接上旋的模式却直接导致超时（大概慢了10倍）。所以说在面对大数据的不确定因素下，还是应当选择考虑更多种情况，而不能图方便。
在这里，我的函数实现的操作是：将at节点旋转到to节点所在的位置。
void splay(int at,int to)
{
to=e[to].father;
while(e[at].father!=to)
{
int up=e[at].father;
if(e[up].father==to) rotate(at);
else if(identify(up)==identify(at))
{//对应图中case1
rotate(up);
rotate(at);
}
else
{//对应图中case2
rotate(at);
rotate(at);
}
}
}添加节点（crepoint）和摧毁节点（destroy）
这两个操作是在插入新元素和删除元素过程中使用的函数。
crepoint的作用是获得一个新的树存储位置，然后为这个存储空间写入基本的信息，并返回使用的存储位置编号。
destroy的作用则是使得一个节点完全失效，完全抹除节点信息，防止其他意外的发生。并且添加了一个小小的优化：如果被抹除的节点恰好是存储数组的当前最后一个元素，那么就对存储空间的使用数减1。
实际上，也可以通过一个队列来确定那些节点在中间被挖空了。但这样的操作不仅要牺牲一个O(log N)的时间复杂度，而且事实上并没有太大的用处，因为你开的数组大小一定能够满足极端情况（比如说所有操作都是插入）。
int crepoint(int v,int father)
{
n++;
e[n].v=v;
e[n].father=father;
e[n].sum=e[n].recy=1;
return n;
}
void destroy(int x)
{
e[x].v=e[x].ch[0]=e[x].ch[1]=e[x].sum=e[x].father=e[x].recy=0;
if(x==n) n--;
}查找元素（find）
要实现的功能是找特定值是否在树中以及对应的节点编号。
很简单的实现方式。从根开始向下移动，如果要找的元素比当前节点小，那么就转到自己的左孩子。否则，就转向自己的右孩子，直到节点值等于要找的值。
如果在找到目标值之前，需要走的路已经无法再走（比如说现在到了5，要找的是3，应该往左走，但是5已经没有左孩子了），那么则查找失败，返回失败值（0）。如果查找成功，则返回节点对应的编号。
查找结束后，将被查找的节点旋转到根，以保证树的结构随机性。
int find(int v)
{
int now=root;
while(true)
{
if(e[now].v==v)
{
splay(now,root);
return now;
}
int next=v<e[now].v?0:1;
if(!e[now].ch[next]) return 0;
now=e[now].ch[next];
}
}建树（build）
建树的功能我并没有看懂大佬们的操作到底是什么意思。。。（我觉得应该是将Splay用作线段树的时候使用的功能）所以我写了一个没有上旋操作的insert函数。
首先，从根开始，向下寻找。如果要插入的元素已经在树中，那么将这个节点的recy加1即可。如果没有出现过，那么找一个合适的空的位置。找到位置后，调用crepoint函数，在数组中申请一个新的下标存储元素。
同时注意，在向下寻找的过程中，对被经过的点的sum值加1，因为如果经过这个点，代表要加的点肯定在自己下面，所以自己下面的元素个数加1。
int build(int v)//内部调用的插入函数，没有splay
{
points++;
if(n==0)//特判无点状态
{
root=1;
crepoint(v,0);
}
else
{
int now=root;
while(true)//向下找到一个空节点
{
e[now].sum++;//自己的下级肯定增加了一个节点
if(v==e[now].v)
{
e[now].recy++;
return now;
}
int next=v<e[now].v?0:1;
if(!e[now].ch[next])
{
crepoint(v,now);
e[now].ch[next]=n;
return n;
}
now=e[now].ch[next];
}
}
return 0;
}插入节点（push）
就是在进行完build操作以后，执行一次上旋操作，确保树的结构随机性。
void push(int v)
{
int add=build(v);
splay(add,root);
}删除节点（pop）
将输入值对应的节点在树中移除。
进行这样的操作时，我一开始考虑的是通过逐层的rotate操作将要被删除的节点转到最下方，然后再删除，最后逐层向上改变路径上的sum值。但是考虑到这样的操作可能会一方面导致树的大幅度退化，另一方面相当于要进行两次O(log N)的时间复杂度操作，常数略大，可能会成为一颗定时炸弹。所以为了稳定，还是用了常规的方法：
首先将要删除的节点旋转到根节点的位置。
然后，判断情况：如果要被删除的节点（注意现在它在根的位置）没有左孩子，那么直接摧毁这个节点，并将它的右孩子变成根。
如果自己有左孩子，那么就先把左子树中值最大的元素旋转到根的左孩子位置，然后将根节点的右孩子变成根节点的左孩子的右孩子，然后摧毁节点，并将左孩子变成根。
原理还请读者自己考虑吧，根据二叉排序树的性质。。。
void pop(int v)//删除节点
{
int deal=find(v);
if(!deal) return;
points--;
if(e[deal].recy>1)
{
e[deal].recy--;
e[deal].sum--;
return;
}
if(!e[deal].ch[0])
{
root=e[deal].ch[1];
e[root].father=0;
}
else
{
int lef=e[deal].ch[0];
while(e[lef].ch[1]) lef=e[lef].ch[1];
splay(lef,e[deal].ch[0]);
int rig=e[deal].ch[1];
connect(rig,lef,1);connect(lef,0,1);
update(lef);
}
destroy(deal);
}获取元素的排名（rank）&获取该排名对应的元素值（atrank）
两个函数是互逆的函数。
rank的实现根find差不多，只是在向下走的时候，对于当前已经记录的rank值进行更新（每次调用rank时都初始化为0）。规则是：向左走时，rank值不发生任何改变。向右走之前，要先给rank加上当前节点的左孩子的sum值和recy值。找到对应元素时，再对rank+1。如下图：
atrank函数根rank实现完全相反。在向下走的过程中，如果要找的排名大于当前点左子树的sum值，并且小于等于当前点的左子树的sum加上本节点的recy的值，那么当前的点就是要找的点。如果小于上述范围，就往左走，反之向右。注意向右走的过程中，将要查询的排名值减少上述范围的最大值。
两个操作结束后，都要将被操作的节点旋转到根。
int rank(int v)//获取值为v的元素在这棵树里是第几小
{
int ans=0,now=root;
while(true)
{
if(e[now].v==v) return ans+e[e[now].ch[0]].sum+1;
if(now==0) return 0;
if(v<e[now].v) now=e[now].ch[0];
else
{
ans=ans+e[e[now].ch[0]].sum+e[now].recy;
now=e[now].ch[1];
}
}
if(now) splay(now,root);
return 0;
}
int atrank(int x)//获取第x小的元素的值
{
if(x>points) return -INF;
int now=root;
while(true)
{
int minused=e[now].sum-e[e[now].ch[1]].sum;
if(x>e[e[now].ch[0]].sum&&x<=minused) break;
if(x<minused) now=e[now].ch[0];
else
{
x=x-minused;
now=e[now].ch[1];
}
}
splay(now,root);
return e[now].v;
}查找前驱（lower）和后继（upper）
两种操作是类似的操作。
前驱是指在树中，小于这个值并且最接近这个值的元素值。
后继则是大于这个值并且最接近这个值的元素值。
对于这两种函数的实现方式，就是先初始化一个最值，然后在向下走的过程中，如果发现了符合要求且更优的值，就用更优值替换当前的值。最后不能走的时候输出这个值即可。
int upper(int v)
{
int now=root;
int result=INF;
while(now)
{
if(e[now].v>v&&e[now].v<result) result=e[now].v;
if(v<e[now].v) now=e[now].ch[0];
else now=e[now].ch[1];
}
return result;
}
int lower(int v)
{
int now=root;
int result=-INF;
while(now)
{
if(e[now].v<v&&e[now].v>result) result=e[now].v;
if(v>e[now].v) now=e[now].ch[1];
else now=e[now].ch[0];
}
return result;
}完整源代码
下面贴出完整源代码，方便交流分享！
1 #include<iostream> 2 #include<cstdio> 3 #include<algorithm> 4 using namespace std; 5 6 const int MAXL=100005; 7 const int INF=2147480000; 8 9 class Splay//存储规则：小左大右，重复节点记录 10 { 11 #define root e[0].ch[1] //该树的根节点 12 private: 13 class node 14 { 15 public: 16 int v,father;//节点值，父级节点 17 int ch[2];//左孩子=0，右孩子=1 18 int sum;//自己+自己下级有多少节点。在根节点为1。 19 int recy;//记录自己被重复了几次 20 }; 21 node e[MAXL];//Splay树主体 22 int n,points;//使用存储数,元素数 23 void update(int x) 24 { 25 e[x].sum=e[e[x].ch[0]].sum+e[e[x].ch[1]].sum+e[x].recy; 26 } 27 int identify(int x) 28 { 29 return e[e[x].father].ch[0]==x?0:1; 30 } 31 void connect(int x,int f,int son)//连接函数。用法：connect(son,father,1/0) 32 { 33 e[x].father=f; 34 e[f].ch[son]=x; 35 }//作用：使得x的father=f，f的son=x. 36 void rotate(int x) 37 { 38 int y=e[x].father; 39 int mroot=e[y].father; 40 int mrootson=identify(y); 41 int yson=identify(x); 42 int B=e[x].ch[yson^1]; 43 connect(B,y,yson);connect(y,x,(yson^1));connect(x,mroot,mrootson); 44 update(y);update(x); 45 } 46 void splay(int at,int to)//将at位置的节点移动到to位置 47 { 48 to=e[to].father; 49 while(e[at].father!=to) 50 { 51 int up=e[at].father; 52 if(e[up].father==to) rotate(at); 53 else if(identify(up)==identify(at)) 54 { 55 rotate(up); 56 rotate(at); 57 } 58 else 59 { 60 rotate(at); 61 rotate(at); 62 } 63 } 64 } 65 int crepoint(int v,int father) 66 { 67 n++; 68 e[n].v=v; 69 e[n].father=father; 70 e[n].sum=e[n].recy=1; 71 return n; 72 } 73 void destroy(int x)//pop后摧毁节点 74 { 75 e[x].v=e[x].ch[0]=e[x].ch[1]=e[x].sum=e[x].father=e[x].recy=0; 76 if(x==n) n--;//最大限度优化 77 } 78 public: 79 int getroot(){return root;} 80 int find(int v)//用于外部的find调用 81 { 82 int now=root; 83 while(true) 84 { 85 if(e[now].v==v) 86 { 87 splay(now,root); 88 return now; 89 } 90 int next=v<e[now].v?0:1; 91 if(!e[now].ch[next]) return 0; 92 now=e[now].ch[next]; 93 } 94 } 95 int build(int v)//内部调用的插入函数，没有splay 96 { 97 points++; 98 if(n==0)//特判无点状态 99 { 100 root=1; 101 crepoint(v,0); 102 } 103 else 104 { 105 int now=root; 106 while(true)//向下找到一个空节点 107 { 108 e[now].sum++;//自己的下级肯定增加了一个节点 109 if(v==e[now].v) 110 { 111 e[now].recy++; 112 return now; 113 } 114 int next=v<e[now].v?0:1; 115 if(!e[now].ch[next]) 116 { 117 crepoint(v,now); 118 e[now].ch[next]=n; 119 return n; 120 } 121 now=e[now].ch[next]; 122 } 123 } 124 return 0; 125 } 126 void push(int v)//插入元素时，先添加节点，再进行伸展 127 { 128 int add=build(v); 129 splay(add,root); 130 } 131 void pop(int v)//删除节点 132 { 133 int deal=find(v); 134 if(!deal) return; 135 points--; 136 if(e[deal].recy>1) 137 { 138 e[deal].recy--; 139 e[deal].sum--; 140 return; 141 } 142 if(!e[deal].ch[0]) 143 { 144 root=e[deal].ch[1]; 145 e[root].father=0; 146 } 147 else 148 { 149 int lef=e[deal].ch[0]; 150 while(e[lef].ch[1]) lef=e[lef].ch[1]; 151 splay(lef,e[deal].ch[0]); 152 int rig=e[deal].ch[1]; 153 connect(rig,lef,1);connect(lef,0,1); 154 update(lef); 155 } 156 destroy(deal); 157 } 158 int rank(int v)//获取值为v的元素在这棵树里是第几小 159 { 160 int ans=0,now=root; 161 while(true) 162 { 163 if(e[now].v==v) return ans+e[e[now].ch[0]].sum+1; 164 if(now==0) return 0; 165 if(v<e[now].v) now=e[now].ch[0]; 166 else 167 { 168 ans=ans+e[e[now].ch[0]].sum+e[now].recy; 169 now=e[now].ch[1]; 170 } 171 } 172 if(now) splay(now,root); 173 return 0; 174 } 175 int atrank(int x)//获取第x小的元素的值 176 { 177 if(x>points) return -INF; 178 int now=root; 179 while(true) 180 { 181 int minused=e[now].sum-e[e[now].ch[1]].sum; 182 if(x>e[e[now].ch[0]].sum&&x<=minused) break; 183 if(x<minused) now=e[now].ch[0]; 184 else 185 { 186 x=x-minused; 187 now=e[now].ch[1]; 188 } 189 } 190 splay(now,root); 191 return e[now].v; 192 } 193 int upper(int v)//寻找该值对应的一个最近的上界值 194 { 195 int now=root; 196 int result=INF; 197 while(now) 198 { 199 if(e[now].v>v&&e[now].v<result) result=e[now].v; 200 if(v<e[now].v) now=e[now].ch[0]; 201 else now=e[now].ch[1]; 202 } 203 return result; 204 } 205 int lower(int v)//寻找该值对应的一个最近的下界值 206 { 207 int now=root; 208 int result=-INF; 209 while(now) 210 { 211 if(e[now].v<v&&e[now].v>result) result=e[now].v; 212 if(v>e[now].v) now=e[now].ch[1]; 213 else now=e[now].ch[0]; 214 } 215 return result; 216 } 217 #undef root 218 }; 219 Splay F; 220 221 int main() 222 { 223 224 return 0; 225 }
后记
总算是讲完了如何实现最基础的Splay排序树。
可能会有大佬感觉：明明是来做题的了，怎么会有不懂Splay的呢？这不纯粹是装逼么？而且一点水平也没有，纯粹瞎扯淡！
我只能说，我刚开始学Splay的时候，就是一点一点的寻找相关资料的。包括从这道模板题找。但是系统讲解的还真没多少。而且贴出来的示例代码比较复杂，表示弱鸡看不懂。。。所以在钻研以后，写下了这篇文章。这些是我对Splay的理解。我将他们变成了书面的东西去分享给大家，希望大家能够从中受益，希望能够帮到更多正在努力学习平衡树的OIERS。如果有问题，也可以提出来，帮助我改进。
