【PAT】1102. Invert a Binary Tree (25)

最新推荐文章于 2022-03-30 22:47:47 发布

原创最新推荐文章于 2022-03-30 22:47:47 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#PAT #树

PAT 专栏收录该内容

107 篇文章

订阅专栏

本文介绍了如何通过队列和栈分别实现层序遍历和中序遍历，以反转给定的二叉树，并输出反转后的层序遍历和中序遍历结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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 <iostream>
#include <vector>
#include <queue>
#include <stack>
using namespace std;

struct node{
	node(){
		left = -1;
		right = -1;
		father = -1;
		level = 0;
	}
	int index;
	int left;
	int right;
	int father;
	int level;
};

int main(int argc, char** argv) {
	int n, i;
	scanf("%d",&n);
	getchar();
	vector<node> tree(n);
	char L, R;
	int left , right;
	for(i=0; i<n; i++){
		tree[i].index = i;
		scanf("%c %c",&L, &R);
		getchar();
		if(isdigit(L)){
			left = L - '0';
			tree[i].right = left ;
			tree[left].father = i;
		}
		if(isdigit(R)){
			right = R - '0';
			tree[i].left = right;
			tree[right].father = i;
		}		
	}
	
	int root;
	for(i=0; i<n; i++){
		if(tree[i].father == -1){		 
			root = i;
			break;
		}
	}
	
	queue<int> que;
	int level, index;
	que.push(root);
	printf("%d",root);
	bool first = false;
	node tmpNode;
	while(!que.empty()){	
		tmpNode = tree[que.front()];
		if(!first){
			first = true;
		}else{
			printf(" %d",que.front());
		}
		level = tmpNode.level;
		left = tmpNode.left;
		right = tmpNode.right;
		if(left != -1){
			que.push(left);
		}
		if(right != -1){
			que.push(right);
		}
		que.pop();
	}
	printf("\n");
		
	stack<int> sta;
 	sta.push(root); 
 	int cnt = 0;
 	while(!sta.empty()){
 		index = sta.top();
		tmpNode = tree[index];
		left = tmpNode.left;
		while(left != -1){
			tree[index].left = -1;
			sta.push(left);
			tmpNode = tree[left];
			index = tmpNode.index;
			left = tmpNode.left;		 
		} 
 		cnt++;
 		if(cnt==n){
 			printf("%d\n",sta.top());
		}else{
			printf("%d ",sta.top());
		}
		sta.pop();
	    if(tmpNode.right != -1){
	    	sta.push(tmpNode.right);
		}		 	
	}
	
	return 0;
}

另一种写法：
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

struct node{
	node(){
		fa = -1;
		left = -1;
		right = -1;
	}
	int id, fa, left, right;
};
vector<node> tree;

void inOrder(int r, vector<int> &vec){
	if(tree[r].right != -1){
		inOrder(tree[r].right,vec);
	}
	vec.push_back(r);
	if(tree[r].left!=-1){
		inOrder(tree[r].left,vec);
	}	
}

void levelOrder(int r, vector<int> &vec){
	queue<node> que;
	que.push(tree[r]);
	while(!que.empty()){
		node n = que.front();
		if(n.right!= -1){
			que.push(tree[n.right]);
		}
		if(n.left!=-1){
			que.push(tree[n.left]);
		}
		vec.push_back(n.id);
		que.pop();
	}
}

void show(vector<int> &vec){
	int i;
	for(i=0; i<vec.size(); i++){
		if(i==0){
			printf("%d",vec[i]);
		}else{
			printf(" %d",vec[i]);
		}
	}	
	printf("\n");
}

int main(int argc, char** argv) {
	int N;
	scanf("%d",&N);
	getchar();
	int i;
	tree.resize(N);
	char a, b;
	for(i=0; i<N; i++){
		tree[i].id = i;
		scanf("%c %c",&a,&b);
		getchar();
		if(isdigit(a)){
			tree[a-'0'].fa = i;
			tree[i].left = a-'0';
		}
		if(isdigit(b)){
			tree[b -'0'].fa = i;
			tree[i].right = b-'0';
		}
	}
	int root;
	for(i=0; i<N; i++){
		if(tree[i].fa==-1){
			root = i;
			break;
		}
	}
	vector<int> level;
	levelOrder(root, level);
	show(level);
	
	vector<int> vec;
	inOrder(root,vec);
	show(vec);
	
	return 0;
}