（c语言）（非递归）判断是否是同构二叉树

树的同构

想必递归大家都知道了吧，这是我突然想到的，判断树的同构其实不用建树，所以这里用非递归也挺好写；
时间复杂度是O（n²）；
空间复杂度是O（1）；

利用慕课的题目来说明
给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图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

我的想法是既然是判断，那么也就没必要去建树了，这里的特点就是两棵树上相同的父节点的左右子树是相同的，只要满足这个，说明就是同构二叉树

#include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996)

typedef struct Node {
 char data;
 char leftc;
 char rightc;
}Gnode;//保存输入的信息

void Creattree(Gnode P[20]);

void Com(Gnode P1[20], Gnode P2[20]);//判断是否是二叉树

int all;

int main() {
   int h;//h为1说明是二叉树，是0说明不是
   Gnode P1[20];
   Gnode P2[20];
   Creattree(P1);//将第一颗树的信息保存至P1
   Creattree(P2);//将第二颗树的信息保存至P2
   h = Com(P1, P2);
   if (h == 1)
      printf("Yes");
   system("pause");
   return 0;
}

void Creattree(Gnode P[20])函数

void Creattree(Gnode P[20]) {
 scanf("%d", &all);
 getchar();//用来除去回车符
 for (int i = 0; i < all; i++) {
  scanf("%c %c %c", &P[i].data, &P[i].leftc, &P[i].rightc);
  getchar();//用来除去回车符
 }
}

int Com(Gnode P1[20], Gnode P2[20])函数虽然有点长但逻辑很简单
就是分第一个父节点和第二个父节点孩子的情况
一、两个都有两个孩子
二、两个都是叶节点
三、两个只有一个孩子（这个要分左右孩子所以代码略显繁琐）
只有一个孩子的情况下要分：
1、第一个只有左孩子，第二个只有右孩子
2、第一个只有右孩子，第二个个只有左孩子
3、两个都是左孩子
4、两个都是右孩子
四、两个拥有孩子数不一样，这就不用考虑肯定不是同构

int Com(Gnode P1[20], Gnode P2[20]) {
 int j;
 int i;
 for (i = 0; i < all; i++) {
    for (j = 0; j < all; j++) {
        if (P1[i].data == P2[j].data) {//找到相同父节点
              if (P1[i].leftc != '-'&&P2[j].leftc != '-'&&P1[i].rightc != '-'&&P2[j].rightc != '-') {//如果相同父节点左右儿子都有
                   int L1 = P1[i].leftc - '0';
                   int L2 = P2[j].leftc - '0';
                   int R1 = P1[i].rightc - '0';
                   int R2 = P2[j].rightc - '0';//将字符串转换为数字，之后这样的操作都是这个目的
                   if ((P1[L1].data == P2[L2].data&&P1[R1].data == P2[R2].data) || (P1[L1].data == P2[R2].data&&P1[R1].data == P2[L2].data))//判断孩子节点是否是一样，之后的操作都一样
                        break;
                   else {
                         printf("No");
                         return 0;
                   }
               }
               else if (P1[i].leftc == '-'&&P2[j].leftc == '-'&&P1[i].rightc == '-'&&P2[j].rightc == '-')//如果相同父节点左右儿子都没有，则判断下一个节点
                    break;
               else if (P1[i].leftc != '-'&&P2[j].leftc == '-'&&P1[i].rightc == '-'&&P2[j].rightc != '-') {//第一个只有左孩子，第二个只有右孩子
                    int L1 = P1[i].leftc - '0';
                    int R2 = P2[j].rightc - '0';
                    if (P1[L1].data == P2[R2].data)
                        break;
                    else {
                        printf("No");
                        return 0;
                    }
                }
               else if (P1[i].leftc == '-'&&P2[j].leftc != '-'&&P1[i].rightc != '-'&&P2[j].rightc == '-') {//第一个只有右孩子，第二个个只有左孩子
                     int L2 = P2[j].leftc - '0';
                     int R1 = P1[i].rightc - '0';
                     if (P1[R1].data == P2[L2].data)
                         break;
                     else {
                         printf("No");
                         return 0;
                     }
                 }
                else if (P1[i].leftc != '-'&&P2[j].leftc != '-'&&P1[i].rightc == '-'&&P2[j].rightc == '-') {//第一个只有左孩子，第二个也只有左孩子
                     int L2 = P2[j].leftc - '0';
                     int L1 = P1[i].leftc - '0';
                     if (P1[L1].data == P2[L2].data)
                         break;
                     else {
                         printf("No");
                         return 0;
                     }
                }
                else if (P1[i].leftc == '-'&&P2[j].leftc == '-'&&P1[i].rightc != '-'&&P2[j].rightc != '-') {//第一个只有右孩子，第二个也只有右孩子
                      int R2 = P2[j].rightc - '0';
                      int R1 = P1[i].rightc - '0';
                      if (P1[R1].data == P2[R2].data)
                      break;
                      else {
                          printf("No");
                          return 0;
                       }
                }
                else {//父节点孩子数量不一样
                     printf("No");
                     return 0;
                }
       }
    }
     if (P1[i].data != P2[j].data) {//如果没找到相同的父节点则肯定不是同构，注意这个代码是放在第一个循环下，和第二个循环并列，这也就是为什么提起声明i和j了
        printf("No");
        return 0;
      }
  }
 return 1;//如果全部符合则是同构
}