PAT——1127 ZigZagging on a Tree (30 分)（BFS遍历树）

1127 ZigZagging on a Tree (30 分)

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 <stdio.h>
#include <vector>
#include <map>
#include <queue>
using namespace std;

int n;
int in[31], post[31];
map<int, vector<int> > level_nodes;
vector<int> nodes;

struct binTree
{
    int data;
    int level;
    binTree *l_child;
    binTree *r_child;
};

void input()
{
    cin >> n;
    for(int i = 0; i < n; i++)
        cin >> in[i];
    for(int i = 0; i < n; i++)
        cin >> post[i];
}
binTree *create(int inL, int inR, int postL, int postR)
{
    if(inL > inR)
        return NULL;
    binTree *root = new binTree;
    int data = post[postR], i;
    root->data = data;

    for(i = inL; i <= inR; i++)
    {
        if(in[i] == data)
            break;
    }
    int left_len = i - inL;
    root->l_child = create(inL, i-1, postL, postL+left_len-1);
    root->r_child = create(i+1, inR, postL+left_len, postR-1);
    return root;
}

void BFS(binTree *root){
    queue<binTree> que;
    root->level = 1;
    level_nodes[1].push_back(root->data);
    que.push(*root);
    while(!que.empty())
    {
        binTree head = que.front();
        que.pop();
        int level = head.level;
        if(head.l_child != NULL){
            head.l_child->level = level + 1;
            level_nodes[level+1].push_back(head.l_child->data);
            que.push(*head.l_child);
        }
        if(head.r_child != NULL){
            head.r_child->level = level + 1;
            level_nodes[level+1].push_back(head.r_child->data);
            que.push(*head.r_child);
        }
    }
}

void output()
{
    map<int, vector<int> >::iterator it;
    for(it = level_nodes.begin(); it != level_nodes.end(); it++)
    {
        if(it == level_nodes.begin()){
            cout << it->second[0];
            continue;
        }
        if(it->first % 2 == 0)
        {/*从左到右*/
            int len = it->second.size();
            for(int i = 0; i < len; i++)
                cout << " " << it->second[i];
        }
        else
        {
            int len = it->second.size();
            for(int i = len-1; i >= 0; i--)
                cout << " " << it->second[i];
        }
    }
}

int main()
{
    /*1127 ZigZagging on a Tree (30 分)*/
    #ifndef ONLINE_JUDGE
        freopen("test.txt", "r", stdin);
    #endif // ONLINE_JUDGE

    input();
    binTree *root = create(0, n-1, 0, n-1);
    BFS(root);
    output();
    return 0;
}