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;
}