PAT-A1127. 二叉树-中序后序建树，Z字遍历

题目链接：https://www.patest.cn/contests/pat-a-practise/1127
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

中序后序建树，或前序中序建树，主要是理清思路，前序的第一个结点或后序的最后一个结点是根结点，根据根结点分割中序，左右子数组分别就是左右子树，然后再将子数组对应前序或后序数组中寻找该子树的根结点，循环如此。

Z字形遍历的关键点在于层序遍历并分层输出，分层的方法在上一篇博客中已经讲了，就是标记每层最左边的结点，在输出过程中根据层数选择正序或倒序输出即可。

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;

struct BTree {
    int data;
    BTree* lchild;
    BTree* rchild;
};
BTree* T;
int indata[35];
int posdata[35];

BTree* Construct(int* posBegin, int* inBegin, int len){
    BTree* root = new BTree();
    root->data = posBegin[len-1];
    root->lchild = NULL;
    root->rchild = NULL;
    int* rootInorder = inBegin;
    while (rootInorder <= inBegin+len && *rootInorder != root->data) {
        ++rootInorder;
    }
    int leftLen = (int)(rootInorder - inBegin);
    int rightLen = len - leftLen - 1;
    int* rightPosBegin = posBegin + leftLen;

    if(leftLen > 0){
        root->lchild = Construct(posBegin, inBegin, leftLen);
    }
    if(rightLen > 0){
        root->rchild = Construct(rightPosBegin, rootInorder+1, rightLen);
    }

    return root;
}

void LevelOrder(BTree* root){
    queue<BTree*> qt;
    vector<int> printOut;
    qt.push(root);
    int cnt = 0;
    BTree* left = NULL;
    bool findLeft = false;

    while (!qt.empty()) {
        BTree* tr = qt.front();
        qt.pop();
        if(tr == left) {
            if(!(cnt & 1)) reverse(printOut.begin(), printOut.end());
            for(int i = 0; i < printOut.size(); ++i){
                cout << printOut[i] << " ";
            }
            findLeft = false;
            left = NULL;
            printOut.clear();
            cnt++;
        }
        printOut.push_back(tr->data);
        if(tr->lchild){
            qt.push(tr->lchild);
            if(!findLeft){
                findLeft = true;
                left = tr->lchild;
            }

        }
        if(tr->rchild){
            qt.push(tr->rchild);
            if(!findLeft){
                findLeft = true;
                left = tr->rchild;
            }
        }

    }
    if(!(cnt & 1)) reverse(printOut.begin(), printOut.end());
    for(int i = 0; i < printOut.size(); ++i){
        cout << printOut[i];
        if(i<printOut.size()-1)
            cout << " ";
        else
            cout << endl;
    }

}

int main()
{
    int n;
    cin >> n;
    for(int i = 0; i < n; ++i)
        cin >> indata[i];
    for(int i = 0; i < n; ++i)
        cin >> posdata[i];
    T = Construct(posdata, indata, n);
    LevelOrder(T);

    return 0;
}