poj 1785 Binary Search Heap Construction

题目链接：
Binary Search Heap Construction

就是建立一个二叉平衡树
刚开始用的treap，tle了，看了这篇文章后发现，如果数据给的是一条链的，那么时间复杂度会达到O(n^2)，稳定tle，但是zoj 2243由于给的时间限制是5ms所以treap是可以过的
文章链接传送门
先把tle的代码贴出来吧T—T

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <stack>
#include <queue>
#include <map>
#include <cmath>
#include <algorithm>

using namespace std;

const int maxn = 5 * 1e5 + 5;

struct treap
{
    char s[3];
    int val;
    treap *l,*r;
};

struct node1
{
    char s1[3];
    int v;
}node[maxn];

bool operator < (const node1 &a,node1 &b)
{
    return strcmp(a.s1,b.s1) < 0;
}

void Treap_Left_Rotate(treap *&rt)
{
    treap *temp = rt->r;
    rt->r = temp->l;
    temp->l = rt;
    rt = temp;
}

void Creat(int i,treap *&rt)
{
    if(rt == NULL){
        rt = new treap;
        rt->s[0] = node[i].s1[0];
        rt->s[1] = 0;
        rt->val = node[i].v;
        rt->l = rt->r = NULL;
        return ;
    }
    Creat(i,rt->r);
    if(rt->val < rt->r->val){
        Treap_Left_Rotate(rt);
    }
}

void in_print(treap *rt)
{
    if(rt == NULL){
        return ;
    }
    printf("(");
    in_print(rt->l);
    printf("%s/%d",rt->s,rt->val);
    in_print(rt->r);
    printf(")");
}

int main()
{
    int n;
    while(scanf("%d",&n),n){
        memset(node,0,sizeof(node));
        treap *rt = NULL;
        for(int i = 1; i <= n; i++){
            /*scanf的用法，%*[ ],表示越过[ ]中的字符，%[a-z]表示读入字符串，
            直到遇到不是a-z中的字符为止。
            %[^a]表示读入字符串直到遇到字符a为止，但a并没有被读入。*/
            scanf("%*[ ]%[^/]/%d",node[i].s1,&node[i].v);
        }
        sort(node + 1,node + n + 1);
        for(int i = 1; i <= n; i++){
            Creat(i,rt);
           //cout<<node[i].s1<<endl;
        }
        in_print(rt);
        printf("\n");
    }
    return 0;
}

下面是笛卡尔树，上面的那篇文章里也给出了相应的建立笛卡尔树的方法和时间复杂度的分析

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <stack>
#include <queue>
#include <map>
#include <cmath>
#include <algorithm>

using namespace std;

const int maxn = 50005;
const int inf = 0x7fffffff;

struct node
{
    char s1[105];
    int val,pa,ls,rs;
    //val 优先级，pa上级节点
}treap[maxn];

//重载速度要比定义比较函数快
bool operator < (const node &a,node &b)
{
    return strcmp(a.s1,b.s1) < 0;
}

void Creat(int i)
{
    int j = i - 1;
    //找到第一个优先级大于待插入节点优先级的上级节点
    while(treap[j].val < treap[i].val){
        j = treap[j].pa;
    }
    //将treap[j]的right指向待插入的节点，treap[j]的right原来指向的节点赋值给待插入节点的left指针
    treap[i].ls = treap[j].rs;
    treap[j].rs = i;
    treap[i].pa = j;
}

void in_print(int i)
{
    if(!i){
        return ;
    }
    printf("(");
    in_print(treap[i].ls);
    printf("%s/%d",treap[i].s1,treap[i].val);
    in_print(treap[i].rs);
    printf(")");
}

int main()
{
    int n;
    while(scanf("%d",&n)&&n){
        memset(treap,0,sizeof(treap));
        treap[0].val = inf;
        for(int i = 1; i <= n; i++){
            /*scanf的用法，%*[ ],表示越过[ ]中的字符，%[a-z]表示读入字符串，
            直到遇到不是a-z中的字符为止。
            %[^a]表示读入字符串直到遇到字符a为止，但a并没有被读入。*/
            scanf("%*[ ]%[^/]/%d",treap[i].s1,&treap[i].val);
        }
        sort(treap + 1,treap + n + 1);
        for(int i = 1; i <= n; i++){
            Creat(i);
           //cout<<node[i].s1<<endl;
        }
        in_print(treap[0].rs);
        printf("\n");
    }
    return 0;
}