4.1是否同一棵二叉搜索树

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

1-分别建两棵搜索树的判别方法

/*1-分别建两棵搜索树的判别方法*/
#include<cstdio>
#include<cstdlib>
/*1.1-树的表示*/
typedef struct TreeNode *Node;
struct TreeNode
{
  int val;
  Node Left,Right;
};
/*1.2-建树*/
Node MakeTree(int);
/*新建结点*/
Node InsertNode(Node,int);
Node NewNode(int);
/*判断两树是否相同*/
int Judge(Node,Node);
/*释放树*/
void FreeTree(Node);
int main()
{
  
/**/
  int n;//n-树结点的个数
  int l;//l-树的个数
  Node t;//t-树根结点
  Node temp;//temp-待比较树的根结点
  scanf("%d",&n);
  while(n)
  {
    scanf("%d",&l);
    t=MakeTree(n);
    /*l为比较数组个数*/
    for(int i=0;i<l;i++)
    {
      temp=MakeTree(n);
      if(Judge(t,temp)) printf("Yes\n");
      else printf("No\n");
      FreeTree(temp);
    }
    FreeTree(t);
    scanf("%d",&n);
  }
  return 0;
 }

/*1.2-建树*/
Node MakeTree(int n)
{
  int v;
  Node t;
  scanf("%d",&v);
  /*t未初始化头节点*/
  t=NewNode(v);
  for (int i = 1; i < n; i++)
  {
    scanf("%d",&v);
   t=InsertNode(t,v);
  } 
  return t;
}
/*产生新结点*/
Node NewNode(int v)
{
  Node t;
  t=(Node)malloc(sizeof(TreeNode));
  t->val=v;
  t->Left=t->Right=NULL;
  return t;
}

Node InsertNode(Node t,int v)
{
  if(!t) t=NewNode(v);
  else 
  {
    if(v<t->val) t->Left=InsertNode(t->Left,v);
    else if(v>t->val) t->Right=InsertNode(t->Right,v);
  }
  return t;
}
/*判断两树是否相同*/
int Judge(Node t,Node m)
{
  Node a,b;
  a=t,b=m;
  /*结点同为空*/
  if(a==NULL&&b==NULL)
  {
    return 1;
  }
  if(a!=NULL&&b!=NULL)
  {
    /*结点同不为空，子树相等*/
    if(a->val==b->val)
    {
      if(Judge(a->Left,b->Left)&&Judge(a->Right,b->Right))
      return 1;
    }
  }
  return 0;
}
/*释放树*/
void FreeTree(Node t)
{
  if(t->Left) FreeTree(t->Left);
  if(t->Right) FreeTree(t->Right);
  free(t);
}

2-不建树的判别方法

/*2-不建树判断方法*/
#include<vector>
#include<iostream>
using namespace std;
vector<int> MakeVector(int n)
{
  int v;
  vector<int> a;
  for(int i=0;i<n;i++)
  {
    cin>>v;
    a.push_back(v);
  }
  return a;
}
bool Judge(vector<int>a,vector<int>b)
{
  /*同为空结点*/
  if(a.empty()&&b.empty()) return true;
  /*同不为空，相等，无子树*/
  if(a.size()==1&&b.size()==1)
  {
    if(a[0]==b[0])
    return true;
  }
  /*同不为空，相等，有子树*/
  if(a.size()==b.size()&&a.size()>1)
  {
    if(a[0]==b[0])
    {
    vector<int>alsub,arsub,blsub,brsub;
      /*a分割*/
      for(int i=1;i<a.size();i++)
      {
        if(a[i]>a[0]) arsub.push_back(a[i]);
        else if(a[i]<a[0]) alsub.push_back(a[i]);
      }
      /*b分割*/
      for(int i=1;i<b.size();i++)
      {
        if(b[i]>b[0]) brsub.push_back(b[i]);
        else if(b[i]<b[0]) blsub.push_back(b[i]);
      }
      if(Judge(alsub,blsub)&&Judge(arsub,brsub)) return true; 
    }  
  }
  return false;
}
 int main()
 {
   vector<int> a,vtemp;
   int l,n;
   cin>>l;
   while(l)
   {
     cin>>n;
    /*输入标准序列*/
    a=MakeVector(l);
    for(int i=0;i<n;i++)
    {
      /*输入带测序列*/
      vtemp=MakeVector(l);
      /*比较*/
      if(Judge(a,vtemp)) cout<<"Yes"<<endl;
      else
      {
        cout<<"No"<<endl;
      }
      vtemp.clear();
    }
     a.clear();
     cin>>l;
   }
 }

3 建一棵树，再判别其他序列是否与该树一致

#include <iostream>
/*3.1-搜索树表示*/
typedef struct treeNode
{
  int v;
  treeNode *Left,*Right;
  int flag=0;/*flag-0visited*/
}treeNode;
treeNode* MakeTree(int);
bool Judge(treeNode*,int );
void ResetT(treeNode*);
void FreeTree(treeNode*);
treeNode* NewNode(int);
treeNode* Insert(treeNode*,int);
bool check(treeNode*,int);
int main() 
{
  int n,l;
  treeNode *t;
  scanf("%d",&n);
  while (n)
  {
    scanf("%d",&l);
    /*3.2-建搜索树T*/
    t=MakeTree(n);
    for(int i=0;i<l;i++)
    {
     /*3.3-判别一序列是否与搜索树T一致*/
      if(Judge(t,n))printf("Yes\n");
      else printf("No\n");
      ResetT(t);
    }
    FreeTree(t);
    scanf("%d",&n);
  }
  return 0;
}
treeNode* MakeTree(int n)
{
  treeNode *t;
  int i,v;
  scanf("%d",&v);
  t=NewNode(v);
  for(i=1;i<n;i++)
  {
    scanf("%d",&v);
    t=Insert(t,v);
  }
  return t;
}
treeNode * NewNode(int v)
{
  treeNode *t=(treeNode*)malloc(sizeof(struct treeNode));
  t->v=v;
  t->Left=t->Right=NULL;
  t->flag=0;
  return t;
}
treeNode* Insert(treeNode* t,int v)
{
  if(!t) t=NewNode(v);
  else
  {
    if(v>t->v)
    t->Right=Insert(t->Right,v);
    else if(v<t->v)
    {
      t->Left=Insert(t->Left,v);
    }
  }
  return t;
}
bool Judge(treeNode *t,int N )
{
  /*在树中顺序搜索序列的每个数
  如果每次搜索所经过的结点在前面均出现过
  ，则一致，否则，不一致*/
  int value;
  bool flag=true;
  scanf("%d",&value);
  if(value!=t->v) flag=false;
  else t->flag=1;
  for(int i=1;i<N;i++)
  {
    scanf("%d",&value);
    if(flag&&!check(t,value)) flag=false;
  }
  return flag?true:false;
}
bool check(treeNode *t,int value)
{
  if(t->flag)
  {
    if(value<t->v) return check(t->Left,value);
    else if(value>t->v) return check(t->Right,value);
    else return false;
  }
  else
  {
    if(t->v==value) 
    {
      t->flag=1;
      return true;
    }
    else
    {
      return false;
    }
  }
}
/*清除树中的标记*/
void ResetT(treeNode* t)
{
  if(t->Left) ResetT(t->Left);
  if(t->Right) ResetT(t->Right);
  t->flag=0;
}
void FreeTree(treeNode*t)
{
  if(t->Left) FreeTree(t->Left);
  if(t->Right) FreeTree(t->Right);
  free(t);
}