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

题意：根据中序和后序建树，对树进行层序遍历，若定义根为第0层，则，在奇数层从左到右，在偶数层从右到左。

思路：可以在层序遍历是定义层高，每一层数据不一个一个输出，保存在容器里，遍历完一层后，根据奇数层正序输出，偶数层逆序输出即可。

#include<iostream>
#include<queue>


#include<vector>

using namespace std;
struct node{

    int data;
    node * lchild;
    node * rchild;

};


node * creat(vector<int> &inorder, vector<int> &postorder, int in_start, int in_end, int post_start, int post_end){

    if(in_start > in_end || post_start > post_end){

        return NULL;
    }
    node * root = new node;
    root -> data = postorder[post_end];
    int i;
    for(i = 0; i < inorder.size(); i++){
        if(inorder[i] == postorder[post_end])
            break;
    }

    root -> lchild = creat(inorder, postorder, in_start, i - 1, post_start, post_start + i - 1 -in_start);
    root -> rchild = creat(inorder, postorder, i + 1, in_end , post_end - in_end + i, post_end - 1);
                                    



    return root;



}
void level_order(node t){
    queue<node> q;
    
    q.push(t);
    int cru_size = q.size();
    int level = 0;
    while (!q.empty())
    {
        vector<int> vec;
        while (cru_size--)
        {
            vec.push_back(q.front().data);
            // cout << q.front().data << " ";
            if(q.front().lchild != NULL)
                q.push(*q.front().lchild);
            if(q.front().rchild != NULL)
                q.push(*q.front().rchild);
            q.pop();
        }

        if(level == 0){
            printf("%d", vec[0]);
        }else
        {
            if(level % 2 == 0){
                for(int i = vec.size() - 1; i >= 0; i--){
                    printf(" %d", vec[i]);
                }
            }else
            {
                for(int i = 0; i < vec.size(); i++){
                    printf(" %d", vec[i]);
                }
                
            }
            
        }
        
        level++;
        cru_size = q.size();


    }
    

}


int main(){

    int n;
    cin >> n;

    vector<int> inorder(n);
    vector<int> postorder(n);

    for(int i = 0; i < n; i++){

        scanf("%d", &inorder[i]);

    }
    for(int i = 0; i < n; i++){
        
        scanf("%d", &postorder[i]);

    }

    node * tree;

    tree = creat(inorder, postorder, 0, n - 1, 0, n - 1);
    
    level_order(*tree);



    return 0;
}