是否同一棵二叉搜索树

04-树4 是否同一棵二叉搜索树（25 分）
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。

输入格式:
输入包含若干组测试数据。每组数据的第1行给出两个正整数N (≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行，每行给出N个插入的元素，属于L个需要检查的序列。

简单起见，我们保证每个插入序列都是1到N的一个排列。当读到N为0时，标志输入结束，这组数据不要处理。

输出格式:
对每一组需要检查的序列，如果其生成的二叉搜索树跟对应的初始序列生成的一样，输出“Yes”，否则输出“No”。

输入样例:
4 2
3 1 4 2
3 4 1 2
3 2 4 1
2 1
2 1
1 2
0
输出样例:
Yes
No
No

#include<iostream>
using namespace std;

struct Tree{
    int ele;                        // 值
    Tree *left;
    Tree *right;
    int mark;                       //在newnode中被初始化为0，被访问过后标记为1
};

Tree *NewNode(int V){               //创建新的Tree节点
    Tree *T = new Tree;             //new内存，new的内存记得释放
    T->ele = V;                     //写入元素
    T->left = T->right = NULL;      //左右儿子标记为NULL
    T->mark = 0;                    //mark初始化
    return T;                       //返回地址
}

Tree *Insert(Tree* T,int V){        //二叉搜索树节点的插入
    if(!T)              //T为NULL，代表递归找到了正确的地址，此处新建V为值的节点，结束递归
        T = NewNode(V);
    else{
        if (V>T->ele)
            T->right = Insert(T->right,V);//大于根节点的值则往右递归
        else
            T->left = Insert(T->left,V);
    }
    return T;                       //返回成熟期的T地址
}

Tree *Tree_creat(int N){            //创建被比较的树
    Tree *T;
    int i,V;
    cin >> V;                       //输入根节点的element
    T=NewNode(V);                   //新建V为值的Tree节点
    for(i=1;i<N;i++){               //循环插入后续V
        cin >> V;
        T = Insert(T,V);            //找合适位置构建二叉搜索树
    }
    return T;                       //返回完全体的T地址
}

int check(Tree *T, int V){          //逐个节点为单位check
    if (T->mark){                   //mark为1，代表mark已经被问候过了
        if (V<T->ele)               //值小于根值，递归check左边节点
            return check(T->left,V);
        else if(V>T->ele)
            return check(T->right,V);
        else                        //值等于数被访问过的根值，代表有重复值
            return 0;
    }
    else{                           //此根没被发现过
        if(V==T->ele){              //相等
            T->mark=1;              //标记代表访问过了
            return 1;               //check结果是相等
        }
        else                        //不等
            return 0;
    }
        
}

int Judge(Tree* T,int n){           //整棵树为单位的judge
    int i,V,flag=0;                 //这里flag的存在是为了保证接受所有cin的数
    cin >> V;
    if(V!=T->ele)                   //根值是否相等
        flag = 1;
    else
        T->mark = 1;
    for(i=1;i<n;i++){               //收进来后面n-1个数
        cin >> V;
        if((!check(T,V)) and (!flag))//flag目前截止都是0 并且 发现了一例不等的check
            flag = 1;
    }
    if(flag)                        //最终flag保持为0不边才输出1，代表最终为yes
        return 0;
    else
        return 1;
}

void Tree_reset(Tree * T){          //reset mark值
    if (T->left)                    //T左不为NULL
        Tree_reset(T->left);
    if (T->right)
        Tree_reset(T->right);
    T->mark = 0;                    //mark标记为0
}

void Tree_free(Tree * T){           //delete所有new出来的node
    if(T->left)
        Tree_free(T->left);
    if(T->right)
        Tree_free(T->right);
    delete T;
}

int main(){
    int n,l;
    cin >> n;                       //首次输入n，不为0则循环
    while(n){
        cin >> l;                   // 要对比的树的数量
        Tree *org = Tree_creat(n);  //创建被比较树
        for(int i=0;i<l;i++){       //”l“次比较次数
            if(Judge(org,n))        //返回是否相同
                cout << "Yes" << endl;
            else
                cout << "No" << endl;
            Tree_reset(org);        //将所有节点的 mark reset为0
        }
        Tree_free(org);             //释放new的Tree节点
        cin >> n;                   //下一个n，为0则结束
    }
    return 0;
}