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

Code：

#include<bits/stdc++.h>

using namespace std;
const int N = 35;
int l[N], r[N];
map<int, int> pos;
int inorder[N];
int postorder[N];
vector<int> depth[N];
int max_depth;
int n;
int q[N];

int build(int il, int ir, int pl, int pr) {
    int root = postorder[pr];
    int k = pos[root];
    if (il < k)
        l[root] = build(il, k - 1, pl, k - il + pl - 1);
    if (ir > k)
        r[root] = build(k + 1, ir, k - il + pl, pr - 1);
    return root;
}

void dfs(int u, int d) {
    if (u == -1)
        return;
    depth[d].push_back(u);
    max_depth = max(max_depth, d);
    dfs(l[u], d + 1);
    dfs(r[u], d + 1);
}

int main() {
    cin >> n;
    memset(l, -1, sizeof l);
    memset(r, -1, sizeof r);
    for (int i = 0; i < n; i++) {
        cin >> inorder[i];
        pos[inorder[i]] = i;
    }
    for (int i = 0; i < n; i++)
        cin >> postorder[i];
    int root = build(0, n - 1, 0, n - 1);
    dfs(root, 1);
    bool flag = true;
    for (int k = 1; k <= max_depth; k++) {
        if (k % 2 == 0) {
            for (int i = 0; i < depth[k].size(); i++) {
                cout << " " << depth[k][i];
            }
        } else {
            if (flag) {
                flag = false;
                cout << depth[k][depth[k].size()-1];
                for (int i = depth[k].size()-2; i >=0 ; i--) {
                    cout << " " << depth[k][i];
                }
            } else {
                for (int i = depth[k].size() - 1; i >= 0; i--) {
                    cout << " " << depth[k][i];
                }
            }
        }
    }
    cout<<endl;
}