AOJ-747-镜像树

镜像树

Time Limit: 1000 ms Memory Limit: 64 MB
Description

一棵二叉树，若其与自己的镜像完全相同，就称其为镜像树（即这棵二叉树关于根完全对称）。例如
1
/
2 2
/ /
3 4 4 3
是一棵镜像树；
而
1
/
2 2

3 3
不是镜像树。
现给你一棵二叉树，请你判断其是不是镜像树。

Input

第一行是一个整数数T，表示测试数据有多少组
每组数据第一行是一个正整数n(1<=n<=100)，表示二叉树中节点的数量
下面n行，每行有三个正整数a b c(1<=a<=100,0<=b,c<=100)，表示以编号a的节点为父节点，它的左孩子节点编号为b，右孩子节点编号为c，若b=0表示没有左孩子节点，c=0表示没有右孩子节点，树的根节点是编号为1的节点，节点的编号都>=1（保证数据中给出的二叉树拓扑结构是合法的）
下面一行是n个正整数vi(1<=vi<=100)，表示编号为i的节点的值。

Output

若数据中表示的二叉树是镜像树，输出“Yes”，否则输出“No”，每个输出单独占一行

Sample Input

2
7
1 2 3
2 4 5
3 6 7
4 0 0
5 0 0
6 0 0
7 0 0
1 2 2 3 4 4 3
5
1 2 3
2 0 4
3 0 5
4 0 0
5 0 0
1 2 2 3 3

Sample Output

Yes
No

一道简单模拟题，因为数据不是很大，可以直接使用构造二叉树的方式来解决。采用中序遍历的方式来遍历二叉树来获取树的每个节点的数值。并用一个数组来保存，从数组的第一个元素开始，与数组的第n-1位（即二叉树所含有的所有节点-1）来判断。值得一提的是，采用这个方式的话，应当把二叉树的所有非空节点的左右孩子全部赋值。即如
1
/
2 2

3 3
这个二叉树，就应当变为
1
/
2 2
/ /
0 3 0 3
这样才可以得到正确答案

#include <stdio.h>
#include <malloc.h>
#include <string.h>
typedef struct node
{
    int seq;
    int num;
    node *left;
    node *right;
}Tree;
int a[200] = {0};
void Insert(int a,int b,int c, Tree *root)
{
    if(root == NULL)
        return;
    if(root -> seq == a)
    {
        if(b ==0 && c == 0) return;

        Tree *p = (Tree *)malloc(sizeof(node));
        root -> left = p;
        p -> seq = b;
        p -> left = NULL;
        p -> right = NULL;
        if(b == 0) p -> num = 0;

        Tree *q = (Tree *)malloc(sizeof(node));
        root -> right = q;
        q -> seq = c;
        q -> left = NULL;
        q -> right = NULL;
        if(c == 0) p -> num = 0;
    }
    else
    {
        Insert(a,b,c,root -> left);
        Insert(a,b,c,root -> right);
    }
}
void Num(int n,int des,Tree *root)
{
    if(root == NULL) return;

    if(root -> seq == des)
        root -> num = n;
    else
    {
        Num(n,des,root -> left);
        Num(n,des,root -> right);
    }
}
int cont = 0;
void MidSearch(Tree *root)
{
    if(root -> left != NULL)
        MidSearch(root -> left);
    a[cont++] = root -> num;
    if(root -> right != NULL)
        MidSearch(root -> right);
}
int main()
{
    int n,i,j,_case;
    scanf("%d",&_case);
    while(_case--)
    {
        Tree *root = (Tree *)malloc(sizeof(node));
        root -> seq = 1;
        root -> left = NULL;
        root -> right = NULL;

        scanf("%d",&n);
        for(i = 0; i < n; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);

            Insert(a,b,c,root);
        }
        for(i = 0; i < n; i++)
        {
            int num;
            scanf("%d",&num);

            Num(num,i+1,root);
        }
        cont = 0;
        MidSearch(root);

        for(i = 0,j = cont - 1; i != j; i++,j--)
        {
            if(a[i] != a[j])
            {
                printf("No
");
                break;
            }
        }
        if(i == j)
            printf("Yes
");
    }
    return 0;
}

本人技术有限，如果有疏漏，希望各位大牛指正