1043 Is It a Binary Search Tree（树的遍历）

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

分析：

本题第一次提交时分析中序可以借助BST特性和前序可得(i.e.将前序进行排序，若BST则顺序，若镜像BST则逆序)，但是测试点1(starting from 0)未通过，猜测可能是得到的中序虽然是BST的中序，但是此中序不一定符合BST特性的要求，毕竟题目要求的是判断给定的序列是不是BST的前序，因为假设是前序时，若中序不符合BST的特性(根节点大于左子树，且小于等于右子树)，则依然由前序和有序的后序不能推出前序是BST的前序，需要在遍历的过程对这一特性做判断，但目前此想法编写的代码为通过测试点2，先将错误代码（源代码1）和思想抛出，日后再看此博客做进一步思考。
最后参考博客^[1]后修改的代码时源代码2，基本思想是，修改基本法的遍历函数，通过BST的特性判断序列的边界条件。
注: 树遍历的总结知识可参考树的遍历问题探讨及总结。
源代码2

#include
#include 
#include 
using namespace std;
vector pre,post;
bool isMirror=false;//false denotes BST,however true specifies Mirror Image of a BST.
void getpost(int root,int tail) {
    if(root>tail) return ;
    int i=root+1,j=tail;
    if(!isMirror) {
        while(i<=tail&&pre[root]>pre[i]) i++;
        while(j>root&&pre[root]<=pre[j]) j--;
    }else{
        while(i<=tail&&pre[root]<=pre[i]) i++;
        while(j>root&&pre[root]>pre[j]) j--;
    }
    if(i-j!=1) return ;
    getpost(root+1,j);
    getpost(i,tail);
    post.push_back(pre[root]);
}
int main() {
    int n;
    cin>>n;
    pre.resize(n);
    for(int i=0; i>pre[i];
    }
    getpost(0,n-1);
    if(post.size()==n) {
        cout<<"YES"<

源代码1

#include
#include 
#include 
using namespace std;
vector pre,in,post;
void post_traverse(int root,int start,int end) {
    if(start>end) return ;
    int i=start;
    while(i<=end && pre[root]!=in[i]) i++;
    post_traverse(root+1,start,i-1);
    post_traverse(root+i-start+1,i+1,end);
    post.push_back(pre[root]);
}
int main() {
    int n;
    cin>>n;
    pre.resize(n),in.resize(n);
    for(int i=0; i>pre[i];
        in[i]=pre[i];
    }
    sort(in.begin(),in.end());
    post_traverse(0,0,n-1);
    if(post.size()==n) {
        cout<<"YES"<());
        post.clear();
        post_traverse(0,0,n-1);
        if(post.size()==n){
            cout<<"YES"<

---

1. https://www.liuchuo.net/archives/2153 ↩