PAT 甲级 1043 Is It a Binary Search Tree

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

解题思路：因为是二叉排序树，所有本题直接根据输入的序列创建二叉树，然后就是先序，后序对二叉树进行操作，镜像只要把左右子树的递归顺序改变一下就行。

#include<cstdio>
#include<vector>
using namespace std;
vector<int> BST,MIBST;
int flag = 0;
struct node{
	int data;
	node* lchild;
	node* rchild;
};
int a[1010],N;
node* newnode(int data){
	node* Node = new node;
	Node->data = data;
	Node->lchild = Node->rchild = NULL;
	return Node;
}

void insert(node* &root,int data){
	if(root == NULL){
		root = newnode(data);
		return;
	}
	if(data < root->data)
		insert(root->lchild,data);
	else
		insert(root->rchild,data);
}
node* create(int a[],int n){
	node* root = NULL;
	for(int i = 0;i < n;i++){
		insert(root,a[i]);
	}
	return root;
}
void insearch(node* root){
	if(root == NULL)
		return;
	BST.push_back(root->data);
	insearch(root->lchild);
	insearch(root->rchild);
}
void MIinsearch(node* root){
	if(root == NULL)
		return;
	MIBST.push_back(root->data);
	MIinsearch(root->rchild);
	MIinsearch(root->lchild);
}
void postsearch(node* root){
	if(root == NULL)
		return;
	postsearch(root->lchild);
	postsearch(root->rchild);
	if(flag)
		printf(" ");
	printf("%d",root->data);
	flag = 1;
}
void MIpostsearch(node* root){
	if(root == NULL)
		return;
	MIpostsearch(root->rchild);
	MIpostsearch(root->lchild);
	if(flag)
		printf(" ");
	printf("%d",root->data);
	flag = 1;
}
int main(void){
	int N,temp = 0;
	scanf("%d",&N)	;
	for(int i = 0;i < N;i++){
		scanf("%d",&a[i]);
	}		
	node* root = create(a,N);
	insearch(root);
	MIinsearch(root);
	int i;
	for(i = 0;i < N;i++)
		if(a[i] != BST[i])
			break;
	if(i == N)
		temp = 1;
	for(i = 0;i < N;i++)
		if(a[i] != MIBST[i])
			break;
	if(i == N)
		temp = 2;
	if(temp){
		printf("YES\n");
		if(temp == 1)
			postsearch(root);
		else
			MIpostsearch(root);
	}
	else
		printf("NO");	
}