PATA 1043 Is It a Binary Search Tree（25 分）解题报告

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

作者: CHEN, Yue

单位: 浙江大学

时间限制: 400 ms

内存限制: 64 MB

代码长度限制: 16 KB

 

题目大意：给定一个BST插入序列，然后要求你判断出这是不是一个二叉搜索树的先序遍历序列，或者是这个BST的镜像树的先序遍历序列。所谓的镜像树，就是把一棵二叉树上的所有左右结点全部互换位置。如果是，请输出他相应的后序遍历序列/镜像树后序遍历序列

解题思路：我们可以根据给出的序列来构建一棵BST，然后对这棵树进行先序遍历和镜像先序遍历，同时也进行后序和镜像后序遍历，把以上四个遍历序列都保存下来，如果符合要求，就输出对应的序列。所谓的镜像树遍历，我们并不需要真的把BST翻转过来，毕竟有的大神都不会，在先序遍历中，我们把左子树右子树的遍历顺序交换，事实上就等于按照正常的先序遍历方式遍历了这棵BST的镜像树，这点可以好好体会。这个题主要考察的是如何表示一棵树，如何建立一棵树，注意的点是，这个BST并不要求所有的结点的值都不同，和根节点相同的值，如果后插入，就放在他的右边（参考测试样例1）

AC代码：

#include<iostream>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<algorithm> 
#include<cmath>
using namespace std;
struct node{
	int data;
	node* lchild;
	node* rchild;
};
int n;
vector<int> ori,pre,prem,post,postm;
node* newNode(int v);
node* create(vector<int> t,int n);
void insert(node* &root,int x);
void preorder(node* root);
void mpreorder(node* root);
void postorder(node* root);
void mpostorder(node* root);
int main()
{
	cin>>n;
	int data;
	for(int i=0;i<n;i++)
	{
		cin>>data;
		ori.push_back(data);
	}
	node *root=NULL;
	root=create(ori,n);
	preorder(root);
	mpreorder(root);
	postorder(root);
	mpostorder(root);
	if(ori==pre)
	{
		printf("YES\n");
		for(int i=0;i<n;i++)
		{
			cout<<post[i];
			if(i<n-1) cout<<" ";
		}
	}
	else if(ori==prem)
	{
		printf("YES\n");
		for(int i=0;i<n;i++)
		{
			cout<<postm[i];
			if(i<n-1) cout<<" ";
		}
	}
	else
		printf("NO\n");
	return 0;
}

node* newNode(int v)
{
	node* Node = new node;
	Node->data=v;
	Node->lchild=Node->rchild=NULL;
	return Node;
}

void insert(node* &root,int x)
{
	if(root==NULL)
	{
		root=newNode(x);
		return;
	}
	if(x<root->data)
		insert(root->lchild,x);
	else
		insert(root->rchild,x);
}

node* create(vector<int> t,int n)
{
	node* root=NULL;
	for(int i=0;i<n;i++)
		insert(root,t[i]);
	return root;
}

void preorder(node* root)
{
	if(root==NULL)
		return;
	pre.push_back(root->data);
	preorder(root->lchild);
	preorder(root->rchild);
}

void mpreorder(node* root)
{
	if(root==NULL)
		return;
	prem.push_back(root->data);
	mpreorder(root->rchild);
	mpreorder(root->lchild);
}

void postorder(node* root)
{
	if(root==NULL)
		return;
	postorder(root->lchild);
	postorder(root->rchild);
	post.push_back(root->data);
}

void mpostorder(node* root)
{
	if(root==NULL)
		return;
	mpostorder(root->rchild);
	mpostorder(root->lchild);
	postm.push_back(root->data);
}
//把遍历中的左子树右子树顺序对换，就是镜像树的正常遍历了
//有趣有趣