HDU 5349 MZL's simple problem(平衡树 树堆)

HDU 5349

#include<iostream>
#include<cmath>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<cstdio>
#include<queue>
using namespace std;
struct Node
{
    Node* son[2];
    int rank;
    int size;
    int key;
    bool operator<(const Node &a)const
    {
        return rank<a.rank;   //重载小于好，用于维护堆的性质
    }
    int cmp(int x)const
    {
        if(x==key) return -1;    //比较函数，用于确定寻找的值的位置，0表示左儿子，1表示右儿子，-1代表当前节点
        return x<key?0:1;
    }
    void maintain()//这里仅仅需要维护size
    {
        size = 1 + son[0]->size + son[1]->size;
    }
};
struct Treap
{
    Node * root;
    Node *null = new Node();//定义空结点，可以有效避免NULL带来的问题
    //初始化Treap
    void initial()
    {
        srand(time(NULL));
        root = null;
    }
    //旋转操作，d=0时代表左旋，d=1时代表右旋
    void rotate(Node* &o,int d)
    {
        Node*  k = o->son[d^1];
        o->son[d^1] = k -> son[d];
        k->son[d] = o;
        o->maintain();//注意，必须先维护o再维护k，因为o是子节点，不优先维护，会导致父节点出错
        k->maintain();
        o = k;
    }
    void ins(Node*  &o,int x)
    {
        if(o==null)
        {
            o = new Node();
            o->son[0] = o->son[1] = null;
            o->rank = rand();
            o->key = x;
            o->size = 1;
        }
        else
        {
            int d;
            if(x>o->key)d=1;
            else d=0;
            ins(o->son[d],x);
            o->maintain();//维护size：节点个数
            if(o <= o->son[d])
                rotate(o,d^1);//当位于左儿子时，需要进行的是右旋，当位于右儿子时应当进行左旋，因此通项为rotate(o,d^1)
        }
    }
    void del(Node* &o,int x)
    {
        int d = o->cmp(x);
        if(d==-1)//已经找到待删除节点，将会有两种情况
        {
            if(o->son[0] == null) o = o->son[1];//左儿子为空，直接连接父节点和右儿子
            else if(o->son[1] == null) o= o->son[0];//右儿子为空，同上
            else
            {
                d = o->son[0] < o->son[1] ? 0:1;//在子节点中找到一个rank大的节点，将其旋转到当前节点，那么当前节点应当位于相反的子节点
                rotate(o,d);
                del(o->son[d],x);
            }
        }
        else
            del(o->son[d],x);
        if(o!=null) o->maintain();//删除节点后，需要对size进行维护。需要注意的是，如果节点为空时，就不需要维护了
    }
    int kth(Node* o,int k)//寻找第k大数
    {
        if(o == null || k<=0 || k>o->size) return -1;//k过大或者过小都不能找到，Treap中没有节点也无需找
        int s = (o->son[1] == null?0:o->son[1]->size);//获得右儿子的size
        if(k == s+1) return o->key;//当k为 s + 1时，说明当前节点就是答案
        else
            if(k<=s) return kth(o->son[1],k);//当k<s时，说明第k大数在右子树，k值无需更改
        else
            return kth(o->son[0],k-s-1);//当k>s+1时，第k大数在左子树，需要减去右子树的值和节点本身
    }
    int find(Node* o,int k)//返回该数是第几大
    {
        if(o == null) return -1;
        int d = o->cmp(k);
        if(d == -1) return 1 + o->son[1]->size;
        else if(d == 1) return find(o->son[d],k);
        else
        {
            int tmp = find(o->son[d],k);
            if(tmp == -1) return -1;
            else
                return tmp + 1 + o->son[1]->size;
        }
    }
} treap;

int main()
{
    int n,t,s,x,ans,m;
    while(~scanf("%d",&t))
    {
        s=0;
        treap.initial();//树堆初始化
        while(t--){
            scanf("%d",&n);
            if(n==1){
                scanf("%d",&x);
                treap.ins(treap.root,x);//插入；
                s++;
            }
            else if(n==2){
                if(s>=1){
                    m = treap.kth(treap.root,s);
                    treap.del(treap.root,m);//删除先进先出
                    s--;
                }
            }
            else{
                if(s>0)ans = treap.kth(treap.root,1),printf("%d\n",ans);
                else printf("0\n");
            }
        }
    }
    return 0;
}