[数据结构与算法-16]树的同构

树的同构

1. 同构树

TreeA和TreeB为同构树,当且仅当存在从TreeA到TreeB的一一映射\(f(a)\)。

\[f(node[a_i]) = node[b_i] \]

对于以上的树,有映射关系

TreeA	TreeB
0	2
1	0
2	3
3	1

2. 同构有根树

TreeA和TreeB为同构树的基础上还要求根节点一致。

3. 同构二叉树

TreeA和TreeB为同构有根树的基础上还要求左右子节点一致。

例题

7-3 树的同构 (25 分)

给定两棵树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

对于样例一,画出给出的两棵树

思路

1. 特殊情况

   • 若两棵树均为空树,二者同构

   • 若两棵树节点数不同,二者不同构

2. 一般情况

   • 保证对应节点的子节点均相同

   • 两棵树的根节点应相同

#include <iostream>
using namespace std;
struct node {
	char number = NULL;
	int l = -1;
	int r = -1;
	 int len = NULL;
};
int K;
char temp;
bool visA[10], visB[10];


// 建树
node* buildTree(int);
// 释放内存
void destroyTree(node*);
// 判断同构
bool isomorphism(node*, node*);


int main() {

	node* TreeA, * TreeB;
	bool* visA, * visB;

	cin >> K;
	TreeA = buildTree(K);
	cin >> K;
	TreeB = buildTree(K);

	if (TreeA == NULL && TreeB == NULL)
		cout << "Yes" << endl;
	else if (isomorphism(TreeA, TreeB))
		cout << "Yes" << endl;
	else
		cout << "No" << endl;

	destroyTree(TreeA);
	destroyTree(TreeB);
}


node* buildTree(int K) {
    // 空树
	if (K == 0) return NULL;
    // 非空
	node* tree = new node[K];
	tree->len = K; // K个节点
	for (int i = 0; i < K; i++) {
		cin >> (tree + i)->number;
        // 读取左子节点
		cin >> temp;
		if (temp != '-')
			(tree + i)->l = int(temp - '0');
        // 读取右子节点
		cin >> temp;
		if (temp != '-')
			(tree + i)->r = int(temp - '0');
	}
	return tree;
}


void destroyTree(node* tree) {
	delete[] tree;
	tree = NULL;
}


bool isomorphism(node* TreeA, node* TreeB) {
    // 空树
	if (TreeA->len != TreeB->len)
		return 0;
    // 单节点
	if (TreeA->len == 1 && TreeB->len == 1)
		if (TreeA->number == TreeB->number)
			return 1;
		else
			return 0;
	for (int i = 0; i < (TreeA->len); i++) {
		char ch = (TreeA + i)->number;
        // 标记遍历过的TreeA的节点
		visA[i] = 1;
		for (int j = 0; j < (TreeB->len); j++) {
			if (ch == (TreeB+j)->number) {
				if (    // 左右皆空
					(((TreeA + i)->l == -1 && (TreeB + j)->l == -1)
					&&
					((TreeA + i)->r == -1 && (TreeB + j)->r == -1))
                    
					||  // 单边为空
					(((TreeA + i)->l == -1 && (TreeB + j)->l == -1)
					&&
					((TreeA + (TreeA + i)->r)->number == (TreeB + (TreeB + j)->r)->number))
                    ||
                    (((TreeA + i)->l == -1 && (TreeB + j)->l == -1)
					&&
					((TreeA + (TreeA + i)->r)->number == (TreeB + (TreeB + j)->r)->number))
					||
					(((TreeA + i)->l == -1 && (TreeB + j)->r == -1)
					&&
					((TreeA + (TreeA + i)->r)->number == (TreeB + (TreeB + j)->l)->number))
					||
					(((TreeA + i)->r == -1 && (TreeB + j)->l == -1)
					&&
					((TreeA + (TreeA + i)->l)->number == (TreeB + (TreeB + j)->r)->number))
                    
                    
					||  // 无空
					(((TreeA + (TreeA + i)->l)->number == (TreeB + (TreeB + j)->l)->number)
					&&
					((TreeA + (TreeA + i)->r)->number == (TreeB + (TreeB + j)->r)->number))
					||
					(((TreeA + (TreeA + i)->r)->number == (TreeB + (TreeB + j)->l)->number)
					&&
					((TreeA + (TreeA + i)->l)->number == (TreeB + (TreeB + j)->r)->number))
					) {
                    // 标记遍历过的TreeB的节点
					visB[j] = 1;
				}
				else
					return 0;
			}
		}
	}
    // 最终TreeA未标记的节点就是TreeA的根节点
    // 最终TreeB未标记的节点就是TreeB的根节点
	for (int i = 0; i < (TreeA->len); i++)
		for (int j = 0; j < (TreeB->len); j++)
			if (visA[i] == 0 && visB[j] == 0)
    			// 比较两个根节点
				if ((TreeA + i)->number != (TreeB + j)->number)
					return 0;
	return 1;
}