2017.3.4 pat甲级D题ZigZagging on a Tree

ZigZagging on a Tree

时间限制

400 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

CHEN, Yue

Suppose that all the keys in a binary tree are distinct positive integers. A unique binary tree can be determined by a given pair of postorder and inorder traversal sequences. And it is a simple standard routine to print the numbers in level-order. However, if you think the problem is too simple, then you are too naive. This time you are supposed to print the numbers in "zigzagging order" -- that is, starting from the root, print the numbers level-by-level, alternating between left to right and right to left. For example, for the following tree you must output: 1 11 5 8 17 12 20 15.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (<= 30), the total number of nodes in the binary tree. The second line gives the inorder sequence and the third line gives the postorder sequence. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the zigzagging sequence of the tree in a line. All the numbers in a line must be separated by exactly one space, and there must be no extra space at the end of the line.

Sample Input:

8
12 11 20 17 1 15 8 5
12 20 17 11 15 8 5 1

Sample Output:

1 11 5 8 17 12 20 15

解析：这道题包含两个步骤，一是根据中序遍历和后序遍历建立一棵树，然后再把这棵树按S型输出。

其中根据中序遍历和后序遍历建立一棵树的大致思路是从后序遍历的最后一个结果的值得出根节点的值，然后在中序遍历的结果中判断哪些部分是属于左子树，哪些部分是属于右子树，不断递归建立这棵树。

按S型输出的大致思路是使用一个栈和一个队列，奇数层用栈来实现先入后出，偶数层用队列来实现先入先出，从而达到S型输出的目的。

由于水平有限，代码有些繁杂，还请大牛多多指教：

#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
using namespace std;

int N;
int inorder[30],postorder[30];
int cout_count = 0;
int max_floor=0;

struct Node {
	int value;
	int floor;
	Node* left;
	Node* right;
}* root;


queue<Node*> que;
stack<Node*> sta;


bool make_tree(int in_start,int in_end,int post_start,int post_end,Node* &p,int floor) {
	
	if (in_start > in_end || post_start>post_end) {
		p = NULL;
		return true;
	}
	p->value = postorder[post_end];
	p->floor = floor;
	if (floor > max_floor) max_floor = floor;
	if (in_start == in_end) {
		p->left = NULL;
		p->right = NULL;
		return true;
	}
	

	int*s = find(inorder, inorder+N-1, postorder[post_end]);//找到根节点在中序遍历中的位置
	int No = s - inorder;//根节点在中序遍历的数组中的序号
	int cnt = No - in_start;//左子树的节点个数
	p->left = new Node;
	p->right = new Node;
	make_tree(in_start, No - 1, post_start, post_start + cnt-1, p->left,floor+1);//左子树建树
	make_tree(No + 1, in_end, post_start + cnt, post_end - 1, p->right,floor+1);//右子树建树
	return true;
}

//按S型输出树
void print_out(int floor) {
	if (floor > max_floor) return;
	if (floor % 2 != 0) {
		while (!sta.empty()) {
			Node*p = sta.top();
			cout_count++;
			if (cout_count == N) cout << p->value;
			else cout << p->value << " ";
			if(floor==1){
				if (p->left != NULL) que.push(p->left);
				if(p->right != NULL) que.push(p->right);
			}
			
			sta.pop();
		}

	}
	else {
		while (!que.empty()&&que.front()->floor==floor) {
			Node*p = que.front();
			cout_count++;
			if (cout_count == N) cout << p->value;
			else cout << p->value << " ";
			if (p->left != NULL) {
				sta.push(p->left);
				if (p->left->left != NULL) que.push(p->left->left);
				if (p->left->right != NULL) que.push(p->left->right);
			}
			if (p->right != NULL) {
				sta.push(p->right);
				if (p->right->left != NULL) que.push(p->right->left);
				if (p->right->right != NULL) que.push(p->right->right);
			}
			que.pop();
		}
	}
	print_out(++floor);
}

int main() {
	root = new Node;
	cin >> N;
	for (int i = 0; i < N; i++) {
		cin >> inorder[i];//输入中序遍历
     }
	for (int i = 0; i < N; i++) {
		cin >> postorder[i];//输入后序遍历
	}
	
	make_tree(0, N - 1, 0, N - 1, root,1);
	sta.push(root);
	print_out(1);
        return 0;

}