Splay 指针&&无父节点

    其实，代码还是99%的和 Running-coder 的相似，但是，没有但是……

    Splay在 NOIP && NOI 有一定地位，学一学，总比打暴搜强……

    Splay的功能有很多，百度一下，你就知道……

    Splay 中文名称 伸展树，是一种很666的平衡树，而平衡树就是优化的二叉搜索树，所以在二叉搜索树的基础上学习Splay会更好，然而我就直接跳过了二叉搜索树……

    

    代码：

    

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
#include<ctime>
#include<cstdlib>
#include<cfloat>

using namespace std;

int MAX_INT=214746000;
struct ez{
    int key;                         //key--当前节点的值
    int num;                         //num--当前节点值的数目
    int size;                        //size--当前节点的子节点个数
    ez *ch[2];                       //ch[0]--左孩子，ch[1]--右孩子。
    
    int cmp(int x){                  //比较函数，比较当前节点的值和要查询的值的大小
        if(x==key) return -1;                          
        else return x>key;
    }
    void maintain(){                 //maintain函数，用于计算每个节点的
        size=num;
        if(ch[0]!=NULL) size+=ch[0]->size;
        if(ch[1]!=NULL) size+=ch[1]->size;  //节点不为空，
    }
};
ez *root=NULL;                              //开始，根节点为空
int f,x,n,u;

void rotate(ez* &p,bool f){                 //旋转函数
    ez *t=p->ch[f^1];                                  
    if(p->ch[f^1]!=NULL)
    p->ch[f^1]=t->ch[f];
    t->ch[f]=p;                             //旋转过程，并不好描述，但只要背过代码，就完全没问题
    
    p->maintain();
    t->maintain();                          //处理size
    p=t;
}

void insert(ez* &p,int x){                   //插入函数
    if(p==NULL){                             //如果p指针为空指针，就新建一个指针
        p=(ez *)malloc(sizeof(ez));
        p->key=x;
        p->num=1;
        p->size=1;
        p->ch[0]=NULL;
        p->ch[1]=NULL;
        return;
    }else
    if(x==p->key){   //否则，如果当前指针的值与要插入的值相等，就将当前指针的num和size都加一
        p->size++;
        p->num++;
        return;
    }
    else
    if(x>p->key){  //否则继续寻找：若要查找的值比当前节点的值大就向右儿子查找，同时当前节点的子节点数目++
        insert(p->ch[1],x);
        p->size++;
        return;
    }
    else
    if(x<p->key){         //如果小，就向左儿子查找，当前子节点数目++
        insert(p->ch[0],x);
        p->size++;
        return;
    }
}

void del(ez* &p,int x){            //删除函数
    if(p==NULL) return;            //删除空节点，会 RE爆0,身败名裂！！！！
    if(p->key==x)                  //如果当前节点的值和要删除的值相同
    if(p->num>1){                  //如果该数的数目大于1，就num和size--就ok了。
        p->num--;
        p->size--;
        return;
    }
    else{                 //否则，把该节点旋转到一个叶子节点，这样就没有后顾之忧了，爆掉他！
        ez *t=p;
        if(p->ch[0]==NULL){
            p=p->ch[1];
            free(t);
            return;
        }else
        if(p->ch[1]==NULL){
            p=p->ch[0];
            free(t);
            return;
        }else{
            int o=rand()%1;
            rotate(p,o);
            del(p->ch[o],x);
            p->size--;
        }
        
    } 
    else{                   //寻找这个节点
        if(x<p->key) del(p->ch[0],x);
        else del(p->ch[1],x);
        p->size--;
    }
}

void splay(ez* &p,int x){ //没有这一部分的Splay就是一棵普通的二叉搜索树，拥有将某一点强行抽到根节点的能力
    int d1=p->cmp(x);                                
    if(d1==-1||p->ch[d1]==NULL) return;  //判断能否继续旋转
    int d2=p->ch[d1]->cmp(x);
    if(d2==-1||p->ch[d1]->ch[d2]==NULL){   //如果这能旋转一次，就旋转一次，否则 双旋
        rotate(p,d1^1);
        return;
    }else{
    splay(p->ch[d1]->ch[d2],x);           //判断能否在d1的基础上继续旋转
    if(d1==d2){
        rotate(p,d1^1);
        rotate(p,d2^1);
        return;
    }else{
        rotate(p->ch[d1],d2^1);
        rotate(p,d1^1);
        return;             //注意：不同的结果，旋转的方式不一样，如果实在理解不了，就背过代码就行了
    }
    }
}

int pre(int x){ //查前驱，方法：把要查的节点提到根节点，那么从他的左子树一直向右查询，得到的最终结果就是x的前驱,
    splay(root,x);
    if(root->key<x) return root->key;
    else{
        if(root->ch[0]==NULL) return -MAX_INT;
        else{
            splay(root->ch[0],MAX_INT);
            return root->ch[0]->key;
        }
    } 
} 

int succ(int x){               //查后继，方法恰好是求前驱反过来
    splay(root,x);
    if(root->key>x) return root->key;
    else{
        if(root->ch[1]==NULL) return -MAX_INT;
        else{
            splay(root->ch[1],-MAX_INT);
            return root->ch[1]->key;
        }
    }
}

int kth(ez* &p,int x){ //求第k小的数
    int s=0;  //方法：从根节点开始搜索，如果x比当前节点小就向左找，否则，名次上减去左子树的节点数，向右找。
    if(p->ch[0]!=NULL) s=p->ch[0]->size;
    if(x<=s) return kth(p->ch[0],x); else
    if(x<=s+p->num) return p->key;else
    return kth(p->ch[1],x-s-p->num);
}

int rank(int x){ //求当前点的排名
    splay(root,x);   //方法：从根节点搜索，如果在左边，就向左走，否则加上左边的节点数再向右找
    if(root->ch[0]==NULL) return 1;
    else return root->ch[0]->size+1;
}

int main(){
    srand(time(0)+20010930);
    
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&f);
        switch(f){
            case 1:{
                scanf("%d",&x);
                insert(root,x);
                break;
            }
            case 2:{
                scanf("%d",&x);
                del(root,x);
                splay(root,x);
                break;
            }
            case 3:{
                scanf("%d",&x);
                printf("%d\n",rank(x));
                splay(root,x);
                break;
            }
            case 4:{
                scanf("%d",&x);
                printf("%d\n",kth(root,x));
                splay(root,x);
                break;
            }
            case 5:{
                scanf("%d",&x);
                printf("%d\n",pre(x));
                splay(root,x);
                break;
            }
            case 6:{
                scanf("%d",&x);
                printf("%d\n",succ(x));
                splay(root,x);
                break;
            }
        }
    }
    return 0;
}