1127 ZigZagging on a Tree (30 分)

原题目： 1127 ZigZagging on a Tree (30 分)

题意

给出一棵二叉树的结点总数N(≤30)以及中序序列和后序序列（无重复值），
👉按“之”字型的顺序层序输出。

分析

一开始是用二叉链表存储结点，发现链表难以实现“之”型输出；而后想改用静态二叉链表，但发现二者都无本质上的差别。学习了柳婼学姐的代码后，发现

1. 解决输出顺序问题的 关键在于——在生成层序序列时，① 利用vector容器的便利，按层序存储结点，即行号为结点所在层次；② 队列元素另外生成为 node{post下标, 层次}
2. 还有一个 亮点 是——建树和生成层序序列时，数组存储的是在post中的下标——存储下标而非权值的好处是，当有多个相同权值的结点时，防止结果出错。

实现思路：

1. 中序后序建树 DFS：
   ① 用数组tree[i][]存树，但不直接存权值，而是存post下标——⭐⭐tree[i][0]表示post[tree[i][0]]是post[i]的左孩子，tree[i][1]表示post[tree[i][1]]是post[i]的右孩子——用 列号控制左右孩子，行号为父结点下标，元素为结点下标。
   ② ⭐⭐用 引用型参数返回值 而不用return。
2. 生成层序遍历序列 BFS：
   ① 入队结点node只需存储：在post中的下标index、所在层次depth。
   ② 用数组tree的值判断是否有孩子结点（见👇注意点）。

知识点

1. 不用（静态/动态）链表存储结点，结点不存数据和孩子地址——① 结点用二维数组存储且只存下标，② 数据只需存输入的数组中，③ 左右孩子用二维数组的列号标识。
2. 用引用型参数返回值。
3. 队列元素边入队边创建：用 node{} 直接创建，直接加入队列中。

q.push(node{root, 1});

//也可以直接花括号
q.push({root, 1});

4. 中序后序建树——关键在如何返回根结点地址，这里用的传引用。
5. 生成层序遍历序列——用vector容器，按层序（行号）将每层结点push_back到数组中。

CODE

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int n, tree[30][2];  //数组tree记录孩子结点在post的下标，行号记录根结点在post的下标，列号记录是左0/右1孩子
int root = -1;  //新建空树
int height = -1;  //树高
vector<int> in, post, result[31];
struct node{
    int index, depth;  //index为在post中的下标
};
void DFS(int &root, int postl, int postr, int inl, int inr);  //中序后序建树
void BFS();  //生成层次序列
int main()
{
    cin >> n;
    in.resize(n+1), post.resize(n+1);
    for ( int i=1; i<=n; i++ ) cin >> in[i];
    for ( int i=1; i<=n; i++ ) cin >> post[i];
    //建树
    DFS(root, 1, n, 1, n);
    //生成层序遍历序列
    BFS();
    //输出：奇数层从右往左，偶数层从左往右
    cout << post[result[1][0]];  //先输出第一层
    for ( int i=2; i<=height; i++ ){  //从第二层开始输出
        if ( i%2 ){
            for ( int j=result[i].size()-1; j>=0; j-- )
                printf(" %d", post[result[i][j]]);
        }
        else{
            for ( int j=0; j<result[i].size(); j++ )
                printf(" %d", post[result[i][j]]);
        }
    }
    
    return 0;
}
void DFS(int &root, int postl, int postr, int inl, int inr){  //注意：传引用，会改变root为在根结点下标（后序序列）
    if ( inl>inr ) return;  //递归边界：区间小于0
    //通过引用返回给root后序序列的最后一个元素的下标，即根结点下标
    root = postr;
    //找到根结点在中序序列中的位置
    int k = inl;
    while( in[k]!=post[postr] ) k++;
    //递归式
    DFS(tree[root][0], postl, postl+(k-inl)-1, inl, k-1);  //往左子树递归
    DFS(tree[root][1], postl+k-inl, postr-1, k+1, inr);   //往右子树递归
}
void BFS(){  //生成层序遍历序列result（以在后序中的下标为元素）
    queue<node> q;
    q.push(node{root, 1});  //结点{根结点后序下标，层次}
    while( !q.empty() ){
        node tmp = q.front();  //存储队首元素
        //访问队首元素：按层次进入数组，数组元素为在post中的下标
        result[tmp.depth].push_back(tmp.index);
        //弹出队首元素
        q.pop();
        //更新树高
        if ( tmp.depth>height ) height = tmp.depth;
        //弹出结点的左右孩子入队
        if ( tree[tmp.index][0]!=0 )
            q.push(node{tree[tmp.index][0], tmp.depth+1});  //tree[tmp.index][0]是tmp.index的左孩子，层次+1
        if ( tree[tmp.index][1]!=0 )
            q.push(node{tree[tmp.index][1], tmp.depth+1});
    }
}

注意点

数组中，除了被赋值的部分，其余部分默认初值为0。
因此，上述CODE的BFS函数中，用数组tree的值（实为下标）判断是否有孩子，则 需让存的下标从1开始，而不能从0开始了，否则与无孩子结点的情况没有区别。