PAT甲级1127 ZigZagging on a Tree//中序后序建树//水平遍历

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 <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
struct node
{
	int val;
	node* left;
	node* right;
	node(int v) : val(v), left(NULL), right(NULL) {}
};
int flag = -1;
vector<int> in, post;
vector<int> ans;
node* creat(int postL, int postR, int inL, int inR);
void levelOrder(node*);
int main()
{
	int N;
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		int num;
		cin >> num;
		in.push_back(num);
	}
	for (int i = 0; i < N; i++)
	{
		int num;
		cin >> num;
		post.push_back(num);
	}
	node* root = creat(0, post.size() - 1, 0, in.size() - 1);
	levelOrder(root);
	for (int i = 0; i < ans.size(); i++)
	{
		if (i != 0)
			cout << " ";
		cout << ans[i];
	}
	system("pause");
	return 0;
}
node* creat(int postL, int postR, int inL, int inR)
{
	if (postL > postR)
		return NULL;
	node* root = new node(post[postR]);
	int k;
	for (k = inL; k <= inR; k++)
		if (in[k] == post[postR])
			break;
	int numL = k - inL;
	root->left = creat(postL, postL + numL - 1, inL, k - 1);
	root->right = creat(postL + numL, postR - 1, k + 1, inR);
	return root;
}
void levelOrder(node* root)
{
	queue<node> Q;
	Q.push(*root);
	while (!Q.empty())
	{
		int size = Q.size();
		vector<int> part;
		for (int i = 0; i < size; i++)
		{
			node* top = &Q.front();
			if (top->left != NULL)
				Q.push(*top->left);
			if (top->right != NULL)
				Q.push(*top->right);
			part.push_back(top->val);
			Q.pop();
		}
		if (flag == -1)
		{
			reverse(part.begin(), part.end());
			flag *= -1;
		}
		else
			flag *= -1;
		for (int i = 0; i < part.size(); i++)
			ans.push_back(part[i]);
	}
}