数据结构与算法题 pta 7-3 树的同构 （25 分） （C++）

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

输入格式:

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

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

1. 图1
2. 图2

输入样例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
做这题的步骤是:

• 建树（根据题目的输入，使用结构数组，即静态链表作为树的储存结构）
• 补成满二叉树（想象成二叉树，由于题目可以是任意树，没有结点的位置用X来代替）
• 两棵树建好后，使用层序遍历知识（Queue实现），跟其他百度的代码思路不一样,我是利用每层的结点进行实时比较，如果不是相反结点序列 比如 树A的某一层结点为 DEG 如果树B的同层结点顺序不为GED，那么返回No,思路不一样的是,避开了繁琐的判断条件，如果不断进行判断每个结点，时间复杂度很高！
• 输出返回结果
  
  时间复杂度为O(nlog(n))

#include<stdio.h>
#include<iostream> 
#include<vector>
#include<queue>
#define max_nodeNum 12
typedef struct tree *Tree ;
using namespace std;

struct oneGroupNodeData{
	string no;
	int left;
	int right;
};
int createNewTree(int index); // index means create treeA or treeB ?
void printTree(struct oneGroupNodeData tree[], int root);
bool coutTreeArray(vector<string>trees[]);
struct oneGroupNodeData tree[2][max_nodeNum]; // treeA and treeB node data
vector<string>treeNode[2];
bool con = true;
int ind = 0;
int sign[max_nodeNum]; // sign ,in order to sure tree's root ,it will be root where index qeuals to 0,other index will be 1
int depthNodeNum[max_nodeNum];
int main(){
	int root[2]; //treeA toot,treeB root	
	for(int i = 0;i<2;i++)
		root[i]  = createNewTree(i); // 建数,   顺便get Root 根结点 
	for(int i = 0;i<2;i++){
		ind = i;
		printTree(tree[i],root[i]);   //得到层序遍历输出和每层有多少个结点 
	}
	bool result = coutTreeArray(treeNode); //判断 
	if(result)                      //输出结果 
		cout<<"Yes";
	else
		cout<<"No";
	return 0;
}
int createNewTree(int index){
	int nodeNum;
	int i,j,k;
	int rootIndex = 0;
	string n,l,r;
	//重置变量
	con = true;  //reset
	for(i = 0;i<max_nodeNum;i++)sign[i] = 0; //reset each times come
	//
	cin>>nodeNum;
	if(nodeNum==0)con = false;   
	for(i = 0;i<nodeNum;i++){
		cin>>n>>l>>r;
		tree[index][i].no = n;
		if(l.at(0)!='-'){
			tree[index][i].left =  l.at(0)-48;
			sign[tree[index][i].left] = 1;
		}
		else
			tree[index][i].left = -1;
		if(r.at(0)!='-'){
			tree[index][i].right =  r.at(0)-48;
			sign[tree[index][i].right] = 1;
		}
		else
			tree[index][i].right = -1;
	}
	for(i = 0;i<nodeNum;i++)  //get root 
		if(sign[i]!=1){
			rootIndex = i;
			break;
		}
	return rootIndex;
}
void printTree(	struct oneGroupNodeData tree[],int root){  // 层序遍历 
	queue<struct oneGroupNodeData>Queue;   
	struct oneGroupNodeData temp,nodeX;
	if(con){
		Queue.push(tree[root]);

		while(!Queue.empty()){
			temp = Queue.front();
			Queue.pop(); 
			treeNode[ind].push_back(temp.no);
			if(temp.left!=-2){
				if(temp.left!=-1){
					Queue.push(tree[temp.left]);		
				}
				else{
						nodeX.no = "X";
						nodeX.left = -2;
						nodeX.right = -2;
						Queue.push(nodeX);
				}
				if(temp.right!=-1){
					Queue.push(tree[temp.right]);		
				}
				else{
						nodeX.no = "X";
						nodeX.left = -2;
						nodeX.right = -2;
						Queue.push(nodeX);		
					}
				}
		}
	} 
} 
bool coutTreeArray(vector<string>trees[]){
	string cA,cB;
	int cardinal = 1; // start to root, after *2
	int k = 0;
	int temp = 0;
		for(int i = 0;i<max_nodeNum;i++){
			cA = "";cB = "";
			if(k>=trees[0].size())break;
			for(k;k<temp+cardinal;k++){
				if(k>=trees[0].size())break;
				if(trees[0][k]!="X")cA.append(trees[0][k]);
				if(trees[1][k]!="X")cB.append(trees[1][k]);	
			}
			cardinal*=2;	
			temp = k;
			//judge is or not 同构 
			if(cA.length()!=cB.length())return false;
			for(int p = 0;p<cA.length();p++)
				if(cA.at(cA.length()-p-1)!=cB.at(p))return false;
			//
		}
		return true;
}