胡扯

因為先學習的treap，而splay與treap中有許多共性，所以會有很多地方不會講的很細緻。關於treap和平衡樹可以參考這篇部落格

關於splay

splay,又叫伸展樹，是一種二叉排序樹，它能在O(log n)內完成插入、查詢和刪除操作。它由Daniel Sleator和Robert Tarjan創造。伸展樹是一種自調整形式的二叉查詢樹，它會沿著從某個節點到樹根之間的路徑，通過一系列的旋轉把這個節點搬移到樹根去。

splay與其他平衡樹相比功能更加強大，可以處理區間問題。可以說其他平衡樹可以做的splay幾乎都能做。所以很多大佬都說平衡樹會寫splay就好了。唯一的缺點可能就是常數要比treap大。

定義

struct node {
    int ch[2],val,siz,cnt,pre;
}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號節點，完成旋轉

void rotate(int cur) {
    int f = getwh(cur),fa = TR[cur].pre,gr = TR[fa].pre;
    TR[gr].ch[getwh(fa)] = cur;
    TR[cur].pre = gr;
    TR[fa].ch[f] = TR[cur].ch[f ^ 1];
    TR[TR[cur].ch[f ^ 1]].pre = fa;
    TR[fa].pre = cur;
    TR[cur].ch[f ^ 1] = fa;
    up(fa);
    up(cur);
}

其中getwh是用來得到當前點是其父親的左兒子還是右兒子，fa是當前點的父親，gr是當前點的爺爺

getwh程式碼如下

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

伸展

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

所謂伸展，就是通過一系列旋轉，將一個節點挪到一個想讓他到達的位置(這個位置一般為根)。

splay的伸展總共可以分為三種情況(伸展到底有什麼用後面會提到，現在只需知道他的作用如上即可)。

第一種情況：

如圖，x結點要挪到他的爺爺結點下面，這種情況只要將x點旋轉一次即可

第二種情況

x結點要挪到他爺爺的節點以上的節點下面，並且他的爺爺，和他的父親，和他在同一直線上。

啥叫在同一直線上？？？

如圖，現在g，p，x就在同一直線上，然後要將x轉到右面的情況，只要現將p旋轉上去，然後再講x旋轉上去即可

第三種情況，

x結點要挪到他爺爺的節點以上的節點下面，並且他的爺爺，和他的父親，和他不在同一直線上。

如圖，現在只要先將x旋轉到p的位置，然後再將x旋轉到g的位置即可

PS

經博主實踐證明，第二和第三種情況都可以通過第三種情況的操作方式進行，至於為什麼第二類不如此操作，大概是為了保持樹的平衡。但是反而更慢

綜上所述

我們可以得到伸展的程式碼(to為0時就是旋轉成根)

void splay(int cur,int to) {
    while(TR[cur].pre != to) {
        if(TR[TR[cur].pre].pre != to) {
             if(getwh(cur) == getwh(TR[cur].pre)) rotate(TR[cur].pre);
             else rotate(cur);
        }
        rotate(cur);
    }
    if(!to) rt = cur;
}

插入

splay的插入和treap的插入類似。就是不斷地尋找當前點恰當的位置，如果以前已經有了，就將cnt++即可，否則新建一個節點。

最後不要忘記將新插入的節點伸展為根。

void insert(int cur,int val,int lst) {
    if(!cur) {
        cur = ++tot;
        TR[cur].pre = lst;
        TR[cur].siz = TR[cur].cnt = 1;
        TR[cur].val = val;
        TR[lst].ch[val > TR[lst].val] = cur;
        splay(cur,0);
        return;
    }
    TR[cur].siz++;
    if(val == TR[cur].val) {TR[cur].cnt++;return;}
    if(val > TR[cur].val) insert(rs,val,cur);
    else insert(ls,val,cur);
}

合併

合併操作也是treap種所沒有了。splay中的合併主要是為了刪除操作做準備

所謂合併也就是將兩棵子樹合成一棵。兩棵子樹能合併的前提是其中一箇中的所有元素大於另一棵的所有元素。

其實很簡單，假如說現在x子樹中的所有元素都小於y子樹中的所有元素，那麼只需找到x種最靠右的(也就是最大的)節點，然後將y變為此節點的右孩子即可。

最後還是要把y節點或者是x子樹中最大的那個節點伸展為根。

void merge(int cur,int y) {
    if(TR[cur].val > TR[y].val) swap(cur,y);
    if(!cur) {
        rt = y;
        return;
    }
    while(rs) cur = rs;
    splay(cur,0);
    rs = y;
    TR[y].pre = cur;
    up(cur);
}

查詢節點

這也是一個用來輔助其他操作的操作。作用是查詢權值為val的節點。

很簡單，就是在二叉搜尋樹上查詢操作，如果比當前節點大就去查右子樹，否則查左子樹。和當前節點一樣大了就範圍即可。

int getpos(int cur,int val) {
    int lst;
    while(cur) {
        lst = cur;
        if(TR[cur].val == val) return cur;
        cur = TR[cur].ch[val > TR[cur].val];
    }
    return lst;
}

刪除

有了合併操作，刪除就很好完成了。首先找到要刪除的節點，然後將此節點伸展為根。然後將這個節點的左右子樹合併即可。

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

查詢排名

用查詢操作找到當前節點，然後旋轉為根，左子樹的大小+1就是這個節點的排名

查詢第k大

與treap一樣，如果k大於左子樹大小+當前節點個數，就在右子樹中查詢k-左子樹大小-當前節點個數。如果k<=左子樹大小，那麼直接在左子樹中查詢第k大。否則返回當前點即可。

int kth(int cur,int x) {
    while(cur) {
        if(x <= TR[ls].siz) cur = ls;
        else if(x > TR[ls].siz + TR[cur].cnt) x -= TR[cur].cnt + TR[ls].siz,cur = rs;
        else return TR[cur].val;
    }
    return cur;
}

前驅

找到要查詢的點伸展為根。然後在左子樹中查詢最大值即可。

int pred(int cur,int val) {
    cur = getpos(rt,val);
    if(TR[cur].val < val) return TR[cur].val;
    splay(cur,0);
    cur = ls;
    while(rs) cur = rs;
    return TR[cur].val;
}

後繼

找到要查詢的點伸展為根。然後在右子樹中查詢最小值即可。

int nex(int cur,int val) {
    cur = getpos(rt,val);
    if(TR[cur].val > val) return TR[cur].val;
    splay(cur,0);
    cur = rs;
    while(ls) cur = ls;
    return TR[cur].val;
}

完整程式碼

#include<cstdio>
#include<iostream>
using namespace std;
typedef long long ll;
const int N = 100000 + 100;
#define ls TR[cur].ch[0]
#define rs TR[cur].ch[1]
ll read() {
    ll x = 0,f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c -'0';
        c = getchar();
    }
    return x * f;
}
int rt;
struct node {
    int ch[2],val,siz,cnt,pre;
}TR[N];
void up(int cur) {
    TR[cur].siz = TR[ls].siz + TR[rs].siz + TR[cur].cnt;
}
int getwh(int cur) {
    return TR[TR[cur].pre].ch[1] == cur;
}
void rotate(int cur) {
    int f = getwh(cur),fa = TR[cur].pre,gr = TR[fa].pre;
    TR[gr].ch[getwh(fa)] = cur;
    TR[cur].pre = gr;
    TR[fa].ch[f] = TR[cur].ch[f ^ 1];
    TR[TR[cur].ch[f ^ 1]].pre = fa;
    TR[fa].pre = cur;
    TR[cur].ch[f ^ 1] = fa;
    up(fa);
    up(cur);
}
void splay(int cur,int to) {
    while(TR[cur].pre != to) {
        if(TR[TR[cur].pre].pre != to) {
            // if(getwh(cur) == getwh(TR[cur].pre)) rotate(TR[cur].pre);
            // else 
                rotate(cur);
        }
        rotate(cur);
    }
    if(!to) rt = cur;
}
int tot;
void insert(int cur,int val,int lst) {
    if(!cur) {
        cur = ++tot;
        TR[cur].pre = lst;
        TR[cur].siz = TR[cur].cnt = 1;
        TR[cur].val = val;
        TR[lst].ch[val > TR[lst].val] = cur;
        splay(cur,0);
        return;
    }
    TR[cur].siz++;
    if(val == TR[cur].val) {TR[cur].cnt++;return;}
    if(val > TR[cur].val) insert(rs,val,cur);
    else insert(ls,val,cur);
}
void merge(int cur,int y) {
    if(TR[cur].val > TR[y].val) swap(cur,y);
    if(!cur) {
        rt = y;
        return;
    }
    while(rs) cur = rs;
    splay(cur,0);
    rs = y;
    TR[y].pre = cur;
    up(cur);
}
int getpos(int cur,int val) {
    int lst;
    while(cur) {
        lst = cur;
        if(TR[cur].val == val) return cur;
        cur = TR[cur].ch[val > TR[cur].val];
    }
    return lst;
}
void del(int cur,int val) {
    cur = getpos(rt,val);
    if(!cur) return;
    if(TR[cur].val != val) return;
    splay(cur,0);
    if(TR[cur].cnt > 1) {TR[cur].cnt--;TR[cur].siz--;return;}
    TR[ls].pre = TR[rs].pre = 0;
    merge(ls,rs);
}
int Rank(int cur,int val) {
    cur = getpos(rt,val);
    splay(cur,0);
    return TR[ls].siz + 1;
}
int kth(int cur,int x) {
    while(cur) {
        if(x <= TR[ls].siz) cur = ls;
        else if(x > TR[ls].siz + TR[cur].cnt) x -= TR[cur].cnt + TR[ls].siz,cur = rs;
        else return TR[cur].val;
    }
    return cur;
}
int pred(int cur,int val) {
    cur = getpos(rt,val);
    if(TR[cur].val < val) return TR[cur].val;
    splay(cur,0);
    cur = ls;
    while(rs) cur = rs;
    return TR[cur].val;
}
int nex(int cur,int val) {
    cur = getpos(rt,val);
    if(TR[cur].val > val) return TR[cur].val;
    splay(cur,0);
    cur = rs;
    while(ls) cur = ls;
    return TR[cur].val;
}
int main() {
    int n = read();
    while(n--) {
        int opt = read(),x = read();
        if(opt == 1) insert(rt,x,0);
        if(opt == 2) del(rt,x);
        if(opt == 3) printf("%d\n",Rank(rt,x));
        if(opt == 4) printf("%d\n",kth(rt,x));
        if(opt == 5) printf("%d\n",pred(rt,x));
        if(opt == 6) printf("%d\n",nex(rt,x));
    }
    return 0;
}