使用 dfs 确定给定树是否是子树

Question

I'm trying to determine if one tree (t) is a subtree of another tree (s).

This is a link to the leetcode which explains the problem thoroughly: https://leetcode.com/problems/subtree-of-another-tree/

My approach: I have one function that does a dfs on s and compares each node to the root of t in another function to determine if t is a subtree of s

My solution doesn't work for when s=[1,1] and t=[1], although I think it should be working. Could you please look at my code and explain what's wrong.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
        /* dfs on s, at each node running a compare tree function for s at that node and
        root of t*/
        
        if(s == null || t == null) {
            return false;
        }
        
        return dfs(s, t);
    }
    
    public static boolean dfs(TreeNode s, TreeNode t) {
        if(s == null) {
            return false;
        }
        
        if(s.val == t.val) {
            return isSameTree(s, t);
        }
        
        
        return dfs(s.left, t) || dfs(s.right, t);
    }
    
    public static boolean isSameTree(TreeNode s, TreeNode t) {
        if(s == null || t == null) {
            return s == t;
        }
        
        if(s.val != t.val) {
            return false;
        }
        
        return isSameTree(s.left, t.left) && isSameTree(s.right, t.right);
    }
}

Answer 1

You need to check for all nodes of s if t is a subtree of that node or not. If you stop at first node while performing dfs on s and its value is same as root of t but subtrees are different, there might be some another node of tree s whose value and subtree both are same as t .

In other words, you need to repeat your 1st step (perform dfs on s and compare each node of s to the root of t ) until you have checked all nodes of s (dfs is complete on s ) or found that t is subtree of s .

 st (1) (1) / (1)

Do not return from root of s just because of same values of root of s and t. If t is not subtree of that node, keep doing dfs to find another node whose value and subtree both are same as t (left child of root of s in this case).

For more clarity, below is your code with corrected part highlighted:

class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
        /* dfs on s, at each node running a compare tree function for s at that node and
        root of t*/
        
        if(s == null || t == null) {
            return false;
        }
        
        return dfs(s, t);
    }
    
    public static boolean dfs(TreeNode s, TreeNode t) {
        if(s == null) {
            return false;
        }
        
        // ==== Corrected below if ====
        // apart from s.val == t.val, if isSameTree(s, t) is true at this
        // point, return true; otherwise keep doing dfs for rest of the tree s
        // other same value node of s can be the answer
        if(s.val == t.val && isSameTree(s, t)) {
            return true;
        }
        
        
        return dfs(s.left, t) || dfs(s.right, t);
    }
    
    public static boolean isSameTree(TreeNode s, TreeNode t) {
        if(s == null || t == null) {
            return s == t;
        }
        
        if(s.val != t.val) {
            return false;
        }
        
        return isSameTree(s.left, t.left) && isSameTree(s.right, t.right);
    }
}

Answer 2

Looks pretty good! Almost there!

This'd pass:

public class Solution {
    public static final boolean isSubtree(
        final TreeNode s,
        final TreeNode t
    ) {
        if (s == null) {
            return false;
        }

        if (checkNextLevel(s, t)) {
            return true;
        }

        return isSubtree(s.left, t) ||
               isSubtree(s.right, t);
    }

    private static final boolean checkNextLevel(
        final TreeNode s,
        final TreeNode t
    ) {
        if (s == null && t == null) {
            return true;
        }

        if (
            (s == null || t == null) ||
            (s.val != t.val)
        ) {
            return false;
        }


        return checkNextLevel(s.left, t.left) &&
               checkNextLevel(s.right, t.right);
    }
}