hdu 3999 二叉排序树

思考了一会，yy出了一个结论：

很显然，对于任意一颗子树中的所有节点来说，根节点必须是第一个插入的，根节点插入以后，这颗子树的其他所有节点会分成两拨，

大于根节点权值的和小于根节点权值的，这两部分不会互相影响，可以转化成新的两个更小的子树的构造过程。

而在构造过程中要想不破坏原来的bst的结构，就必须满足：

任意节点的插入不会比它的祖先更早，否则就会是一颗不一样的bst了。

若不理解请回忆bst的插入过程。

于是乎发现：要想满足这个规律只要做先根遍历即可，而要使字典序最小，只要先序遍历就是答案。

#include <iostream>
#include <cstdio>
using namespace std;

int n, cnt;

struct Node 
{
    Node * ch[2];
    int v;
    bool cmp( int x )
    {
        if ( x == v ) return -1;
        return x < v ? 0 : 1;
    }
};

Node * root;

void insert( Node * & o, int x )
{
    if ( o == NULL )
    {
        o = new Node ();
        o->ch[0] = o->ch[1] = NULL;
        o->v = x;
        return ;
    }
    int d = o->cmp(x);
    if ( d == -1 ) return ;
    insert( o->ch[d], x );
}

/*
Node * find( Node * o, int x )
{
    if ( o == NULL ) return NULL;        
    int d = o->cmp(x);
    if ( d == -1 ) return o;        
    return find( o->ch[d], x );
}

void remove( Node * & o, int x )
{
    if ( o == NULL ) return ;
    int d = o->cmp(x);
    if ( d == -1 )
    {
        if ( o->ch[0] == NULL )
        {
            Node * tmp = o;
            o = o->ch[1];
            delete tmp;
        }
        else if ( o->ch[1] == NULL )
        {
            Node * tmp = o;
            o = o->ch[0];
            delete tmp;
        }
        else
        {
            Node * p = o, * q = o->ch[0];
            while ( q->ch[1] != NULL )
            {
                p = q;
                q = q->ch[1];
            }
            o->v = q->v;
            if ( p != o )
            {
                p->ch[1] = q->ch[0];
                delete q;
            }
            else
            {
                p->ch[0] = q->ch[0];
                delete q;
            }
        }
    }
    else
    {
        remove( o->ch[d], x );
    }
}
*/

void free( Node * o )
{
    if ( o != NULL )
    {
        free(o->ch[0]);
        free(o->ch[1]);
        delete o;
    }
}

void visit( Node * o )
{
    cnt++;
    printf("%d", o->v);
    if ( cnt != n ) putchar(' ');
    else putchar('
');    
}

void preorder( Node * o )
{
    if ( o )
    {
        visit(o);
        preorder(o->ch[0]);
        preorder(o->ch[1]);
    }
}

/*
void inorder( Node * o )
{
    if ( o )
    {
        inorder(o->ch[0]);
        visit(o);
        inorder(o->ch[1]);
    }
}

void postorder( Node * o )
{
    if ( o )
    {
        postorder(o->ch[0]);
        postorder(o->ch[1]);
        visit(o);
    }
}
*/

int main ()
{
    while ( scanf("%d", &n) != EOF )
    {
        root = NULL;
        cnt = 0;
        for ( int i = 0; i < n; i++ )
        {
            int tmp;
            scanf("%d", &tmp);
            insert( root, tmp );
        }
        preorder(root);
        free(root);        
    }
    return 0;
}