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:

1. The left subtree of a node contains only nodes with keys less than
   the node’s key.
2. The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
3. 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

给出一棵树的先序遍历，问这是否是一个二叉搜索树或者镜像的二叉搜索树。
不管怎么样，先根据给出的先序遍历序列建BST，即第一个数字是root，后面的数字根据BST的规则或者镜像BST的规则，插入到左边或者右边。对建好的BST进行先序遍历，如果得到的序列和题目给出的序列一致，说明是BST。

#include 
#include 
using namespace std;

struct node{
    node* left;
    node* right;
    int value;
    node(){
        int value=-1;
        left=right=NULL;
    }
};

int N;
vector<int> preorder;

node* insert1(node* &x,int a){
    if(x==NULL){
        x=new node();
        x->value=a;
    }
    else{
        if(avalue) x->left=insert1(x->left,a);
        else x->right=insert1(x->right,a);
    }
    return x;
}

node* insert2(node* &x,int a){
    if(x==NULL){
        x=new node();
        x->value=a;
    }
    else{
        if(a>=x->value) x->left=insert2(x->left,a);
        else x->right=insert2(x->right,a);
    }
    return x;
}

/*根据BST的规则建树*/
node* buildTree1(node* root,int index){
    while(indexreturn root;
}

/*根据镜像BST的规则建树*/ 
node* buildTree2(node* root,int index){
    while(indexreturn root;
}

/*对建好的BST进行先序遍历*/ 
int flag=1,cnt=0;
void preOrder(node* root){
    if(cntvalue!=preorder[cnt]) {
        flag=0;
    };
    cnt++;
    if(root->left!=NULL) preOrder(root->left);
    if(root->right!=NULL) preOrder(root->right);
}

/*后序遍历*/ 
int flag1=0;
void postOrder(node* root){
    if(root->left!=NULL) postOrder(root->left);
    if(root->right!=NULL) postOrder(root->right);
    if(flag1==0) { 
        printf("%d",root->value);
        flag1++;
    }
    else printf(" %d",root->value);
}


int main(){
    scanf("%d",&N);

    node* root1=new node();
    node* root2=new node();
    preorder.resize(N);

    for(int i=0;iscanf("%d",&preorder[i]);
        if(i==0) {
            root1->value=preorder[0];
            root2->value=preorder[0];
        }
    }

    buildTree1(root1,1);
    preOrder(root1);
    if(flag){
        printf("YES\n");
        postOrder(root1);
    }
    else{
        flag=1,cnt=0;
        buildTree2(root2,1);
        preOrder(root2);
        if(flag){
            printf("YES\n");
            postOrder(root2);
        }
        else printf("NO\n");
    }

    return 0;
}