5-4 搜索树判断 (25分)

5-4 搜索树判断   (25分)

对于二叉搜索树，我们规定任一结点的左子树仅包含严格小于该结点的键值，而其右子树包含大于或等于该结点的键值。如果我们交换每个节点的左子树和右子树，得到的树叫做镜像二叉搜索树。

现在我们给出一个整数键值序列，请编写程序判断该序列是否为某棵二叉搜索树或某镜像二叉搜索树的前序遍历序列，如果是，则输出对应二叉树的后序遍历序列。

输入格式:

输入的第一行包含一个正整数N（$\le$1000），第二行包含N个整数，为给出的整数键值序列，数字间以空格分隔。

输出格式:

输出的第一行首先给出判断结果，如果输入的序列是某棵二叉搜索树或某镜像二叉搜索树的前序遍历序列，则输出YES，否侧输出NO。如果判断结果是YES，下一行输出对应二叉树的后序遍历序列。数字间以空格分隔，但行尾不能有多余的空格。

输入样例1:

7
8 6 5 7 10 8 11

输出样例1:

YES
5 7 6 8 11 10 8

输入样例2:

7
8 6 8 5 10 9 11

输出样例2:

NO

纯C代码~~~敬请享用；

就是镜像的话先序遍历就是根右左，后序遍历就是右左根；

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct BST* bstree;

int temp[1010],temp_num,n;

struct BST{
    int Weight;
    bstree left;
    bstree right;
}BST;


void Insert(bstree T,int data)
{
    if(T->Weight>data)
    {
        if(T->left==NULL)
        {
            bstree P=(bstree)malloc(sizeof(BST));
            P->left=NULL;
            P->right=NULL;
            P->Weight=data;
            T->left=P;
        }
        else
            Insert(T->left,data);
    }
    else
    {
        if(T->right==NULL)
        {
            bstree P=(bstree)malloc(sizeof(BST));
            P->left=NULL;
            P->right=NULL;
            P->Weight=data;
            T->right=P;
        }
        else
            Insert(T->right,data);
    }
}

int aa[1010];
int num_a;
void xianxu(bstree T)
{
    if(T!=NULL)
    {
        aa[num_a++]=T->Weight;
        xianxu(T->left);
        xianxu(T->right);
    }
}

int bb[1010];
int num_b;
void houxu(bstree T)
{
    if(T!=NULL)
    {
        bb[num_b++]=T->Weight;
        houxu(T->right);
        houxu(T->left);
    }
}

int cc[1010];
int num_c;
void houxu_ans(bstree T)
{
    if(T!=NULL)
    {
        houxu_ans(T->left);
        houxu_ans(T->right);
        cc[num_c++]=T->Weight;
    }
}

void huoxu_ans_2(bstree T)
{
    if(T!=NULL)
    {
        huoxu_ans_2(T->right);
        huoxu_ans_2(T->left);
        cc[num_c++]=T->Weight;
    }
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&temp[i]);

    bstree root;
    root=(bstree)malloc(sizeof(BST));
    root->left=NULL;
    root->right=NULL;
    root->Weight=temp[1];

    for(int i=2;i<=n;i++)
        Insert(root,temp[i]);
    num_a=num_b=0;
    xianxu(root);
    houxu(root);

    int flag=1;
    for(int i=0;i<num_a;i++)
    {
        if(temp[i+1]!=aa[i])
        {
            flag=0;
            break;
        }
    }
    if(flag)
    {
        puts("YES");
        num_c=0;
        houxu_ans(root);
        for(int i=0;i<num_c;i++)
        {
            if(i) printf(" ");
            printf("%d",cc[i]);
        }
        return 0;
    }
    flag=1;
    for(int i=0;i<num_b;i++)
    {
        if(temp[i+1]!=bb[i])
        {
            flag=0;
            break;
        }
    }
    if(flag)
    {
        puts("YES");
        num_c=0;
        huoxu_ans_2(root);
        for(int i=0;i<num_c;i++)
        {
            if(i) printf(" ");
            printf("%d",cc[i]);
        }
        return 0;
    }
    puts("NO");
    return 0;
}