PTA：列出叶结点 (20 分)；树的同构 (20 分)

树的同构 (20 分)：

给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图2就不是同构的。

图1
图2

现给定两棵树，请你判断它们是否是同构的。

输入格式:

输入给出2棵二叉树树的信息。对于每棵树，首先在一行中给出一个非负整数N (≤10)，即该树的结点数（此时假设结点从0到N−1编号）；随后N行，第i行对应编号第i个结点，给出该结点中存储的1个英文大写字母、其左孩子结点的编号、右孩子结点的编号。如果孩子结点为空，则在相应位置上给出“-”。给出的数据间用一个空格分隔。注意：题目保证每个结点中存储的字母是不同的。

输出格式:

如果两棵树是同构的，输出“Yes”，否则输出“No”。

输入样例1（对应图1）：

8
A 1 2
B 3 4
C 5 -
D - -
E 6 -
G 7 -
F - -
H - -
8
G - 4
B 7 6
F - -
A 5 1
H - -
C 0 -
D - -
E 2 -

结尾无空行

输出样例1:

Yes

结尾无空行

输入样例2（对应图2）：

8
B 5 7
F - -
A 0 3
C 6 -
H - -
D - -
G 4 -
E 1 -
8
D 6 -
B 5 -
E - -
H - -
C 0 2
G - 3
F - -
A 1 4

输出样例2:

No

列出叶结点 (20 分)：

对于给定的二叉树，本题要求你按从上到下、从左到右的顺序输出其所有叶节点。

输入格式：

首先第一行给出一个正整数 N（≤10），为树中结点总数。树中的结点从 0 到 N−1 编号。随后 N 行，每行给出一个对应结点左右孩子的编号。如果某个孩子不存在，则在对应位置给出 "-"。编号间以 1 个空格分隔。

输出格式：

在一行中按规定顺序输出叶节点的编号。编号间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

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

结尾无空行

输出样例：

4 1 5

结尾无空行

———————————————————————————————————————————

这两题放一块儿说了。因为难点都在于如何根据题目输入构造一个二叉树，两道题的输入方式都是一样，所给的节点可能是无序的。

我的思路是：创建一个结构体数组指针，以2题为例，首先初始化每个节点的数据T[i]->data=i;，之后输入只要将T[i]的左右指针指向相应节点就可以了，空的话指向NULL；

于是在2中构造代码如下：

tree * T[n];
	for(int i=0;i<n;i++){ //初始化节点
		T[i]=(struct tree *)malloc(sizeof(struct tree));
		T[i]->data=i;
	}
	int check[n]={0}; //寻找根节点
	for(int i=0;i<n;i++){
		char l,r;
		cin>>l>>r;
		if(l=='-') T[i]->lchild=NULL;
		else{
			T[i]->lchild=T[l-'0'];
			check[l-'0']=1;
		}
		if(r=='-') T[i]->rchild=NULL;
		else{
			T[i]->rchild=T[r-'0'];
			check[r-'0']=1;
		}
	}

其中，check数组的作用是寻找根节点，0代表是根节点，1代表不是。

具体做法是将一个节点的左右孩子都标记为1（如果有的话），剩下0就是根节点。

下面找到check[i]=0的位置就是根节点：

int head;
	for(int i=0;i<n;i++) if(check[i]==0){
		head=i;
		break;
	}

好了，现在已经构建出了二叉树，对于不熟悉用结构体的我已经度过了大部分难关，二叉树在手，法力无边，剩下的就很容易了。

思路：1题写一个判断函数，先判断根节点，再递归判断其左右子树（具体见代码）

2题 注意到访问叶节点是从上到下，从左到右。所以一般的叶结点访问算法不符合题目要求。可以先用层序遍历，再判断节点是否为叶子。

2题代码如下：

#include<iostream>
#include<stdlib.h>
#include<queue>
using namespace std;
struct tree{
	int data;
	struct tree * lchild;
	struct tree * rchild;
};
bool judge(tree * T) //判断是否为叶
{
	if(T->lchild==NULL&&T->rchild==NULL) return true;
	return false;
}
void print_leaves(tree *T) //传入根节点打印树的叶
{
	queue<tree *>q; //创建树的指针队列
	int flag=1;
	q.push(T);
	while(!q.empty()){
		if(judge(q.front()))
		if(flag){ //第一个单独输出
			cout<<q.front()->data;
			flag=0;
		}
		else cout<<" "<<q.front()->data;
		if(q.front()->lchild) q.push(q.front()->lchild);
		if(q.front()->rchild) q.push(q.front()->rchild); //左右孩子入队
		q.pop();
	}
}
int main()
{
	int n;
	cin>>n;
	tree * T[n];
	for(int i=0;i<n;i++){
		T[i]=(struct tree *)malloc(sizeof(struct tree));
		T[i]->data=i;
	}
	int check[n]={0};
	for(int i=0;i<n;i++){
		char l,r;
		cin>>l>>r;
		if(l=='-') T[i]->lchild=NULL;
		else{
			T[i]->lchild=T[l-'0'];
			check[l-'0']=1;
		}
		if(r=='-') T[i]->rchild=NULL;
		else{
			T[i]->rchild=T[r-'0'];
			check[r-'0']=1;
		}
	}
	int head;
	for(int i=0;i<n;i++) if(check[i]==0){
		head=i;
		break;
	}
	print_leaves(T[head]);
	return 0;
}

结果：

当时做题时，我是先写的2.而1的建树方式完全可以沿用2.

先不要慌，看看上一个的建树代码，由于我们的惯性思维，建立结点结构体的时候，左右孩子理所当然的用了指针类型，对于结构体数组指针，每一个都是一个指向数组的指针。稍微想想就知道指针完全是多余的，因为通过下标就可以找到结构体，这样左右孩子不用指针维护，只需要int就可以索引到了。

1整体代码如下：

#include<iostream>
using namespace std;
struct tree{
	char data;
	int lc; //左孩子
	int rc; //右孩子
}T1[10],T2[10];
int createT(tree T[],int n) //建立二叉树，返回根节点
{
	int check[n]={0};
	for(int i=0;i<n;i++){
		char x,y,z;
		cin>>x>>y>>z; //这里不太严谨，只适用于结点不超过10的情况（本题数据量小）
		T[i].data=x;
		if(y=='-') T[i].lc=-1;
		else{
			T[i].lc=y-'0'; //直接指向相应结点下标
			check[y-'0']=1;
		}
		if(z=='-') T[i].rc=-1;
		else{
			T[i].rc=z-'0';
			check[z-'0']=1;
		}
	}
	for(int i=0;i<n;i++)
	if(check[i]==0) return i;
	return -1;
}
bool judge(int r1,int r2) //传入两个根节点
{
	if(r1==-1&&r2==-1) return true; //都是空树
	if((r1==-1&&r2!=-1)||(r1!=-1&&r2==-1)||T1[r1].data!=T2[r2].data) return false;
//一个空一个不空，根节点不相等的情况
	if((judge(T1[r1].lc,T2[r2].lc)&&judge(T1[r1].rc,T2[r2].rc))||(judge(T1[r1].lc,T2[r2].rc)&&judge(T1[r1].rc,T2[r2].lc))) return true;
//根节点相等，尝试1左树2左树，1右2右是否匹配，或者1右2左，1左2右是否配对
	else return false; 
}
int main()
{
	int n,root1,root2;
	cin>>n;
	root1=createT(T1,n);
	cin>>n;
	root2=createT(T2,n);
	if(judge(root1,root2)) cout<<"Yes";
	else cout<<"No";
	return 0;
}

结果：