【BST、镜像BST、后序和前序】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

Code（By LiuCuo）

//二叉搜索树的前序遍历结构是有规律的，根+（左子树）+（右子树）
//而一定满足左子树小于右子树，所以我们可以通过根的节点划分左右不分
//对于正常的当根大于左子树时 i++,当根小于等于右子树时 j-- 
//最后root+1~ j-- 就是左子树的范围，i~tail就是右子树的范围，当左右子树的都push_back操作后才push_back自己，就得到了一个后序遍历
//对于镜像的就反过来的逻辑就好了，如果镜像的在当做正常二叉树遍历时，最后的后续结果会小于n，因为i-j要满足等于一，而非搜索二叉树和镜像二叉树都不满足就会提前return导致n小
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
bool isMirror;
vector<int> pre, post;
void getpost(int root, int tail){
	if(root > tail)
		return;//表示空节点
	int i = root + 1, j = tail;
	if(!isMirror){//先按照正常BST判断
		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);//left tree
	getpost(i, tail);
	post.push_back(pre[root]); 
}
int main(){
	int n;
	cin>>n;
	pre.resize(n);
	for(int i = 0; i < n; i++){
		cin>>pre[i];
	}
	getpost(0, n - 1);//整个范围内获取后续遍历
	if(post.size() < n){
		isMirror = true;
		post.clear();//是镜像的或者非BST，我们不清楚，总之按照镜像求后序的过程再求一次后序，如果还是小于n就是非BST了
		getpost(0, n - 1); 
	} 
	if(post.size() == n){
		cout<<"YES\n"<<post[0];
		for(int i = 1; i < n; i++)
			cout<<" "<<post[i];
	}else
		cout<<"NO";
	return 0;
} 

Summary

二叉搜索树的前序遍历结构是有规律的，根+（左子树）+（右子树）
而一定满足左子树小于右子树，所以我们可以通过根的节点划分左右不分
对于正常的当根大于左子树时 i++,当根小于等于右子树时 j–
最后root+1~ j 就是左子树的范围，i~tail就是右子树的范围，当左右子树的都push_back操作后才push_back自己，就得到了一个后序遍历
对于镜像的就反过来的逻辑就好了，如果镜像的在当做正常二叉树遍历时，最后的后续结果会小于n，因为i-j要满足等于一，而非搜索二叉树和镜像二叉树都不满足就会提前return导致数组 size < n