Splay讲解

伸展树(Splay Tree)是AVL树不错的替代，它有以下几个特点：
(1)它是二叉查找树的改进，所以具有二叉查找树的有序性。
(2)对伸展树的操作的平摊复杂度是O(log2n)。
(3)伸展树的空间要求、编程难度非常低。

提到伸展树，就不得不提到AVL树和Read-Black树，虽然这两种树能够保证各种操作在最坏情况下都为logN，但是两都实现都比较复杂。而在实际情况中，90%的访问发生在10%的数据上。因此，我们可以重构树的结构，使得被经常访问的节点朝树根的方向移动。尽管这会引入额外的操作，但是经常被访问的节点被移动到了靠近根的位置，因此，对于这部分节点，我们可以很快的访问。这样，就能使得平摊复杂度为logN。

1、自底向上的伸展树
伸展操作Splay(x,S)是在保持伸展树有序性的前提下，通过一系列旋转操作将伸展树S中的元素x调整至树的根部的操作。
在旋转的过程中，要分三种情况分别处理：
(1)Zig 或 Zag
(2)Zig-Zig 或 Zag-Zag
(3)Zig-Zag 或 Zag-Zig
1.1、Zig或Zag操作
节点x的父节点y是根节点。

1.2、Zig-Zig或Zag-Zag操作
节点x的父节点y不是根节点，且x与y同时是各自父节点的左孩子或者同时是各自父节点的右孩子。

1.3、Zig-Zag或Zag-Zig操作
节点x的父节点y不是根节点，x与y中一个是其父节点的左孩子而另一个是其父节点的右孩子。

2.以上的操作我们就可以将某一个节点进行相应的旋转，接下来叙述一下如何对于区间进行操作。

首先我们要知道，伸展树是具有有序性的，无论进行如何反转操作，有序性都不会被破坏掉。这样子就对我们的区间操作提供了很大的方便，假设要对于区间【L，R】进行操作，我们先把L-1反转到根节点处，再把R+1节点反转到根的右孩子处，这样很显然的目前R节点的左孩子的子树就是我们要处理的这段区间，由于边界问题，我们经常加入两个虚拟节点，分别是数列的头部和尾部，然后就可以方便的进行操作了，把一棵子树剪切，翻转等操作都可以利用这个性质很好的实现。有时候为了边界问题，我们会添加两个虚节点，分别作为序列的开始和结尾。接下来是我的splay的实现代码，仅供参考。

#define N 500000#define lc (tr[id].c[0])#define rc (tr[id].c[1])struct Tr {    int fa, sum, val, c[2], lz;}tr[N];int newtr(int k, int f) {//新建立一个节点    tr[tot].sum = 1, tr[tot].val =  k;    tr[tot].c[0] = tr[tot].c[1] = -1;    tr[tot].lz = 0;    tr[tot].fa = f;    return tot++;}void Push(int id) {    int lsum, rsum;    lsum = (lc == -1)?0:tr[lc].sum;    rsum = (rc == -1)?0:tr[rc].sum;    tr[id].sum = lsum+rsum+1;}void lazy(int id) {//懒操作    if (tr[id].lz) {        swap(lc, rc);        tr[lc].lz ^= 1, tr[rc].lz ^= 1;        tr[id].lz = 0;    }}int build(int l, int r, int f) {//建树    if (r < l) return-1;    int mid = l+r>>1;    int ro = newtr(data[mid], f);    tr[ro].c[0] = build(l, mid-1, ro);    tr[ro].c[1] = build(mid+1, r, ro);    Push(ro);    return ro;}void Rotate(int x, int k) {    if (tr[x].fa == -1) return;    int fa = tr[x].fa, w;    lazy(fa), lazy(x);    tr[fa].c[!k] = tr[x].c[k];    if (tr[x].c[k] != -1) tr[tr[x].c[k]].fa = fa;    tr[x].fa = tr[fa].fa, tr[x].c[k] = fa;    if (tr[fa].fa != -1) {        w = tr[tr[fa].fa].c[1]==fa;        tr[tr[fa].fa].c[w] = x;    }    tr[fa].fa = x;    Push(fa);    Push(x);}void Splay(int x, int goal) {//将x节点转到goal的儿子上    if (x == -1) return;    lazy(x);    while (tr[x].fa != goal) {        int y = tr[x].fa;        lazy(tr[y].fa), lazy(y), lazy(x);        bool w = x==tr[y].c[1];        if (tr[y].fa != goal && w == (y==tr[tr[y].fa].c[1]))            Rotate(y, !w);        Rotate(x, !w);    }    if (goal == -1) root = x;    Push(x);}int find(int k) {//找到第k哥节点的ID    int id = root;    while (id != -1) {        lazy(id);        int lsum = (lc==-1)?0:tr[lc].sum;        if (lsum >= k) {            id = lc;        }        else if (lsum+1 == k) break;        else {            k = k-lsum-1;            id = rc;        }    }    return id;}int Index(int l, int r) {//将区间【l+1, r-1】化成一颗子树    Splay(find(l),-1);    Splay(find(r),root);}int Getnext(int id) {//寻找后继节点    lazy(id);    int p = tr[id].c[1];    if (p == -1) return id;    lazy(p);    while (tr[p].c[0] != -1) {        p = tr[p].c[0];        lazy(p);    }    return p;}int del(int l, int r) {//将【l,r】切掉,返回切掉子树的根节点    Index(l-1, r+1);    int ro = KEY;    tr[KEY].fa = -1;    KEY = -1;    Push(tr[root].c[1]);    Push(root);    return ro;}void cut(int k, int ro) {//将子树ro接到第k个树之后    Index(k, k+1);    KEY = ro;    tr[ro].fa = tr[root].c[1];    Push(tr[root].c[1]);    Push(root);}void filp(int l, int r) {//对区间【l,r】反转    Index(l-1, r+1);    lazy(root), lazy(tr[root].c[1]);    tr[KEY].lz ^= 1;}void Add(int l, int r, int d) {//区间【l,r】的数加上d    Index(l-1, r+1);    tr[KEY].add += d;    tr[KEY].mi += d;    tr[KEY].val += d;    Push(tr[root].c[1]);    Push(root);}void Delete(int x) {//删除第x个数    Index(x-1, x+1);    tr[KEY].fa = -1;    tr[tr[root].c[1]].c[0] = -1;    Push(tr[root].c[1]);    Push(root);}void Insert(int l, int x) {//在l之后插入x    Index(l, l+1);    int ro;    ro = newtr(x, tr[root].c[1]);    KEY = ro;    Push(tr[root].c[1]);    Push(root);}void Revolve(int l, int r, int d) {//【l, r】整体右移d位    int ro = del(r+1-d, r);    cut(l-1, ro);}