035树的子结构(keep it up)

剑指offer中题目：http://ac.jobdu.com/problem.php?pid=1520

题目描述：

输入两颗二叉树A，B，判断B是不是A的子结构。

输入：

输入可能包含多个测试样例，输入以EOF结束。
对于每个测试案例，输入的第一行一个整数n,m(1<=n<=1000,1<=m<=1000)：n代表将要输入的二叉树A的节点个数（节点从1开始计数），m代表将要输入的二叉树B的节点个数（节点从1开始计数）。接下来一行有n个数，每个数代表A树中第i个元素的数值，接下来有n行，第一个数Ki代表第i个节点的子孩子个数，接下来有Ki个树，代表节点i子孩子节点标号。接下来m+1行，与树A描述相同。

输出：

对应每个测试案例，
若B是A的子树输出”YES”(不包含引号)。否则，输出“NO”（不包含引号）。

样例输入：

7 3
8 8 7 9 2 4 7
2 2 3
2 4 5
0
0
2 6 7
0
0
8 9 2
2 2 3
0
0

1 1
2
0
3
0

样例输出：

YES
NO

提示：

B为空树时不是任何树的子树。

代码：

#include <stdio.h>
#include <stdlib.h>
#include <queue>
 
#define MAXDATA 0X7FFFFFFF
#define MAXSIZE 1001
 
int TreeData[MAXSIZE];
 
typedef struct SNode
{
    int data;
    int left;
    int right;
}SNode;
 
SNode* createNode(int vData)
{
    SNode *Node = (SNode*)malloc(sizeof(SNode));
    Node->data  = vData;
    Node->left  = -1;
    Node->right = -1;
    return Node;
}
 
void deleteNode(SNode **vNode)
{
    (*vNode)->left  = -1;
    (*vNode)->right = -1;
    free(*vNode);
    *vNode = NULL;
}
 
void allocNode(SNode *vArray[], int vSize)
{
    int i;
    for (i = 1; i <= vSize; ++i)
    {
        vArray[i] = createNode(MAXDATA);
    }
}
 
void deleteTree(SNode *vTree[], int vSize)
{
    int i;
    for (i=1; i <= vSize; ++i)
    {
        deleteNode(&(vTree[i]));
    }
}
 
void clearTree(SNode *vTree[], int vSize)
{
    int i;
    for (i=1; i <= vSize; ++i)
    {
        vTree[i]->data  = MAXDATA;
        vTree[i]->left  = -1;
        vTree[i]->right = -1;
    }
}
 
void createBinaryTree(SNode *vNode[], int vN)
{
    int    i;
    int    NumChld;
 
    for (i = 1; i <= vN; ++i)
    {
        scanf("%d", &(vNode[i]->data));
    }
 
    for (i = 1; i <= vN; ++i)
    {
        scanf("%d", &NumChld);
        if (NumChld == 0) continue;
        else if (NumChld == 1)
        {
            scanf("%d", &(vNode[i]->left));
        }
        else if (NumChld == 2)
        {
            scanf("%d %d", &(vNode[i]->left), &(vNode[i]->right));
        }
    }
}
 
int judgeSubRoot(int vRootBegin, SNode *vTreeRoot[], int vSubBegin, SNode *vSubRoot[])
{
    int LeftFlag;
    int RightFlag;
     
    if (vSubBegin == -1)  return 1;
    if (vRootBegin == -1) return 0;
 
    if (vTreeRoot[vRootBegin]->data == vSubRoot[vSubBegin]->data) 
    {
        LeftFlag = judgeSubRoot(vTreeRoot[vRootBegin]->left, vTreeRoot, vSubRoot[vSubBegin]->left, vSubRoot);
        if (!LeftFlag) return 0;
        RightFlag = judgeSubRoot(vTreeRoot[vRootBegin]->right, vTreeRoot, vSubRoot[vSubBegin]->right, vSubRoot);
        if (!RightFlag) return 0;
        return 1;
    }
    else return 0;
}
 
int isSubTree(SNode *vTreeRoot[], SNode *vSubRoot[])
{
    if (vSubRoot[1]->data == MAXDATA || vTreeRoot[1]->data == MAXDATA) return 0;
 
    std::queue<int> Que;
    int Index;
    int Flag;
 
    Que.push(1);
    while(!Que.empty())
    {
        Index = Que.front();
        Que.pop();
 
        if (vTreeRoot[Index]->data == vSubRoot[1]->data)
        {
            Flag = judgeSubRoot(Index, vTreeRoot, 1, vSubRoot);
            if (Flag) return 1;
        }
 
        if (vTreeRoot[Index]->left != -1)  Que.push(vTreeRoot[Index]->left);
        if (vTreeRoot[Index]->right != -1) Que.push(vTreeRoot[Index]->right);
    }
 
    return 0;
}
 
int main()
{
    int M;
    int N;
    SNode *TreeRoot[MAXSIZE];
    SNode *SubRoot[MAXSIZE];
 
    allocNode(TreeRoot, MAXSIZE-1);
    allocNode(SubRoot, MAXSIZE-1);
 
    while (scanf("%d %d", &N, &M) != EOF)
    {
        createBinaryTree(TreeRoot, N);
        createBinaryTree(SubRoot, M);
 
        if (isSubTree(TreeRoot, SubRoot))
        {
            printf("YES\n");
        }
        else
        {
            printf("NO\n");
        }
 
        clearTree(TreeRoot, MAXSIZE-1);
        clearTree(SubRoot, MAXSIZE-1);
    }
 
    deleteTree(TreeRoot, MAXSIZE-1);
    deleteTree(SubRoot, MAXSIZE-1);
 
    return 0;
}
/**************************************************************
    Problem: 1520
    User: 
    Language: C++
    Result: Accepted
    Time:10 ms
    Memory:1056 kb
****************************************************************/