PAT (Advanced Level) 1127. ZigZagging on a Tree (30)

1127. ZigZagging on a Tree (30)

时间限制

400 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

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

这道题今晚终于AC了，相比前面两道看不懂的25分的题目，这道题就是传说中的，看得懂但是不会做的类型。。。。

所以我在想，除非我做过类似的题目，不然我是不可能在那么短的考试时间里面写出来并且AC的。。。

这道题，暴力算确实可以，而且我也百度了，看见有些大佬是用双向链表，有的说用vector<vector<int> > a;来解决，鉴于我目前对vector掌握的还不是很熟练，所以我想了一晚上，终于想到用栈结合队列，然后把他们一起放进BFS里面来输出~

想到用栈，是因为，题目要求是反方向的Z字型输出，然后刚开始也是考虑在create树的时候，记录他们每个点（node）的层值，

然后判断奇偶性来输出，但是后来觉得为什么不用BFS输出呢？

比如只要在奇数层的时候（从1开始），判断当前队列是否还有数字，如果还有就说明是上一层偶数层的数字还没有完全输出，此时要耐心“等候”，也就是要将他们的左右孩子们读入栈里面，直到判断到队列已经空啦，队列要求要加入新的数字的时候，我们再将栈里面的数值“一口气”全部输出~~在偶数层也是类似的道理，但是要注意在将奇数层的数字加入队列的时候，要先加入右孩子，偶数层要先加入左孩子~~（这是因为反方向Z字决定的性质）

下面就是代码~~

#include<cstdio>
#include<queue>
#include<stack>
#include<string.h>
#include<algorithm>
#include<math.h>

using namespace std;

const int maxn = 35;

int n;
int f = 0;
int xx = 0;

int pos[maxn], in[maxn];

struct node {
int data;
int layer;
node* lchild;
node* rchild;
};

node* create(int posL, int posR, int inL, int inR, int ll) {
node* root = new node;

if (posL > posR) {
return NULL;
}

root->data = pos[posR];
root->layer = ll;

int k;
for (k = inL; k <= inR; k++) {
if (in[k] == pos[posR]) {
break;
}
}

int num = k - inL;
root->lchild = create(posL, posL + num - 1, inL, k - 1, ll + 1);
root->rchild = create(posL + num, posR - 1, k + 1, inR, ll + 1);
return root;
}

void BFS(node* root) {
stack<node*> sss;

queue<node*> q;
q.push(root);

while (!q.empty()) {
node* top = q.front();
q.pop();

if (f != n - 1) {
printf("%d ", top->data);
f++;
}
else {
printf("%d\n", top->data);
break;
}

if ((top->layer) % 2 != 0) {
if (top->rchild != NULL) { sss.push(top->rchild); }
if (top->lchild != NULL) { sss.push(top->lchild); }

if (q.empty()) {
while (!sss.empty()) {
node* temp = sss.top();
sss.pop();
q.push(temp);
}
}
}
else {
if (top->lchild != NULL) {
sss.push(top->lchild);
}
if (top->rchild != NULL) {
sss.push(top->rchild);
}

if (q.empty()) {
while (!sss.empty()) {
node* temp = sss.top();
sss.pop();
q.push(temp);
}
}

}
}
}

int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &in[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &pos[i]);
}
node* root = create(0, n - 1, 0, n - 1, 1);
BFS(root);
return 0;
}