PAT L2-004 这是二叉搜索树吗？

L2-004. 这是二叉搜索树吗？

时间限制: 400 ms
内存限制: 65536 kB
代码长度限制: 8000 B
判题程序: Standard
作者: 陈越

一棵二叉搜索树可被递归地定义为具有下列性质的二叉树：对于任一结点，

其左子树中所有结点的键值小于该结点的键值；
其右子树中所有结点的键值大于等于该结点的键值；
其左右子树都是二叉搜索树。 

所谓二叉搜索树的“镜像”，即将所有结点的左右子树对换位置后所得到的树。

给定一个整数键值序列，现请你编写程序，判断这是否是对一棵二叉搜索树或其镜像进行前序遍历的结果。

输入格式：

输入的第一行给出正整数N（<=1000）。随后一行给出N个整数键值，其间以空格分隔。

输出格式：

如果输入序列是对一棵二叉搜索树或其镜像进行前序遍历的结果，则首先在一行中输出“YES”，然后在下一行输出该树后序遍历的结果。数字间有1个空格，一行的首尾不得有多余空格。若答案是否，则输出“NO”。

输入样例1：

7
8 6 5 7 10 8 11

输出样例1：

YES
5 7 6 8 11 10 8

输入样例2：

7
8 10 11 8 6 7 5

输出样例2：

YES
11 8 10 7 5 6 8

输入样例3：

7
8 6 8 5 10 9 11

输出样例3：

NO

问题分析

解题步骤：根据输入序列建立一颗二叉搜索树，跑一遍前序遍历，看是否相同；建一颗二叉搜索树的镜像，跑一遍前序遍历，看是否相同。最后如果满足两者之一，输出YES，跑一遍后序遍历，否则输出NO。
ok，上AC code咯~（^_^）

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e3+1;
typedef struct node{
    node *left;
    node *right;
    int v;
    node(){left = right = NULL;}
} Node;
int num[N],n,c = 0,ok = 0;

void build(Node *a,int v) //建二叉搜索树
{
    if(a->v>v) //二叉搜索树左子树的所有结点键值都小于该结点值
    {
        if(a->left==NULL)
        {
            a->left = new node();
            a->left->v = v;
        }else
        {
            build(a->left,v);
        }
    }else //右子树所有结点键值大于等于该结点键值
    {
        if(a->right==NULL)
        {
            a->right = new node();
            a->right->v = v;
        }else
        {
            build(a->right,v);
        }
    }
}

void rev(Node *a,int v) //镜像（左子树右子树交换位置）
{
    if(a->v<=v) //镜像恰好相反，左子树就相当于二叉搜索树的右子树，所有结点大于等于该结点值
    {
        if(a->left==NULL)
        {
            a->left = new Node();
            a->left->v = v;
        }else
        {
            rev(a->left,v);
        }
    }else //右子树
    {
        if(a->right==NULL)
        {
            a->right = new Node();
            a->right->v = v;
        }else
        {
            rev(a->right,v);
        }
    }
}

void judge(Node *p) //前序遍历
{
    if(p->v!=num[c++]){
        ok = 1;
        return;
    }else
    {
        if(p->left)
        {
            judge(p->left);
            if(ok) return;
        }else if(p->right)
        {
            judge(p->right);
            if(ok) return;
        }
    }
}

void dfs(Node *p) //后序遍历
{
    if(p==NULL) return;
    dfs(p->left);  //左子树
    dfs(p->right);  //右子树
    if(ok)
    {
        cout<<p->v;
        ok = 0;
    }else
    {
        cout<<' '<<p->v;
    }
}

int main()
{
    cin>>n;
    for(int i = 0; i < n; ++i)
        cin>>num[i];
    Node *head = new Node();
    head->v = num[0];
    //建二叉搜索树
    for(int i = 1; i < n; ++i)
        build(head,num[i]);
    judge(head);//判断输入序列是否是二叉搜索树前序遍历的结果
    if(ok==0)
    {
        cout<<"YES\n";
        ok = 1;
        dfs(head);
        puts("");
    }else
    {
        ok = 0;
        head = new Node();
        head->v = num[0];
        //建镜像
        for(int i = 1; i < n; ++i)
            rev(head,num[i]);
        c = 0;
        judge(head); //判断输入序列是否是镜像前序遍历的结果
        if(ok==0)
        {
            cout<<"YES\n";
            ok = 1;
            dfs(head);
            puts("");
        }else
        {
            cout<<"NO\n";
        }

    }
    return 0;
}