17.树的子结构

1.思路：

递归求解，首先知道大体框架是先判断root和childTree，不行就继续判断root->left和childTree、root->right和childTree.其次是需要构建doesTree1HaveTree2(TreeNode* node1, TreeNode* node2) 函数，用来判断两个树之间是否存在包含关系。

2.代码：

/*代码一  两个递归调用配合使用
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) {
        bool res = false;
        if(pRoot1 != NULL && pRoot2 != NULL) {  //如果全为空，则返回false
            if(pRoot1->val == pRoot2->val) {   //如果节点相等，则判断是否为子树
                res = doesTree1HaveTree2(pRoot1, pRoot2);
            }
            if(!res) {                         //若不是子树，则进一步判断pRoot1的左子树和右子树是否包括pRoot2
                res = HasSubtree(pRoot1->left, pRoot2);
            }
            if(!res) {
                res = HasSubtree(pRoot1->right, pRoot2);
            }
        }
        return res;
    }
    
    bool doesTree1HaveTree2(TreeNode* node1, TreeNode* node2) {
        if(node2 == NULL)  //子树已经遍历完，且都能对应的上
            return true;
        if(node1 == NULL)  //父树已经遍历完，但子树还没遍历完
            return false;
        if(node1->val != node2->val)  //对应位置的值不相等
            return false;
        return doesTree1HaveTree2(node1->left, node2->left) && doesTree1HaveTree2(node1->right, node2->right);
    }
};

/*代码二： 递归判断加树的层次遍历
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
         if(pRoot2 == NULL || pRoot1 == NULL) {
             return false;
         } else {
             queue<TreeNode*> q;
             q.push(pRoot1);
             TreeNode* tmp;
             bool res = false;
             while(!q.empty()) {
                 tmp = q.front();
                 q.pop();
                 if(tmp->left) {
                     q.push(tmp->left);
                 }
                 if(tmp->right) {
                     q.push(tmp->right);
                 }
                 res = helper(tmp, pRoot2);
                 if(res) {
                     return true;
                 }
             }
             return false;
         }
    }
    
    bool helper(TreeNode* r1, TreeNode* r2) {
        if(r2 == NULL) {
            return true;
        } else if(r1 == NULL) {
            return false;
        }
        if(r1->val == r2->val) {
            return helper(r1->left, r2->left) && helper(r1->right, r2->right);
        } else {
            return false;
        }
    }
};

/*代码一 （二刷写法）
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
         if(pRoot2 == NULL || pRoot1 == NULL) {
             return false;
         } else {
             if(helper(pRoot1, pRoot2)) {
                 return true;
             } else {
                 return HasSubtree(pRoot1->left, pRoot2) || HasSubtree(pRoot1->right, pRoot2);
             }
         }
    }
    
    bool helper(TreeNode* r1, TreeNode* r2) {
        if(r2 == NULL) {
            return true;
        } else if(r1 == NULL) {
            return false;
        }
        if(r1->val == r2->val) {
            return helper(r1->left, r2->left) && helper(r1->right, r2->right);
        } else {
            return false;
        }
    }
};