这是我第一篇对高级数据结构的描述，如有不准确的地方还请指出，谢谢~
调这颗树的代码调的头皮发麻，和线段树根本不是一个难度的。
首先简单地介绍一下这棵平衡BST中的另类
这是一棵没有任何平衡因子的BST，它依靠均摊来达到O（logn）的插入查询和删除复杂度，常数比较大
而且，它的具有其他BST所不具备的，对于子树的任意分裂和合并的功能
下面我从定义讲起，剖析这棵树实现过程中的每一个细节
const int INF=1000000000;
const int maxn=1000005;
int n,m;
int a[maxn];
struct Tree
{
int fa,ch[2];
int size;
int v,sum,mx,lx,rx;
bool tag,rev;
}t[maxn];
int node[maxn];
int root;
int cnt=0;
queue<int> q;
定义部分，注意INF如果太大可能会有越界的危险，所以这里长了个教训
树中包含n个点，对于树中的每一个点，有如下定义：
fa里存父节点的ID，ch[]里存左右孩子的ID，size里存该节点所形成子树包含的总节点个数
v表示节点的值，sum表示该节点所形成子树的值的和
mx,lx,rx是需要维护的一个关系，其中：
mx是当前子树的最大子串和
lx是当前子树以左端点为起点，向右延伸的最大子串和，rx同理（这里的实现思路类似于SCOI2010的线段树的那道题）
tag是区间重置标记，rev是区间翻转标记，区间即子树
q是一个垃圾回收的缓冲数组，将在后面介绍
建树部分：
void buildtree(int l,int r,int f)
{
if(l>r)
return;
int mid=(l+r)>>1;
int o=node[mid];
int last=node[f];
if(l==r)
{
t[o].sum=a[l];
t[o].size=1;
t[o].tag=t[o].rev=0;
if(a[l]>=0)
t[o].lx=t[o].rx=t[o].mx=a[l];
else
{
t[o].lx=t[o].rx=0;
t[o].mx=a[l];
}
}
else
{
buildtree(l,mid-1,mid);
buildtree(mid+1,r,mid);
}
t[o].v=a[mid];
t[o].fa=last;
update(o);
t[last].ch[mid>=f]=o;
}
依然是递归建树，由于是均摊的，根节点只要从中间随便找一个就好了
这里可以类比线段树的建树过程，比线段树稍微复杂一些
建树过程中用到了一个函数update:
void update(int o)
{
int l=t[o].ch[0],r=t[o].ch[1];
t[o].sum=t[l].sum+t[r].sum+t[o].v;
t[o].size=t[l].size+t[r].size+1;
t[o].mx=max(t[l].mx,t[r].mx);
t[o].mx=max(t[o].mx,t[l].rx+t[o].v+t[r].lx);
t[o].lx=max(t[l].lx,t[l].sum+t[o].v+t[r].lx);
t[o].rx=max(t[r].rx,t[r].sum+t[o].v+t[l].rx);
}
它的作用是随着子树的建立随时去更新子树根节点所维护的那些值
接下来介绍插入操作，它可以在特定位置插入tot个元素：
void insert(int k,int tot)
{
for(int i=1;i<=tot;i++)
cin>>a[i];
for(int i=1;i<=tot;i++)
if(!q.empty())
{
node[i]=q.front();
q.pop();
}
else
{
node[i]=++cnt;
}
buildtree(1,tot,0);
int z=node[(1+tot)>>1];
int x=find(root,k+1);
int y=find(root,k+2);
splay(x,root);
splay(y,t[x].ch[1]);
t[z].fa=y;
t[y].ch[0]=z;
update(y);
update(x);
}
大致过程如下。用着tot个元素生成一棵新的子树，子树上随便找一个点作为根节点
之后对原树伸展操作，首先找到k+1与k+2位置的节点ID
然后将k+1位置的节点伸展到根节点位置，将k+2位置的节点伸展到新根节点（就是刚才伸展过来的）的右子树位置
然后直接把新生产的子树的根节点接在k+2位置节点的左子树位置上就好了，形成之字形结构，有三层，LRL，分别是XYZ
有了这种插入的思路，我们可以把任意的东西接在任意的位置，这就是合并操作的原理
在介绍删除操作之前，我们先介绍一下split操作：
int split(int k,int tot)
{
int x=find(root,k),y=find(root,k+tot+1);
splay(x,root);
splay(y,t[x].ch[1]);
return t[y].ch[0];
}
其作用是把k位置之后的tot个节点形成的子树拎出来，放在之前所描述的之字形结构的Z位置，然后就能随意处理这个子树了，你可以把它删掉，也可以再把它接到其他位置
就比如刚才在描述插入操作的时候的那个Z位置，这样就实现了把区间的一段挪到区间的另一个位置去。分裂合并操作也就隐式实现了
既然现在这个split出来的子树已经和原来的树没有任何关系了，我就开一个新变量存一下它的根节点，然后把它和原树的联系切断，为了介绍切断，我们这里引出删除函数：
void erase(int k,int tot)
{
int x=split(k,tot);
int y=t[x].fa;
rec(x);
t[y].ch[0]=0;
update(y);
update(t[y].fa);
}
其删除的实现中有一个回收节点空间的函数rec，我们如果此时不做回收，而是像刚才那样，开一个新变量存这个拎出来的节点，就能既切断联系又拎出来了一棵子树。美滋滋
接下来我们稍微改动一下insert函数，把其中z替换成我们拎出来的这个子树
综上所述，区间的任意分裂合并都可以实现了
其实除了分裂和合并操作之外，就是BST的最基本的套路了
我们接着介绍，刚才引出了好几个陌生的函数，先说离咱们最近的那个，rec,回收子树节点函数：
void rec(int x)
{
if(!x)
return;
int l=t[x].ch[0],r=t[x].ch[1];
rec(l);rec(r);q.push(x);
t[x].fa=t[x].ch[0]=t[x].ch[1]=0;
t[x].tag=t[x].rev=0;
}
这个函数存在的意义就是重复利用Tree结构的空间，避免因数组连续性造成的空间浪费，这里学了一招，应该很实用
然后我们介绍find函数，这个函数就是用来找指定位置的节点ID的
int find(int o,int rk)
{
pushdown(o);
int l=t[o].ch[0],r=t[o].ch[1];
if(t[l].size+1==rk)
return o;
if(t[l].size>=rk)
return find(l,rk);
return find(r,rk-t[l].size-1);
}
在o形成的子树中找第k个节点的ID
这里又引出了pushdown函数
void pushdown(int x)
{
int l=t[x].ch[0];
int r=t[x].ch[1];
if(t[x].tag)
{
t[x].rev=t[x].tag=0;
if(l)
{
t[l].tag=1;
t[l].v=t[x].v;
t[l].sum=t[x].v*t[l].size;
}
if(r)
{
t[r].tag=1;
t[r].v=t[x].v;
t[r].sum=t[x].v*t[r].size;
}
if(t[x].v>=0)
{
if(l)
t[l].lx=t[l].rx=t[l].mx=t[l].sum;
if(r)
t[r].lx=t[r].rx=t[r].mx=t[r].sum;
}
else
{
if(l)
t[l].lx=t[l].rx=0,t[l].mx=t[x].v;
if(r)
t[r].lx=t[r].rx=0,t[r].mx=t[x].v;
}
}
if(t[x].rev)
{
t[x].rev^=1;t[l].rev^=1;t[r].rev^=1;
swap(t[l].lx,t[l].rx),swap(t[r].lx,t[r].rx);
swap(t[l].ch[0],t[l].ch[1]);
swap(t[r].ch[0],t[r].ch[1]);
}
}
它是用来处理节点上的翻转和重置标记的
说了半天都没有说splay函数，下面介绍
void splay(int x,int &k)
{
while(x!=k)
{
int y=t[x].fa;
int z=t[y].fa;
if(y!=k)
{
if(t[y].ch[0]==x^t[z].ch[0]==y)
rotate(x,k);
else
rotate(y,k);
}
rotate(x,k);
}
}
这个函数可以把一个节点伸展到指定根节点的位置（可以是子树根），这个时候这个节点就是新的根节点了
这是整个伸展树最核心的函数，一定要理解
然后就是旋转操作，其实刚开始旋转我是不会的，后来我是去看了AVL的四种旋转方式才过来看的Splay
我们先回顾一下AVL的四种旋转方式，什么是AVL（一种特别特别正经的平衡树，不想用）
LL,RR,LR,RL，左旋就是往左转，右旋就是往右转，转的时候要搞清楚转哪条边，把谁转过去把谁转过来，转完之后有时候要拆接，怎么处理。搞清楚之后，理解Splay的一字形旋转和之字形旋转就容易多了
Splay双旋（只有双旋才叫Splay）的目的不是为了平衡，而是为了协助完成Splay操作，一次Splay就把沿途的所有的点都转了一遍
下面给出旋转的函数，写的比较硬核：
void rotate(int x,int &k)
{
int y=t[x].fa;
int z=t[y].fa;
int l=(t[y].ch[1]==x);
int r=l^1;
if(y==k)
k=x;
else
t[z].ch[t[z].ch[1]==y]=x;
t[t[x].ch[r]].fa=y;
t[y].fa=x;
t[x].fa=z;
t[y].ch[l]=t[x].ch[r];
t[x].ch[r]=y;
update(y);
update(x);
}
后面的就比较水了，重点都已经介绍完了，再说说修改函数，把tot个树都修改为指定的值
void modify(int k,int tot,int val)
{
int x=split(k,tot);
int y=t[x].fa;
t[x].v=val,t[x].tag=1,t[x].sum=t[x].size*val;
if(val>=0)
t[x].lx=t[x].rx=t[x].mx=t[x].sum;
else
t[x].lx=t[x].rx=0,t[x].mx=val;
update(y);
update(t[y].fa);
}
原理很简单，打标记，更新节点参数
然后是区间翻转：
void rever(int k,int tot)
{
int x=split(k,tot);
int y=t[x].fa;
if(!t[x].tag)
{
t[x].rev^=1;
swap(t[x].ch[0],t[x].ch[1]);
swap(t[x].lx,t[x].rx);
update(y);
update(t[y].fa);
}
}
也是打标记，反正有处理标记的函数，不怕，这里和线段树的lazy Tag的原理类似，只不过这里的树实在是很复杂
再说说查询：
void query(int k,int tot)
{
int x=split(k,tot);
cout<<t[x].sum<<endl;
}
只查个sum太水了，我们可以中序遍历是不是，BST家族都可以的
特别特别特别要注意的一点，在执行分裂合并操作的时候，如果你没有保证分裂合并能够满足BST性质，那么因为你的分裂合并，这棵Splay可能就不再是一棵BST了
你要特别小心这一点，仔细审题，如果只让你分裂合并，那好说，如果涉及到了查询什么的，一定要看清楚题意才行
最后，我们给出debug了三个小时的Template,感谢黄学长~
1 #include<queue>
2 #include<iostream>
3 #include<cstdlib>
4 #include<algorithm>
5 using namespace std;
6 const int INF=1000000000;
7 const int maxn=1000005;
8 int n,m;
9 int a[maxn];
10 struct Tree
11 {
12 int fa,ch[2];
13 int size;
14 int v,sum,mx,lx,rx;
15 bool tag,rev;
16 }t[maxn];
17 int node[maxn];
18 int root;
19 int cnt=0;
20 queue<int> q;
21 void update(int o)
22 {
23 int l=t[o].ch[0],r=t[o].ch[1];
24 t[o].sum=t[l].sum+t[r].sum+t[o].v;
25 t[o].size=t[l].size+t[r].size+1;
26 t[o].mx=max(t[l].mx,t[r].mx);
27 t[o].mx=max(t[o].mx,t[l].rx+t[o].v+t[r].lx);
28 t[o].lx=max(t[l].lx,t[l].sum+t[o].v+t[r].lx);
29 t[o].rx=max(t[r].rx,t[r].sum+t[o].v+t[l].rx);
30 }
31 void pushdown(int x)
32 {
33 int l=t[x].ch[0];
34 int r=t[x].ch[1];
35 if(t[x].tag)
36 {
37 t[x].rev=t[x].tag=0;
38 if(l)
39 {
40 t[l].tag=1;
41 t[l].v=t[x].v;
42 t[l].sum=t[x].v*t[l].size;
43 }
44 if(r)
45 {
46 t[r].tag=1;
47 t[r].v=t[x].v;
48 t[r].sum=t[x].v*t[r].size;
49 }
50 if(t[x].v>=0)
51 {
52 if(l)
53 t[l].lx=t[l].rx=t[l].mx=t[l].sum;
54 if(r)
55 t[r].lx=t[r].rx=t[r].mx=t[r].sum;
56 }
57 else
58 {
59 if(l)
60 t[l].lx=t[l].rx=0,t[l].mx=t[x].v;
61 if(r)
62 t[r].lx=t[r].rx=0,t[r].mx=t[x].v;
63 }
64 }
65 if(t[x].rev)
66 {
67 t[x].rev^=1;t[l].rev^=1;t[r].rev^=1;
68 swap(t[l].lx,t[l].rx),swap(t[r].lx,t[r].rx);
69 swap(t[l].ch[0],t[l].ch[1]);
70 swap(t[r].ch[0],t[r].ch[1]);
71 }
72 }
73 void rotate(int x,int &k)
74 {
75 int y=t[x].fa;
76 int z=t[y].fa;
77 int l=(t[y].ch[1]==x);
78 int r=l^1;
79 if(y==k)
80 k=x;
81 else
82 t[z].ch[t[z].ch[1]==y]=x;
83 t[t[x].ch[r]].fa=y;
84 t[y].fa=x;
85 t[x].fa=z;
86 t[y].ch[l]=t[x].ch[r];
87 t[x].ch[r]=y;
88 update(y);
89 update(x);
90 }
91 void splay(int x,int &k)
92 {
93 while(x!=k)
94 {
95 int y=t[x].fa;
96 int z=t[y].fa;
97 if(y!=k)
98 {
99 if(t[y].ch[0]==x^t[z].ch[0]==y)
100 rotate(x,k);
101 else
102 rotate(y,k);
103 }
104 rotate(x,k);
105 }
106 }
107 int find(int o,int rk)
108 {
109 pushdown(o);
110 int l=t[o].ch[0],r=t[o].ch[1];
111 if(t[l].size+1==rk)
112 return o;
113 if(t[l].size>=rk)
114 return find(l,rk);
115 return find(r,rk-t[l].size-1);
116 }
117 void rec(int x)
118 {
119 if(!x)
120 return;
121 int l=t[x].ch[0],r=t[x].ch[1];
122 rec(l);rec(r);q.push(x);
123 t[x].fa=t[x].ch[0]=t[x].ch[1]=0;
124 t[x].tag=t[x].rev=0;
125 }
126 int split(int k,int tot)
127 {
128 int x=find(root,k),y=find(root,k+tot+1);
129 splay(x,root);
130 splay(y,t[x].ch[1]);
131 return t[y].ch[0];
132 }
133 void query(int k,int tot)
134 {
135 int x=split(k,tot);
136 cout<<t[x].sum<<endl;
137 }
138 void modify(int k,int tot,int val)
139 {
140 int x=split(k,tot);
141 int y=t[x].fa;
142 t[x].v=val,t[x].tag=1,t[x].sum=t[x].size*val;
143 if(val>=0)
144 t[x].lx=t[x].rx=t[x].mx=t[x].sum;
145 else
146 t[x].lx=t[x].rx=0,t[x].mx=val;
147 update(y);
148 update(t[y].fa);
149 }
150 void rever(int k,int tot)
151 {
152 int x=split(k,tot);
153 int y=t[x].fa;
154 if(!t[x].tag)
155 {
156 t[x].rev^=1;
157 swap(t[x].ch[0],t[x].ch[1]);
158 swap(t[x].lx,t[x].rx);
159 update(y);
160 update(t[y].fa);
161 }
162 }
163 void erase(int k,int tot)
164 {
165 int x=split(k,tot);
166 int y=t[x].fa;
167 rec(x);
168 t[y].ch[0]=0;
169 update(y);
170 update(t[y].fa);
171 }
172 void buildtree(int l,int r,int f)
173 {
174 if(l>r)
175 return;
176 int mid=(l+r)>>1;
177 int o=node[mid];
178 int last=node[f];
179 if(l==r)
180 {
181 t[o].sum=a[l];
182 t[o].size=1;
183 t[o].tag=t[o].rev=0;
184 if(a[l]>=0)
185 t[o].lx=t[o].rx=t[o].mx=a[l];
186 else
187 {
188 t[o].lx=t[o].rx=0;
189 t[o].mx=a[l];
190 }
191 }
192 else
193 {
194 buildtree(l,mid-1,mid);
195 buildtree(mid+1,r,mid);
196 }
197 t[o].v=a[mid];
198 t[o].fa=last;
199 update(o);
200 t[last].ch[mid>=f]=o;
201 }
202 void insert(int k,int tot)
203 {
204 for(int i=1;i<=tot;i++)
205 cin>>a[i];
206 for(int i=1;i<=tot;i++)
207 if(!q.empty())
208 {
209 node[i]=q.front();
210 q.pop();
211 }
212 else
213 {
214 node[i]=++cnt;
215 }
216
217 buildtree(1,tot,0);
218 int z=node[(1+tot)>>1];
219 int x=find(root,k+1);
220 int y=find(root,k+2);
221 splay(x,root);
222 splay(y,t[x].ch[1]);
223 t[z].fa=y;
224 t[y].ch[0]=z;
225 update(y);
226 update(x);
227 }
228 int main()
229 {
230 std::ios::sync_with_stdio(false);
231 cin>>n>>m;
232 t[0].mx=a[1]=a[n+2]=-INF;
233 for(int i=1;i<=n;i++)
234 cin>>a[i+1];
235 for(int i=1;i<=n+2;i++)
236 node[i]=i;
237 buildtree(1,n+2,0);
238 root=(n+3)>>1;
239 cnt=n+2;
240 int k,tot,val;
241 char ch[15];
242 while(m--)
243 {
244 cin>>ch;
245 if(ch[0]!=‘M‘||ch[2]!=‘X‘)
246 cin>>k>>tot;
247 if(ch[0]==‘I‘)
248 insert(k,tot);
249 if(ch[0]==‘D‘)
250 erase(k,tot);
251 if(ch[0]==‘M‘)
252 {
253 if(ch[2]==‘X‘)
254 cout<<t[root].mx<<endl;
255 else
256 cin>>val,modify(k,tot,val);
257 }
258 if(ch[0]==‘R‘)
259 rever(k,tot);
260 if(ch[0]==‘G‘)
261 query(k,tot);
262 }
263 return 0;
264 }
最后吐槽一下，这道题是NOI2005年的数列操作，也是我有生以来做的第二道NOI题目（这时候立刻想到了第一道是什么）
能够在考场上完美实现一个这么个东西，平时要付出多少努力可想而知，不是谁都可以去清华的
原文地址：https://www.cnblogs.com/aininot260/p/9326793.html