PAT (Advanced Level) Practise 1102. Invert a Binary Tree (25) 二叉树的层序和中序遍历

1102. Invert a Binary Tree (25)

时间限制

400 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

The following is from Max Howell @twitter:

Google: 90% of our engineers use the software you wrote (Homebrew), but you can't invert a binary tree on a whiteboard so fuck off.

Now it's your turn to prove that YOU CAN invert a binary tree!

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (<=10) which is the total number of nodes in the tree -- and hence the nodes are numbered from 0 to N-1. Then N lines follow, each corresponds to a node from 0 to N-1, and gives the indices of the left and right children of the node. If the child does not exist, a "-" will be put at the position. Any pair of children are separated by a space.

Output Specification:

For each test case, print in the first line the level-order, and then in the second line the in-order traversal sequences of the inverted tree. There must be exactly one space between any adjacent numbers, and no extra space at the end of the line.

Sample Input:

8
1 -
- -
0 -
2 7
- -
- -
5 -
4 6

Sample Output:

3 7 2 6 4 0 5 1
6 5 7 4 3 2 0 1

就是二叉树的遍历，注意下遍历的优先级就行了

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>

using namespace std;

const int maxn = 10 + 10;

struct node {
	int l, r;
}tn[maxn];

struct qn {
	int root, l, r; //要记录根节点和左右子节点信息
	qn(int root, int l, int r) : root(root), l(l), r(r) {}
};

char s1[5], s2[5];
int tree[maxn], N, cou;
bool vis[maxn];

void build(int root, int i) {
	tree[i] = root;
	if (root == -1) return;
	build(tn[root].l, i * 2);
	build(tn[root].r, i * 2 + 1);
}

//层序遍历其实就是个BFS
void lo(int root) {
	queue<qn> Q;

	Q.push(qn(root, 1 * 2, 1 * 2 + 1));

	bool first = true;
	while (!Q.empty()) {
		qn tn = Q.front(); Q.pop();
		if (first)
			printf("%d", tn.root);
		else
			printf(" %d", tn.root);
		if (first) first = false;
		int l = tn.l, r = tn.r;
		int ln = tree[l], rn = tree[r];
		//右优先
		if (rn != -1) {
			Q.push(qn(rn, r * 2, r * 2 + 1)); //注意更改左右节点信息
		}
		if (ln != -1) {
			Q.push(qn(ln, l * 2, l * 2 + 1)); //注意更改左右节点信息
		}
	}
}

//中序遍历其实就是个DFS
void io(int root, int i) {
	if (root != -1) {
		//右子树优先
		io(tn[root].r, i * 2 + 1);
		cou++;
		if (cou == 1)
			printf("%d", tree[i]);
		else
			printf(" %d", tree[i]);
		io(tn[root].l, i * 2);
	}
}

int main()
{
	scanf("%d", &N);
	for (int i = 0; i < N; i++) {
		scanf("%s%s", s1, s2);
		if (s1[0] != '-')
			tn[i].l = atoi(s1);
		else
			tn[i].l = -1;
		if (s2[0] != '-')
			tn[i].r = atoi(s2);
		else
			tn[i].r = -1;
	}
	memset(vis, false, sizeof(vis));
	for (int i = 0; i < N; i++) {
		if (tn[i].l != -1)
			vis[tn[i].l] = true;
		if (tn[i].r != -1)
			vis[tn[i].r] = true;
	}
	int root;
	//不是任何节点的左右子节点的那个数就是根节点
	for (int i = 0; i < N; i++) {
		if (!vis[i]) {
			root = i;
			break;
		}
	}
	memset(tree, -1, sizeof(tree));
	//建树
	build(root, 1);
	lo(root);
	puts("");
	cou = 0;
	io(root, 1);
	puts("");
	return 0;
}