PTA 7-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;
#include <vector>
class node{
    public:
        node(const int& el = 0,node* l=nullptr, node* r=nullptr){
            elem = el;
            left = l;
            right = r;
        }
        int elem;
        node* left;
        node* right;
};
int isSame(node* tree1, node* tree2);

class Bintree{
    public:
        Bintree(){
            root = nullptr;
        }
        void InitTree(int);
        void insert(int);
        void predorder(vector<int>& ans);
        void preordertra(vector<int>& ans, node*);
        node* root;
};


void Bintree::InitTree(int N){
    int num;
    for(int i=0;i<N;i++){
        cin>>num;
        insert(num);
    }
}

void Bintree::insert(int data){
    if(root==nullptr)
        root = new node(data);
    else{
        node *p = root;
        node *pre;
        while(true){
            if(p==nullptr){
                break;
            }
            pre = p;
            if(data > p->elem)
                p = p->right;
            else if(data < p->elem)
                p = p->left;
        }
        if(data > pre->elem)
            pre->right = new node(data);
        else
            pre->left = new node(data);
    }
}

void Bintree::predorder(vector<int>& ans){
    node *p = root;
    ans.push_back(p->elem);
    preordertra(ans, p->left);
    preordertra(ans, p->right);
}

void Bintree::preordertra(vector<int>& ans,node* p){
    if(p==nullptr)
        return;
    ans.push_back(p->elem);
    preordertra(ans, p->left);
    preordertra(ans, p->right);
}

int isSame(node* tree1, node* tree2){
    if(tree1==NULL&tree2==NULL)
        return 1;
    if((tree1==NULL && tree2!=NULL)||(tree1!=NULL&&tree2==NULL)||(tree1->elem!=tree2->elem))
        return 0;
    else
        return (isSame(tree1->left,tree2->left)&&isSame(tree1->right,tree2->right));
}

int main(){
    int N,L;
    while(true){
        cin>>N>>L;
        if(N==0)
            break;
        Bintree tree1;
        tree1.InitTree(N);
        for(int i=0;i<L;i++){
            Bintree tree2;
            tree2.InitTree(N);
            if(isSame(tree1.root, tree2.root)==1)
                cout<<"Yes"<<endl;
            else 
                cout<<"No"<<endl;
        }
    }
    return 0;
}

标签：node,25,int,tree1,elem,PTA,二叉,ans,tree2
来源： https://www.cnblogs.com/chrisng/p/15505648.html