平衡二叉树---Shaolin

Description

Shaolin temple is very famous for its Kongfu monks.A lot of young men go to Shaolin temple every year, trying to be a monk there. The master of Shaolin evaluates a young man mainly by his talent on understanding the Buddism scripture, but fighting skill is also taken into account. 
When a young man passes all the tests and is declared a new monk of Shaolin, there will be a fight , as a part of the welcome party. Every monk has an unique id and a unique fighting grade, which are all integers. The new monk must fight with a old monk whose fighting grade is closest to his fighting grade. If there are two old monks satisfying that condition, the new monk will take the one whose fighting grade is less than his. 
The master is the first monk in Shaolin, his id is 1，and his fighting grade is 1,000,000,000.He just lost the fighting records. But he still remembers who joined Shaolin earlier, who joined later. Please recover the fighting records for him. 

 

Input

HDU  4585

There are several test cases. 
In each test case: 
The first line is a integer n (0 <n <=100,000),meaning the number of monks who joined Shaolin after the master did.(The master is not included).Then n lines follow. Each line has two integer k and g, meaning a monk's id and his fighting grade.( 0<= k ,g<=5,000,000) 
The monks are listed by ascending order of jointing time.In other words, monks who joined Shaolin earlier come first. 
The input ends with n = 0. 

 

Output

A fight can be described as two ids of the monks who make that fight. For each test case, output all fights by the ascending order of happening time. Each fight in a line. For each fight, print the new monk's id first ,then the old monk's id.

 

Sample Input

3 2 1 3 3 4 2 0

 

Sample Output

2 1 3 2 4 2

 

题意：有n个新加入的和尚和一个开始的大和尚，大和尚编号为1，攻击力1000,000,000  其它n个和尚编号和攻击力各不一样，输入流中按时间顺序给出了加入的和尚的编号和攻击力，每个新加入的和尚会找一个和他攻击力最接近的已加入的和尚比试，若有两个和尚和这个新和尚的差值相同，攻击力小的和他比试，输出新和尚的编号和与他比试的和尚的编号。

 

思路：使用平衡二叉树的算法，方便查找x值的前驱与后继。

 

代码如下：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
struct data
{
    int l,r,v,vo;
    int rnd;
}tr[110000];
int size,root,ans1,ans2;///定义全局整型变量默认初值为0；

void rturn(int &k)
{
    int t=tr[k].l;
    tr[k].l=tr[t].r;
    tr[t].r=k;
    k=t;
}

void lturn(int &k)
{
    int t=tr[k].r;
    tr[k].r=tr[t].l;
    tr[t].l=k;
    k=t;
}

void insert(int &k,int x,int xo)
{
    if(k==0)
    {
        size++;///记录已经使用的结构体数目；
        k=size;
        tr[k].v=x;
        tr[k].vo=xo;
        tr[k].rnd=rand();
        return;
    }
    if(x>tr[k].v)
    {
        insert(tr[k].r,x,xo);
        if(tr[tr[k].r].rnd<tr[k].rnd)
            lturn(k);
    }
    else
    {
        insert(tr[k].l,x,xo);
        if(tr[tr[k].l].rnd<tr[k].rnd)
            rturn(k);
    }
}

void query_pro(int k,int x)///求x的前驱(前驱定义为小于x，且最大的数);
{
    if(k==0)return;
    if(tr[k].v<x)
    {
        ans1=k;
        query_pro(tr[k].r,x);
    }
    else query_pro(tr[k].l,x);
}

void query_sub(int k,int x)///求x的后继(后继定义为大于x，且最小的数);
{
    if(k==0)return;
    if(tr[k].v>x)
    {
        ans2=k;
        query_sub(tr[k].l,x);
    }
    else query_sub(tr[k].r,x);
}

int main()
{
    int n,xo,x;
    while(scanf("%d",&n)!=EOF&&n)
    {
        root=0;
        size=0;
        for(int i=0;i<110000;i++)
        {
            tr[i].l=0;
            tr[i].r=0;
            tr[i].v=0;
            tr[i].vo=0;
            tr[i].rnd=0;
        }
        insert(root,1000000000,1);
        while(n--)
        {
            scanf("%d %d",&xo,&x);
            insert(root,x,xo);
            ans1=0;
            ans2=0;
            query_pro(root,x);
            query_sub(root,x);
            if(ans1==0) printf("%d %d\n",xo,tr[ans2].vo);\
            else
            {
                if(x-tr[ans1].v<=tr[ans2].v-x)
                    printf("%d %d\n",xo,tr[ans1].vo);
                else  printf("%d %d\n",xo,tr[ans2].vo);
            }
        }
    }
    return 0;
}