PAT 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


题目大意：通过中序遍历和后序遍历构建一棵树， 并交替的输出层序遍历；
思路：treeTraverse()构建这棵树， levelOrder()交替的层序遍历这棵树；
　　  在构建这棵树的时候， 记录下每个节点的深度，根据节点深度的不同， 把节点添加到不同的数组中， 就可以实现交替的层序遍历
　　　深度为奇数的层从左到右遍历， 复制从右到左遍历

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
vector<int> in(30), post(30), depth(30, 0), leftToRight[30], rightToleft[30];
int tree[30][2], root, idx1=0, idx2=0;
void treeTraverse(int &index, int height, int inl, int inr, int postl, int postr){
  int temp=post[postr], i=inl;
  if(inl>inr) return;
  index = postr;   
  depth[index] = height; //记录每个节点的深度
  while(i<=inr && in[i]!=temp) i++;
  treeTraverse(tree[index][0], height+1, inl, i-1, postl, postl+(i-inl)-1);
  treeTraverse(tree[index][1], height+1, i+1, inr, postl+i-inl, postr-1);
}

void levelOrder(){
  queue<int> q;
  q.push(root);
  int height=0, flag=true;
  while(q.size()){
    int temp = q.front();
      q.pop();
      //节点深度不同时， 表示开始遍历新的一层， 把原来的序号+1，
      //替换新的深度， 更改标识符
      //idx1是leftToRight的下标, idx2是rightToleft的下标
    if(depth[temp]!=height){
      if(flag) idx2++;
      else idx1++;
      flag = 1-flag;
        height=depth[temp];
    }
    //根据节点的深度不同， 把节点添加到不同的数组中
    if(depth[temp]%2==0) rightToleft[idx2].push_back(post[temp]);   
    else  leftToRight[idx1].push_back(post[temp]);  
    if(tree[temp][0]!=-1) q.push(tree[temp][0]);
    if(tree[temp][1]!=-1) q.push(tree[temp][1]);
  }
}
int main(){
  int n, i, j;
  scanf("%d", &n);
  fill(tree[0], tree[0]+60, -1);
  for(i=0; i<n; i++) scanf("%d", &in[i]);
  for(i=0; i<n; i++) scanf("%d", &post[i]);
  treeTraverse(root, 0, 0, n-1, 0, n-1);
  levelOrder();
  printf("%d", rightToleft[0][0]);
  for(i=1; i<idx1+idx2+1; i++){
      for(j=rightToleft[i/2].size()-1; j>=0 && i%2==0; j--) printf(" %d", rightToleft[i/2][j]);
      for(j=0; j<leftToRight[i/2].size() && i%2==1; j++) printf(" %d", leftToRight[i/2][j]);
  }
  return 0;
}