*PAT_甲级_1043 Is It a Binary Search Tree (25分) (C++)【二叉搜索树/树的遍历】

最新推荐文章于 2022-02-24 17:45:24 发布

&再见萤火虫&

最新推荐文章于 2022-02-24 17:45:24 发布

阅读量228

点赞数

分类专栏： PAT甲级文章标签： PAT 甲级 1043 C++

本文链接：https://blog.csdn.net/qq_41528502/article/details/104389771

版权

PAT甲级专栏收录该内容

155 篇文章 5 订阅

订阅专栏

1，题目描述

Sample Input 1:

7
8 6 5 7 10 8 11

Sample Output 1:

YES
5 7 6 8 11 10 8

Sample Input 2:

7
8 10 11 8 6 7 5

Sample Output 2:

YES
11 8 10 7 5 6 8

Sample Input 3:

7
8 6 8 5 10 9 11

Sample Output 3:

NO

题目大意

给出树的节点数，以及一系列值，判断这些值是不是二叉搜索树（或者是该树的镜像）的先序遍历，是则输出Yes，并输出其后序遍历；

2，思路

方法一：

极为野蛮的解法。先构建BST，并求出先序遍历pre和镜像先序遍历preMir，对照输入是否为其中一个；

若是，则求后序遍历/镜像后序遍历；

否则，输出NO；

方法二（柳神）：

充分利用镜像BST的特点：

左子树的值小于当前节点，右子树的值大于等于当前节点；
BST的先序遍历，只要是值小于根节点root的都是左子树上的点，否则就是右子树上的点。据此可以判断左右两子树的根节点，并递归的遍历左右两子树；

如图。红色表示根节点，不同颜色表示不同的树（为了区分，根节点未填充）

根据输入的序列，可以判断左子树的根节点（root后一个位置），右子树根节点（从root向tail遍历，第一个大于root对应值的节点）。递归地进行其他子树的遍历（getpost(root + 1, j)；getpost(i, tail)；），并在最后将root存入后序遍历的序列中即可（post.push_back(pre[root])；）。

最后只需要判断post.size()是否为n（每个节点均遍历过），即可判断输入是否为先序序列。

镜像输入的话也一样。

3，代码

方法一：

#include<iostream>
#include<vector>
using namespace std;

vector<int> input, pre, preMir, ans;            //input输入数组 pre先序遍历 preMir镜像先序遍历

struct tree{
    int key;
    tree * left = NULL;
    tree * right = NULL;
};
void insert(tree *& node, int key){             //构建BST 注意加&
    if(node == NULL){
        node = new tree;
        node->key = key;
    }else{
        if(key < node->key)
            insert(node->left, key);
        else
            insert(node->right, key);
    }
}

void preOrder(tree * node){                     //先序遍历
    if(node != NULL){
        pre.push_back(node->key);
        preOrder(node->left);
        preOrder(node->right);
    }
}
void preMirOrder(tree * node){                  //镜像先序遍历
    if(node != NULL){
        preMir.push_back(node->key);
        preMirOrder(node->right);
        preMirOrder(node->left);
    }
}
void postOrder(tree * node){                    //后序遍历
    if(node != NULL){
        postOrder(node->left);
        postOrder(node->right);
        ans.push_back(node->key);
    }
}
void postMirOrder(tree * node){                 //镜像后序遍历
    if(node != NULL){
        postMirOrder(node->right);
        postMirOrder(node->left);
        ans.push_back(node->key);
    }
}
int main(){
//#ifdef ONLINE_JUDGE
//#else
//    freopen("1.txt", "r", stdin);
//#endif

    int n;
    cin>>n;
    tree * root = NULL;
    int key, i;
    for(i = 0; i < n; i++){
        cin>>key;
        input.push_back(key);
        insert(root, key);
    }
    preOrder(root);
    preMirOrder(root);

    i = 0;
    while(i < n){
        if(pre[i] == input[i])
            i++;
        else
            break;
    }
    if(i < n){                                  //若不是正常的先序遍历 判断是否为镜像先序遍历
        i = 0;
        while(i < n){
            if(preMir[i] == input[i])
                i++;
            else
                break;
        }
        if(i < n){                              //既不是正常的先序遍历 也不是镜像先序遍历
            cout<<"NO";
            return 0;
        }
        postMirOrder(root);
    }else postOrder(root);
    cout<<"YES"<<endl<<ans[0];
    for(i = 1; i < n; i++){
        cout<<' '<<ans[i];
    }

    return 0;
}

方法二：

#include<iostream>
#include<vector>
using namespace std;

bool isMirror;
vector<int> pre, post;

void getPost(int root, int tail){
    if(root > tail) return;
    int i = root + 1, j = tail;
    if(isMirror == false){
        while(i <= tail && pre[i] < pre[root]) i++;
        while(j > root && pre[j] >= pre[root]) j--;
    }else{
        while(i <= tail && pre[i] >= pre[root]) i++;
        while(j > root && pre[j] < pre[root]) j--;
    }

    if(i - j != 1) return;                  //正常情况下i-j应等于1!!!(若不符合先序遍历 那么post的长度就会小于n)
    getPost(root + 1, j);                   //遍历左子树
    getPost(i, tail);                       //遍历右子树
    post.push_back(pre[root]);              //后序遍历 最后将根节点入栈
}
int main(){
//#ifdef ONLINE_JUDGE
//#else
//    freopen("1.txt", "r", stdin);
//#endif

    int n;
    cin>>n;
    int num;
    for(int i = 0; i < n; i++){
        scanf("%d", &num);
        pre.push_back(num);
    }
    getPost(0, n-1);
    if(post.size() != n){
        isMirror = true;
        post.clear();
        getPost(0, n-1);
    }
    if(post.size() != n){
        cout<<"NO";
        return 0;
    }
    cout<<"YES"<<endl<<post[0];
    for(int i = 1; i < n; i++)
        cout<<' '<<post[i];

    return 0;
}