Pat【甲级】 1043 Is It a Binary Search Tree （附中文题目）

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

中文题目

二叉搜索树 (BST) 递归定义为具有以下属性的二叉树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
• 若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值
  它的左、右子树也分别为二叉搜索树

我们将二叉搜索树镜面翻转得到的树称为二叉搜索树的镜像。 现在，给定一个整数序列，请你判断它是否可能是某个二叉搜索树或其镜像进行前序遍历的结果。 输入格式 第一行包含整数 N，表示节点数量。 第二行包含 N 个整数。 输出格式 如果给定整数序列是某个二叉搜索树或其镜像的前序遍历序列，则在第一行输出 YES，否则输出 NO。 如果你的答案是 YES，则还需要在第二行输出这棵树的后序遍历序列。

---

注意

我们可以由BST的定义知道，BST的中序遍历就是权值从小到大排序，我们来举个例子

我们可以利用前序遍历以及中序遍历来重建二叉树，而对于BST的镜像其实就是把左儿子和右儿子的条件调换（由原来中序遍历是从小到大排变成从大到小排）

---

---

代码

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N = 1010;
int n;
int preorder[N];  //前序
int inorder[N];   //中序
int postorder[N],cnt;

bool build(int il,int ir,int pl,int pr,int type) {
	if (il > ir)return true;  //表示没有元素了，意思是该部分已经建立成功了
	//根节点
	int root = preorder[pl];
	int k;
	if (!type) {
		for (k = il; k <= ir; k++) {
			if (inorder[k] == root) {
				break;
			}
		}
		if (k > ir)return false;
		
	}
	else {
		for (k = ir; k >= il; k--) {
			if (inorder[k] == root) {
				break;
			}
		}
		if (k < il)return false;
	}

	bool res = true;

	//左子树重建
	if (!build(il, k - 1, pl + 1, pl + 1 + (k - 1 - il), type))res = false;
	//右子树重建
	if (!build(k + 1, ir, pl + 1 + (k - 1 - il) + 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)) {
		cout << "YES" << endl;
		cout << postorder[0];
		for (int i = 1; i < n; i++) {
			cout << " " << postorder[i];
		}
		cout << endl;
	}
	else {  //如果不满足原BST就尝试镜像
		reverse(inorder, inorder + n);
		cnt = 0;
		
		if (build(0, n - 1, 0, n - 1, 1)) {
			cout << "YES" << endl;
			cout << postorder[0];
			for (int i = 1; i < n; i++) {
				cout << " " << postorder[i];
			}
			cout << endl;
		}
		else {
			cout << "NO" << endl;
		}
	}
	return 0;
}

运行结果