[PAT]1043 Is It a Binary Search Tree (25 分)

一、题意

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:

• The left subtree of a node contains only nodes with keys less than the node's key.
• The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
• Both the left and right subtrees must also be binary search trees.

If we swap the left and right subtrees of every node, then the resulting tree is called the Mirror Image of a BST.

Now given a sequence of integer keys, you are supposed to tell if it is the preorder traversal sequence of a BST or the mirror image of a BST.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤1000). Then N integer keys are given in the next line. All the numbers in a line are separated by a space.

Output Specification:

For each test case, first print in a line YES if the sequence is the preorder traversal sequence of a BST or the mirror image of a BST, or NO if not. Then if the answer is YES, print in the next line the postorder traversal sequence of that tree. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

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"再输出这个二叉搜索树或者二叉搜索树镜像树的后序遍历。

题解：我第一次做的时候理解错了题意，以为给出一个序列随便构造一个二叉搜索树即可，后来看其他人的代码意识到二叉搜索树并不唯一，用某种方式构造出来的二叉树虽然可能不满足，但是可能用另一种方式构造出来的就满足。这道题在构造二叉树时如果使用insert节点的方式可以很容易的判断，如果采用其他的方式构造就容易出错。最后在柳婼女神的代码的提示下终于做出来了，但是代码与柳婼的思路并不完全一样，(柳的比我的简洁多了，膜拜)。

下面给出我的代码的题解：

首先假设已知序列是某二叉搜索树的前序遍历，假设序列为nums[i, i+1, i+2, ....., i+n]根据前序遍历的性质：nums[i]即为该树的根节点，同时 nums[i+1,....i+x]，(其中nums[i+1]、nums[i+2]....nums[i+x]都小于nums[i])为树的左子树，nums[i+x+1,......i+x+m]，(nums[i+x+1]、nums[i+x+2].....nums[i+x+m]都大于等于nums[i])为树的右子树。那么我们根据这个性质建树。这里注意i+x+m 不一定等于i+n（当不等于时说明该序列不是这个二叉搜索树的前序遍历）。

建完树后对树进行后序遍历，如果后序遍历序列的长度等于Nums.size()说明建的树包含了所有Nums[i]即输出“YES”,然后输出后序序列。不然，在此建树，但是此时将左子树与右子树反过来，再次建树，再次判断后序遍历序列的长度是否等于nums.szie()，如果等于输出“YES”和后序遍历的结果，不然输出“NO”；

AC代码：

#include<bits/stdc++.h>
using namespace std;
struct node {
    int val;
    node* left;
    node* right;
    node(int val, node* l=NULL, node* r=NULL) {
        this->val = val;
        this->left = l;
        this->right = r;
    }
};

vector<int > nums;

vector<int > post;

void creatTree1(node* &root, int l, int r) {
    if(l>r) {
        root = NULL;
        return ;
    } else {
        root = new node(nums[l]);
        int ll=l+1, lr=l, rl, rr;
        for(int i=l+1; i<=r; i++) {
            if(nums[i] >= nums[l]) {

                break;
            } else {
                lr ++;
            }
        }
        rl = lr + 1;
        rr = lr;
        for(int i=lr+1; i<=r; i++) {
            if(nums[i] < nums[l]) {

                break;
            } else {
                rr ++;
            }
        }

        creatTree1(root->left, ll, lr);
        creatTree1(root->right, rl, rr);
    }
}
void creatTree2(node* &root, int l, int r) {
    if(l>r) {
        root = NULL;
        return ;
    } else {
        root = new node(nums[l]);
        int ll=l+1, lr=l, rl, rr;
        for(int i=l+1; i<=r; i++) {
            if(nums[i] < nums[l]) {
                break;
            } else {
                lr ++;
            }
        }
        rl = lr + 1;
        rr = lr;
        for(int i=lr+1; i<=r; i++) {
            if(nums[i] >= nums[l]) {

                break;
            } else {
                rr ++;
            }
        }
        creatTree2(root->left, ll, lr);
        creatTree2(root->right, rl, rr);
    }
}
void postorder(node* root) {
    if(root==NULL) {
        return ;
    } else {
        postorder(root->left);
        postorder(root->right);
        post.push_back(root->val);
    }

}

int main() {
    int n;
    cin>>n;
    for(int i=0; i<n; i++) {
        int temp;
        cin>>temp;
        nums.push_back(temp);
    }
    node* root;
    creatTree1(root, 0, nums.size()-1);
    postorder(root);
    if(post.size() == nums.size()) {
        cout<<"YES"<<endl;
        for(int i=0; i<post.size()-1; i++) {
            cout<<post[i]<<" ";
        }
        cout<<post.back()<<endl;
    } else {
        post.clear();
        node* root2;
        creatTree2(root2, 0, nums.size()-1);
        postorder(root2);
        if(post.size() == nums.size()) {
            cout<<"YES"<<endl;
            for(int i=0; i<post.size()-1; i++) {
                cout<<post[i]<<" ";
            }
            cout<<post.back()<<endl;
        } else {
            cout<<"NO"<<endl;
        }
    }
    return 0;
}