LeetCode 572. Subtree of Another Tree

题目：

Given two non-empty binary trees s and t, check whether tree t has exactly the same structure and node values with a subtree of s. A subtree of s is a tree consists of a node in s and all of this node's descendants. The tree s could also be considered as a subtree of itself.

Example 1:
Given tree s:

     3
    / \
   4   5
  / \
 1   2

Given tree t:

   4 
  / \
 1   2

Return true, because t has the same structure and node values with a subtree of s.

Example 2:
Given tree s:

     3
    / \
   4   5
  / \
 1   2
    /
   0

Given tree t:

   4
  / \
 1   2

Return false.

---

这道题刚开始自己想的时候想错了，应该是，如果root的value相同的话，判断s和t是否是same tree，如果不同的话，判断s->left和t或者s->right和t是不是subtree，并且这些条件是并列的或关系，而不是if else的关系，任意满足一个就可以了。

Runtime: 36 ms, faster than 22.81% of C++ online submissions for Subtree of Another Tree.

Memory Usage: 21.1 MB, less than 56.25% of C++ online submissions for Subtree of Another Tree.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 isIdentical(s,t)= s.val==t.val AND isIdentical(s.left,t.left) AND isIdentical(s.right,t.right)
 */
class Solution {
public:
    bool isSame(TreeNode* s, TreeNode* t) {
        if (!s || !t) {
            return !s && !t;
        }
        if (s->val != t->val) {
            return false;
        }
        return isSame(s->left, t->left) && isSame(s->right, t->right);
    }
    
    bool isSubtree(TreeNode* s, TreeNode* t) {
        if (!s || !t) {
            return !s && !t;
        }
        if (isSame(s, t)) {
            return true;
        }
        // cannot use if-else because if parent is not same, child can be same
        return isSubtree(s->left, t) || isSubtree(s->right, t);
    }
};

2020.10.06 Java

自己写出来了，虽然第一次也是，犯了跟之前一样的错误，return应该两个条件是并列的，不能拆开来用if else，或者就算是要拆开来，也要val相等放if里，第二条不放else里。

Runtime: 5 ms, faster than 97.24% of Java online submissions for Subtree of Another Tree.

Memory Usage: 39.3 MB, less than 81.81% of Java online submissions for Subtree of Another Tree.

/**
 * 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) {
        if (s == null) {
            return false;
        }
        if (t == null) {
            return true;
        }
        
        return (s.val == t.val && isSameTree(s, t)) || (isSubtree(s.left, t) || isSubtree(s.right, t));
    }
    
    private boolean isSameTree(TreeNode s, TreeNode t) {
        if (s == null || t == null) {
            return s == t;
        } else {
            return s.val == t.val && isSameTree(s.left, t.left) && isSameTree(s.right, t.right);
        }
    }
}

2023.1.19

哎，没写出来，其实很简单但是考虑的不全面。其实sameTree的代码写出来了但是不够简洁，isSubTree应该直接判断当前root是否是t的subtree、或者root.left是不是subtree、或者root.right是不是subtree。不知道自己咋想的就没总结好情况，导致各种没考虑到然后if else越写越乱。

/**
 * 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) {
        if (s == null) {
            return t == null;
        }
        return sameTree(s, t) || (isSubtree(s.left, t) || isSubtree(s.right, t));
    }

    private boolean sameTree(TreeNode s, TreeNode t) {
        if (s == null || t == null) {
            return s == t;
        }
        return s.val == t.val && sameTree(s.left, t.left) && sameTree(s.right, t.right);
    }
    
}

---

还有一种方法是可以直接用preorder traversal把树转换成一个string，然后比较是不是substring。但是直接转成string的话没有办法区分数字，因此需要在每个数字之间加上分隔符比如#，以及遇到leaf的时候要在它后面加上null以区分结构。然而，运行起来是真的慢。

/**
 * 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) {
        StringBuilder sbs = new StringBuilder();
        preorder(s, sbs);
        StringBuilder sbt = new StringBuilder();
        preorder(t, sbt);
        return sbs.indexOf(sbt.toString()) != -1;
    }
    
    private void preorder(TreeNode s, StringBuilder sb) {
        if (s == null) {
            sb.append("null");
            return;
        }
        sb.append("#" + s.val);
        preorder(s.left, sb);
        preorder(s.right, sb);
    }
    
}

---

迭代，其实就是100的迭代写法，加上主函数里迭代遍历s。

**
 * 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) {
        if (s == null) {
            return t == null;
        }
        Deque<TreeNode> stack = new ArrayDeque<>();
        stack.push(s);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            if (isSame(node, t)) {
                return true;
            }
            if (node.left != null) {
                stack.push(node.left);
            }
            if (node.right != null) {
                stack.push(node.right);
            }
        }
        return false;
    }
    
    private boolean isSame(TreeNode s, TreeNode t) {
        if (s == null || t == null) {
            return s == t;
        }
        Deque<TreeNode> stackS = new ArrayDeque<>();
        Deque<TreeNode> stackT = new ArrayDeque<>();
        stackS.push(s);
        stackT.push(t);
        while (!stackS.isEmpty() && !stackT.isEmpty()) {
            TreeNode nodeS = stackS.pop();
            TreeNode nodeT = stackT.pop();
            if (nodeS.val != nodeT.val) {
                return false;
            }
            if (nodeS.left != null && nodeT.left != null) {
                stackS.push(nodeS.left);
                stackT.push(nodeT.left);
            } else if (nodeS.left != nodeT.left) {
                return false;
            }
            if (nodeS.right != null && nodeT.right != null) {
                stackS.push(nodeS.right);
                stackT.push(nodeT.right);
            } else if (nodeS.right != nodeT.right) {
                return false;
            }
        }
        return true;
    }
    
}