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

思路：之字型层次遍历。进行两次层次遍历，从左到右，和从右到左；从左到右比遍历，如果节点在偶数层，则将其保存起来；同样，从右到左遍历，如果该节点在奇数层，则将其保存起来。

程序：

#include <cstdio>
#include <vector>
#include <queue>
#include <unordered_map>
using namespace std;
struct node
{
  int data;
  struct node *lchild,*rchild;
};
struct node* create(vector<int> v1,vector<int> v2,int low1,int high1,int low2,int high2)
{
  if(low1 > high1) return NULL;
  struct node* root = (struct node*)malloc(sizeof(struct node));
  root->data = v2[high2];
  int pos = low1;
  while(v1[pos] != v2[high2])
  {
    pos++;
  }
  root->lchild = create(v1,v2,low1,pos-1,low2,low2+pos-low1-1);
  root->rchild = create(v1,v2,pos+1,high1,low2+pos-low1,high2-1);
  return root;
}
vector<vector<int>> v(31);
unordered_map<struct node*,int> mymap;
unordered_map<struct node*,int> mmap;
int height = 0;
void l2r(struct node* root)
{
  queue<struct node*> q;
  q.push(root);
  mymap[root] = 1;
  while(!q.empty())
  {
    struct node * temp = q.front();
    if(mymap[temp] % 2 == 0)
    {
      v[mymap[temp]].push_back(temp->data);
    }
    if(mymap[temp] > height)
      height = mymap[temp];
    if(temp->lchild)
    {
      q.push(temp->lchild);
      mymap[temp->lchild] = mymap[temp] + 1;
    }
    if(temp->rchild)
    {
      q.push(temp->rchild);
      mymap[temp->rchild] = mymap[temp] + 1;
    }
    q.pop();
  }
}
void r2l(struct node* root)
{
  queue<struct node*> q;
  q.push(root);
  mmap[root] = 1;
  while(!q.empty())
  {
    struct node* temp = q.front();
    if(mmap[temp] % 2 == 1)
    {
      v[mmap[temp]].push_back(temp->data);
    }
    if(temp->rchild)
    {
      q.push(temp->rchild);
      mmap[temp->rchild] = mmap[temp] + 1;
    }
    if(temp->lchild)
    {
      q.push(temp->lchild);
      mmap[temp->lchild] = mmap[temp] + 1;
    }
    q.pop();
  }
}
int main()
{
  int n;
  scanf("%d",&n);
  vector<int> in,post;
  for(int i = 0; i < n; i++)
  {
    int data;
    scanf("%d",&data);
    in.push_back(data);
  }
  for(int i = 0; i < n; i++)
  {
    int data;
    scanf("%d",&data);
    post.push_back(data);
  }
  struct node* root = create(in,post,0,n-1,0,n-1);
  l2r(root);
  r2l(root);
  int cnt = 0;
  for(int i = 1; i <= height; i++)
  {
    for(int j = 0; j < v[i].size(); j++)
    {
      if(cnt == 0)
      {
        printf("%d",v[i][j]);
        cnt++;
      }
      else
        printf(" %d",v[i][j]);
    }
  }
  return 0;
}