1043. Is It a Binary Search Tree (25)-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.

---

分析:这道题就是给一串数，不是bst就是bst的镜像

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

/*
前序:1.访问根结点
     2.访问左子树
     3.访问右子树

后序：1.访问左子树
      2.访问右子树
      3.访问根


所以bst前序就是根节点，然后逐渐变小，直到右节点逐渐变大
bst后序算法就是由小变大直到根，然后又由大变小

那么bst的镜像的前序就是根节点，然后逐渐变大直到右节点逐渐变小
后序算法就是由大变小直到根，然后又由小变大
*/



#include <cstdio>
#include <vector>
using namespace std;
bool isMirror;
vector<int> v1;
vector<int> v2;
void getpost (int root , int tail)
{
    if (root > tail) 
        return;
    int i = root + 1 , j = tail;
    //判断是不是镜像
    if (!isMirror)
    {
        //从左查找比根节点值要小的
        while (i <= tail && v1[root] > v1[i])
            i++;
        //从右查找比根节点值要大或等于的
        while (j > root && v1[root] <= v1[j])
            j--;
    }
    else//镜像就反过来
    {
        while (i <= tail && v1[root] <= v1[i]) 
            i++;
        while (j > root && v1[root] > v1[j])
            j--;
    }
    //i j不相邻才会退出
    if (i - j != 1)
        return;
    /*
    1、首先构造镜像的右子数，也就是从小到根
    去掉根节点，那么所有比根节点小的树这是左子树，重新进行判断
    如果是bst，那么最终root+1>tail退出
    最小的值就是root，此时root=tail
    同样右子树也直接退出，把最小值输入v2
    2、输入根节点
    3、最后构造镜像的左子树，也就是从根到大，此时root+1永远大于j了
    全部是直接判断右子数，直到找到最大的退出
    */
    getpost (root + 1 , j);
    getpost (i , tail);
    v2.push_back (v1[root]);
}
int main ()
{
    int n;
    scanf_s ("%d" , &n);
    v1.resize (n);
    for (int i = 0; i < n; i++)
        scanf_s ("%d" , &v1[i]);
    getpost (0 , n - 1);
    if (v2.size () != n)
    {
        isMirror = true;
        v2.clear ();
        getpost (0 , n - 1);
    }
    if (v2.size () == n)
    {
        printf ("YES\n%d" , v2[0]);
        for (int i = 1; i < n; i++)
            printf (" %d" , v2[i]);
    }
    else
    {
        printf ("NO");
    }
    system ("pause");
    return 0;
}

---

　　总结:这道题一度我竟然以为总的根就左边一直左，右边一直右，搞了我半天没看懂输出，好愚蠢，唉，反正每个子树同样都是bst，要从最小的子树开始判断，一直到根为止就可以解决了，不过我可能得背一背算法了。。。。