pat甲级

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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

//所谓二叉搜索树题无非就是把给定的序列排个序之后就成中序遍历数然后就跟普通二叉树一样

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

const int N = 1010;
int inorder[N], preorder[N], postorder[N];
int n, cnt;

bool build(int il, int ir, int pl, int pr, int type){
    if (il > ir)//左右子树递归结束返回true
        return true;
    int root = preorder[pl];//寻找根结点
    int k;//寻找根节点在中序遍历的位置
    if (!type)   //对二查搜索树的判断
    {
        for (k = il; k <= ir; k++) //找到该结点在中序序列中的位置
            if (root == inorder[k])
                break;
        if (k > ir)  //如果查找的根节点在中序遍历的ir右边说明超出范围不是二叉搜索树（先固定查找范围在找根节点，如果最终k>ir+1,说明根节点不在某个根内，因此不是二叉搜索树）
            return false;
    }
    else    //对镜像二叉搜索树的判断
    {
        //Q:为何逆序遍历查找根节点？
        //A:这样遍历结果才能输出原二叉树的后序遍历
        for (k = ir; k >= il; k--)
            if (root == inorder[k])
                break;
        if (k < il)  
            return false;
    }

    //递归判断其左右子树是否满足要求
    int res = true;//假设最终为二叉树或其镜像的前序遍历
    if (!build(il, k - 1, pl + 1, pl + 1 + (k - il - 1), type)) 
        res = false;
    if (!build(k + 1, ir, pl + 1 + (k - il - 1) + 1, pr, type))  
        res = false;

    postorder[cnt++] = root;  //将根结点加入后序数组中

    return res;
}

int main()
{
    //输入结点信息
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> preorder[i];
        inorder[i] = preorder[i];
    }

    sort(inorder, inorder + n);    //获得中序序列

    if (build(0, n - 1, 0, n - 1, 0))    //判断是否为二叉搜索树，传5个参数其中第五个参数一开始为0假设为二叉搜索树
    {
        puts("YES");
        cout << postorder[0];
        for (int i = 1; i < cnt; i++)  cout << " " << postorder[i];
        cout << endl;
    }
    else    //判断是否为镜像二叉搜索树
    {
        reverse(inorder, inorder + n);//反转
        cnt = 0;
        if (build(0, n - 1, 0, n - 1, 1))
        {
            puts("YES");
            cout << postorder[0];
            for (int i = 1; i < cnt; i++)  cout << " " << postorder[i];
            cout << endl;
        }
        else    puts("NO");
    }

    return 0;
}