判断一个二叉树是否是另一个二叉树的子树

点：二叉树理解，递归的运用

题意：如二叉树A，如下：

                                                                                 16

                                   7                                                                                            28

                6                                      14                                            23                                                 41

      3                                     12                   15                                              27                      30                      55

                                           8                                                                                               29

判断另几个二叉树B、C、D、E、F、G依次如下：

                                    14                                14                           14                             41                               30                    28

                              12         15                    12       15                12      15                 30       55                   29                23

                           8                                                                     9                              29                                                            27      

                                                                                                                                27  

剑指offer面试题18

思路：这也是道典型题，首先一定要明确什么样的二叉树可以称之为另一个二叉树的子二叉树，看结论：
B：yes

C：no，缺失叶子节点8

D：no，叶子节点9和原二叉树叶子节点8不一致

E：no，多出叶子节点

F：yes，30的子树只有30自己和叶子节点29

G：no，28的子树还有41等节点组成的右子树

    也就是说，必须是完整的子树，从子树到叶子，无论是形状、值、个数必须完全一致

    所以，判断是否为子树的步骤：

1、原二叉树走前序遍历，试图发现哪个节点的值和被判断子树的根节点相同；

如果一直到最后也没有找到那么肯定不是

2、如果找到了，就两个二叉树一起前序遍历，试图发现两个二叉树同时遍历完成，且同样的左右子树遍历过程中的节点值均相同，同时遍历完成说明有相同的形状，左右子树遍历过程中的节点值均相同说明两个二叉树不仅形状一样，值也是一样，则可以认为是子树。

代码：

#include <iostream>

template<class T> struct Node {
T val;
Node<T> *lchild;
Node<T> *rchild;
Node(int _val):val(_val), lchild(nullptr), rchild(nullptr) {}
};

template<class T> class Btree {
Node<T> *root;

public:
Btree():root(nullptr){}
void Free (Node<T> *cur) {
if (cur) {
Free(cur->lchild);
Free(cur->rchild);
delete cur;
cur = nullptr;
}
}
~Btree () {
Free(root);
}
Node<T> *GetRoot () {
return root;
}

void Add (int val) {
if (!root) {
root = new Node<T>(val);
} else {
Node<T> *cur = root;
while (cur) {
if (cur->val > val) {
if (cur->lchild) {
cur = cur->lchild;
} else {
Node<T> *newnode = new Node<T>(val);
cur->lchild = newnode;
}
} else if (cur->val < val) {
if (cur->rchild) {
cur = cur->rchild;
} else {
Node<T> *newnode = new Node<T>(val);
cur->rchild = newnode;
}
} else {
break;
}
}
}
}

bool Judge (Node<T> *cur1, Node<T> *cur2) {
if (!cur1 && !cur2) {
return true;
}

if (cur1 && cur2) {
if (cur1->val == cur2->val) {
bool res_l = Judge(cur1->lchild, cur2->lchild);
bool res_r = Judge(cur1->rchild, cur2->rchild);
return res_l & res_r;
} else {
bool res_l = Judge(cur1->lchild, cur2);
if (res_l) {
return res_l;
} else if (!res_l) {
return Judge(cur1->rchild, cur2);
}
}
} else {
return false;
}
}

bool Judge_whether_is_a_subtree (Btree &obt) {
Judge(root, obt.GetRoot());
}
};

int main () {
Btree<int> bt1, bt2, bt3, bt4, bt5, bt6, bt7, bt8;
bt1.Add(16);
bt1.Add(7);
bt1.Add(28);
bt1.Add(6);
bt1.Add(14);
bt1.Add(23);
bt1.Add(41);
bt1.Add(3);
bt1.Add(12);
bt1.Add(15);
bt1.Add(27);
bt1.Add(30);
bt1.Add(55);
bt1.Add(8);
bt1.Add(29);

bt2.Add(14);
bt2.Add(12);
bt2.Add(15);
bt2.Add(8);

bt3.Add(14);
bt3.Add(12);
bt3.Add(15);

bt4.Add(14);
bt4.Add(12);
bt4.Add(15);
bt4.Add(9);

bt5.Add(41);
bt5.Add(30);
bt5.Add(55);
bt5.Add(29);
bt5.Add(37);

bt6.Add(30);
bt6.Add(29);

bt7.Add(28);
bt7.Add(23);
bt7.Add(27);

bt8.Add(129);

std::cout << bt1.Judge_whether_is_a_subtree(bt2) << std::endl;
std::cout << bt1.Judge_whether_is_a_subtree(bt3) << std::endl;
std::cout << bt1.Judge_whether_is_a_subtree(bt4) << std::endl;
std::cout << bt1.Judge_whether_is_a_subtree(bt5) << std::endl;
std::cout << bt1.Judge_whether_is_a_subtree(bt6) << std::endl;
std::cout << bt1.Judge_whether_is_a_subtree(bt7) << std::endl;
std::cout << bt1.Judge_whether_is_a_subtree(bt8) << std::endl;
return 0;
}