pat 1127. ZigZagging on a Tree (30) 递归建树 + BFS

1127. ZigZagging on a Tree (30)

时间限制

400 ms

内存限制

65536 kB

代码长度限制

16000 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

#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <set>
#include <map>
#include <queue>
#include <vector>

using namespace std;

int N;
int in[35], post[35];
int len, maxdep;
map<int, int> ls, rs;
vector<int> G[35];

struct node {
	int x, dep;
	node() {}
	node(int x, int dep) : x(x), dep(dep) {}
};

int build(int l, int r) {
	if (l > r) {
		return -1;
	}
	int root, i;
	root = post[len--];
	for (i = l; i <= r; i++) {
		if (in[i] == root) {
			break;
		}
	}
	rs[root] = build(i + 1, r);
	ls[root] = build(l, i - 1);
	return root;
}

void bfs(int s) {
	queue<node> q;
	while (!q.empty()) {
		q.pop();
	}
	q.push(node(s, 1));
	for (int i = 0; i < 33; i++) G[i].clear();
	maxdep = -1;
	while(!q.empty()) {
		node tn = q.front(); q.pop();
		maxdep = max(maxdep, tn.dep);
		G[tn.dep].push_back(tn.x);
		if (ls[tn.x] != -1) {
			q.push(node(ls[tn.x], tn.dep + 1));
		}
		if (rs[tn.x] != -1) {
			q.push(node(rs[tn.x], tn.dep + 1));
		}
	}
}

void output() {
	int cnt = 0;
	for (int i = 1; i <= maxdep; i++) {
		if (i % 2) {
			for (int j = G[i].size() - 1; j >= 0; j--) {
				printf(cnt++ == 0 ? "%d" : " %d", G[i][j]);
			}
		} else {
			for (int j = 0; j < G[i].size(); j++) {
				printf(cnt++ == 0 ? "%d" : " %d", G[i][j]);
			}
		}
	}
	puts("");
}

int main()
{
	cin >> N;
	for (int i = 1; i <= N; i++) {
		scanf("%d", &in[i]);
	}
	for (int i = 1; i <= N; i++) {
		scanf("%d", &post[i]);
	}
	len = N;
	ls.clear();
	rs.clear();
	int root = build(1, N);
	bfs(root);
	output();
	return 0;
}