剑指Offer：17 树的子结构

最新推荐文章于 2020-08-27 12:53:55 发布

原创最新推荐文章于 2020-08-27 12:53:55 发布 · 140 阅读

0 ·

CC 4.0 BY-SA版权

剑指Offer 同时被 2 个专栏收录

60 篇文章

订阅专栏

二叉树

25 篇文章

订阅专栏

本文介绍了如何解决《剑指Offer》中关于判断二叉树子结构的问题。通过两步来实现：首先在树A中找到与树B根节点值相同的节点R，然后判断以R为根的子树是否与树B结构相同。通过递归遍历和比较节点值及结构完成判断，特别注意空指针的边界条件处理。

20.5.2

class Solution {
public:
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(!A || !B) return false; //空树不是任何树的子树

        bool res = false;
        if(A->val == B->val) res = isSubStructureCore(A, B);
        if(!res) res = isSubStructure(A->left, B);
        if(!res) res = isSubStructure(A->right, B);
        return res;
    }

    bool isSubStructureCore(TreeNode* A, TreeNode* B) {
        if(!B) return true; //B已经遍历完成,返回true
        if(!A) return false; //B还没完成,A已经完成,返回false
        if(A->val != B->val) return false;
        
        return isSubStructureCore(A->left, B->left) && isSubStructureCore(A->right, B->right);
    }
};

对二叉树的题还不是很熟练，做的太少了。这次看了书上的解法之后，自己再写了一遍，还是出了几个小问题，就是下面程序中注释掉的两处：

1、不应该把那两行加在else下，因为根节点相同、但后续节点不同时，下面还要继续递归找下去。

2、比较鸡肋的错误，注释与否关系不大，把return都放在if判断里，编译器会报错。

注意：在使用指针的时候一定要注意边界条件，即检查空指针。当树A或树B为空的时候，定义相应的输出。如果没有检查并做相应的处理，程序非常容易崩溃。

思路：

要查找树A中是否存在和树B结构一样的子树，可以分成两步：

第一步在树A中找到和B的根节点的值一样的结点R；
第二步再判断树A中以R为根结点的子树是不是包含和树B一样的结构。

第一步在树A中查找与根结点的值一样的结点，这实际上就是树的遍历。递归调用HasSubTree遍历二叉树A。如果发现某一结点的值和树B的头结点的值相同，则调用Judge，做第二步判断。

第二步是判断树A中以R为根结点的子树是不是和树B具有相同的结构。

/*
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 result = false;
        
        if(pRoot1==NULL || pRoot2==NULL) return result;
        if(pRoot1->val == pRoot2->val){
            result = Judge(pRoot1, pRoot2); //注意函数调用：调用结果应该直接return，还是赋值给result值，因为这个值之后判断处理还用的到，所以赋值给result变量。
        }
        //else{
            //只有还没有找到B是A的子结构时，才需要进一步向下深挖和B的根节点相同的点
            if(!result) result = HasSubtree(pRoot1->left, pRoot2);
            if(!result) result = HasSubtree(pRoot1->right, pRoot2);
        //}
        
        return result;
    }
    
    bool Judge(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(pRoot2 == NULL) return true; 
        if(pRoot1 == NULL) return false;
        if(pRoot1->val != pRoot2->val) return false;
        
        //if(pRoot1->val==pRoot2->val){
            return (Judge(pRoot1->left, pRoot2->left) && Judge(pRoot1->right, pRoot2->right));
        //}
    }
};

看到的代码风格比较好的答案

class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(!pRoot1 || !pRoot2) return false;
        bool result=false;
        if(pRoot1->val == pRoot2->val)result=isSubtree(pRoot1,pRoot2); // 找到判断子树
        if(!result) result=HasSubtree(pRoot1->left,pRoot2); // 未找到匹配的根节点以及匹配的子树，则继续向下递归
        if(!result) result=HasSubtree(pRoot1->right,pRoot2);
        return result;
    }
     
    bool isSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(!pRoot2) return true; // 子树遍历完成（关键语句）
        if(!pRoot1) return false; // 主树异常时的输出（关键语句：提高鲁棒性）
        bool result=true;
        if(pRoot1->val!=pRoot2->val) result=false;
        if(result) result=isSubtree(pRoot1->left,pRoot2->left);
        if(result) result=isSubtree(pRoot1->right,pRoot2->right);
        return result;
    }
};