第三天PAT-A1043 Is It a Binary Search Tree算法详细注解

A1043

Description:

BST递归定义如下：

左子树节点小于该节点，右子树节点大于等于该节点，左右子树都只有一个节点；

如果所有节点的左右子树交换，则结果叫BST的镜像；

现给出一个正数主键序列，问其是否为一个BST或BST镜像的先序遍历序列

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<vector>
#include<queue>
using namespace std;
const int maxn = 1e3+5;
int n;
struct node{
    int key;
    int left;
    int right;
}Node[maxn];
int root = -1, indexx = 0;  //根下标root，当前结点数indexx
vector<int>pre, post;   //存放先序序列和后序序列结果
int create(int x){  //新增节点，返回其下标
    Node[indexx].key = x;
    return indexx++;
}

void in(int root, int x){   //插入新节点
    if(x < Node[root].key){ //当前值小于根值
        if(Node[root].left == -1){  //当前根无左孩子，直接插入
            Node[root].left = create(x);
            return ;
        }
        else    //当前根有左孩子，递归至左子树插入
            in(Node[root].left, x);
    }
    else{   //当前值大于根值
        if(Node[root].right == -1){//当前根无右孩子，直接插入
            Node[root].right = create(x);
            return ;
        }
        else    //当前根有右孩子，递归至右子树插入
            in(Node[root].right, x);
    }
}

void preOrder(int root){
    pre.push_back(Node[root].key);
    if(Node[root].left != -1) preOrder(Node[root].left);
    if(Node[root].right != -1) preOrder(Node[root].right);
}

void preOrderM(int root){   //镜像
    pre.push_back(Node[root].key);
    if(Node[root].right != -1) preOrderM(Node[root].right);
    if(Node[root].left != -1) preOrderM(Node[root].left);
}

void postOrderM(int root){  //镜像
    if(Node[root].right != -1) postOrderM(Node[root].right);
    if(Node[root].left != -1) postOrderM(Node[root].left);
    post.push_back(Node[root].key);
}

void postOrder(int root){
    if(Node[root].left != -1) postOrder(Node[root].left);
    if(Node[root].right != -1) postOrder(Node[root].right);
    post.push_back(Node[root].key);
}

int main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("1.txt", "r", stdin);
#endif // ONLINE_JUDGE
    memset(Node, -1, sizeof(Node));
    scanf("%d", &n);
    int temp;
    for(int i = 0; i < n; i++){ //数据读入同时建树
        scanf("%d", &temp);
        if(i == 0){
            root = i;
            Node[root].key = temp;
            indexx++;
            continue;
        }
        in(root, temp);
    }
    preOrder(root);

    int i, j;
    for(i = 0; i < n; i++){
        if(Node[i].key != pre[i]){  //先序匹配失败
            pre.clear();    //重新使用vector时，注意先将其清空
            preOrderM(root);
            for(j = 0; j < n; j++){
                if(Node[j].key != pre[j]){//镜像先序匹配失败
                    printf("NO");
                    return 0;
                }
            }
            break;
        }
    }

    if(i >= n){ //先序匹配成功
        printf("YES\n");
        postOrder(root);
        for(int k = 0; k < n; k++){
            if(k != 0)
                printf(" ");
            printf("%d", post[k]);
        }
    }else{  //镜像先序匹配成功
        printf("YES\n");
        postOrderM(root);
        for(int k = 0; k < n; k++){
            if(k != 0)
                printf(" ");
            printf("%d", post[k]);
        }
    }
    return 0;
}