PTA L2-004 这是二叉搜索树吗？-判断是否是对一棵二叉搜索树或其镜像进行前序遍历的结果 团体程序设计天梯赛-练习集

L2-004 这是二叉搜索树吗？ （25 分)

 

一棵二叉搜索树可被递归地定义为具有下列性质的二叉树：对于任一结点，

• 其左子树中所有结点的键值小于该结点的键值；
• 其右子树中所有结点的键值大于等于该结点的键值；
• 其左右子树都是二叉搜索树。

所谓二叉搜索树的“镜像”，即将所有结点的左右子树对换位置后所得到的树。

给定一个整数键值序列，现请你编写程序，判断这是否是对一棵二叉搜索树或其镜像进行前序遍历的结果。

输入格式：

输入的第一行给出正整数 N（≤）。随后一行给出 N 个整数键值，其间以空格分隔。

输出格式：

如果输入序列是对一棵二叉搜索树或其镜像进行前序遍历的结果，则首先在一行中输出 YES ，然后在下一行输出该树后序遍历的结果。数字间有 1 个空格，一行的首尾不得有多余空格。若答案是否，则输出 NO。

输入样例 1：

7
8 6 5 7 10 8 11

输出样例 1：

YES
5 7 6 8 11 10 8

输入样例 2：

7
8 10 11 8 6 7 5

输出样例 2：

YES
11 8 10 7 5 6 8

输入样例 3：

7
8 6 8 5 10 9 11

输出样例 3：

NO

因为前面写了二叉树的，所以这道题打算也用那种思路，写是写出来了，但是感觉怪怪的。

我建树是保存的下标编号，因为数可能是一样的，但是下标编号是唯一的。

建完树之后，写了个bfs搜了一下左右节点，发现好像也没毛病，但是自己想的一个样例过不了，肯定是错的代码，应该是后台样例比较水，所以满分水过了。。。

代码写的奇丑无比，但是还是希望有好心人能帮我想想我的代码哪里要改才能改对，过不了的样例：

2

2 1

输出应该为

YES

1 2

我的代码跑不出来。

后面看了一下别人的题解，发现还是别人的思路更简洁好实现一些，学到了，我这个弟弟。

先贴一下我的代码，不要学我的代码，有bug的，找不出来什么问题。。。

代码:

 //L2-004 这是二叉搜索树吗？
 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int maxn=1e5+;
 const int inf=0x3f3f3f3f;

 int pre[maxn];
 int n,flag=;

 struct node{
     int l,r;
 }tree[maxn];

 int buildmin(int l,int r)
 {
     if(l>r) return ;
     if(r==-) return ;
     int rt=pre[l];
     int p1=r;
     while(pre[p1]>=rt){
         if(p1==l) break;
         p1--;
     }
     int minn=inf,pos;
     for(int i=p1;i>l;i--){
         if(minn>pre[i]){
             minn=pre[i];
             pos=i;
         }
     }
     for(int i=pos;i>l;i--){
         if(pre[i]>=rt){
             flag=;break;
         }
     }
     if(flag==){
         buildmin(,-);
     }
 //    cout<<pre[p1]<<endl;
     else{
         if(p1!=l){
             tree[l].l=buildmin(l+,p1);
             tree[l].r=buildmin(p1+,r);
         }
         else{
            tree[l].r=buildmin(p1+,r);
         }
         return l;
     }
 }

 int buildmax(int l,int r)
 {
     if(l>r) return ;
     if(r==-) return ;
     int rt=pre[l];
     int p1=r;
     while(pre[p1]<rt){
         p1--;
     }
     for(int i=p1;i>l;i--){
         if(pre[i]<rt){
             flag=;break;
         }
     }
     if(flag==){
         buildmax(,-);
     }
 //    cout<<pre[p1]<<endl;
     else{
         if(p1!=r){
             tree[l].l=buildmax(l+,p1);
             tree[l].r=buildmax(p1+,r);
         }
         else{
             tree[l].l=buildmax(l+,p1);
         }
         return l;
     }
 }

 void bfs(int x)
 {
     vector<int> vec;
     queue<int> que;
     que.push(x);
     while(!que.empty()){
         int ret=que.front();
         que.pop();
         if(ret==) break;
         vec.push_back(ret);
         if(tree[ret].l!=){
             que.push(tree[ret].l);
         }
         if(tree[ret].r!=){
             que.push(tree[ret].r);
         }
     }
     int l=vec.size();
     for(int i=;i<l;i++)
         cout<<pre[vec[i]]<<" ";
     cout<<endl;
 }

 vector<int> vec;

 int behorder(int x)
 {
     if(tree[x].l==&&tree[x].r==){
         if(pre[x]!=)
             vec.push_back(pre[x]);
         return ;
     }
     behorder(tree[x].l);
     behorder(tree[x].r);
     vec.push_back(pre[x]);
 }

 void print()
 {
     int l=vec.size();
     for(int i=;i<l-;i++)
         cout<<vec[i]<<" ";
     cout<<vec[l-]<<endl;
 }

 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++)
         scanf("%d",&pre[i]);
 //        cout<<"23333333333"<<endl;
     if(pre[]<pre[]){
         buildmin(,n);
         if(flag==) cout<<"NO"<<endl;
         else{
 //            bfs(1);
             cout<<"YES"<<endl;
             behorder();
             print();
         }
     }
     else{
         buildmax(,n);
         if(flag==) cout<<"NO"<<endl;
         else{
 //            bfs(1);
             cout<<"YES"<<endl;
             behorder();
             print();
         }
     }
 //    for(int i=1;i<=n;i++)
 //        cout<<tree[i].l<<" "<<tree[i].r<<endl;
 //
 ////    else buildmax(1,n);
 //    behorder();

 }

学的别人的思路：

代码:

 //L2-004 这是二叉搜索树吗？
 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int maxn=1e5+;
 const int inf=0x3f3f3f3f;

 int n;
 int isMirror=;
 int pre[maxn];
 vector<int> vec;

 int build(int l,int r)
 {
     if(l>r) return ;
     int rt=pre[l];
     int p1=l+,p2=r;
     if(!isMirror){
         while(p1<=r&&rt>pre[p1]) p1++;
         while(p2>l&&rt<=pre[p2]) p2--;
     }
     else{
         while(p1<=r&&rt<=pre[p1]) p1++;
         while(p2>l&&rt>pre[p2]) p2--;
     }
     if(p1-p2!=) return ;
     build(l+,p2);//按照后序遍历建树
     build(p1,r);
     vec.push_back(rt);
 }

 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++)
         scanf("%d",&pre[i]);
     build(,n);
     if(vec.size()!=n){
         isMirror=;
         vec.clear();
         build(,n);
     }
     if(vec.size()==n){
         printf("YES\n");
         int l=vec.size();
         for(int i=;i<l-;i++)
             cout<<vec[i]<<" ";
         cout<<vec[l-]<<endl;
     }
     else{
         cout<<"NO"<<endl;
     }
 }

先这样。