solve problem Subtree Of Another Tree

Author: P-ppc

README.md

@@ -132,6 +132,7 @@ All solutions will be accepted!
 |67|[Add Binary](https://leetcode-cn.com/problems/add-binary/description/)|[java/py/js](./algorithms/AddBinary)|Easy|
 |504|[Base 7](https://leetcode-cn.com/problems/base-7/description/)|[java/py/js](./algorithms/Base7)|Easy|
 |830|[Positions Of Large Groups](https://leetcode-cn.com/problems/positions-of-large-groups/description/)|[java/py/js](./algorithms/PositionsOfLargeGroups)|Easy|
+|572|[Subtree Of Another Tree](https://leetcode-cn.com/problems/subtree-of-another-tree/description/)|[java/py/js](./algorithms/Subtree Of Another Tree)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/SubtreeOfAnotherTree/README.md

@@ -0,0 +1,2 @@
+# Subtree Of Another Tree
+This problem is easy to solve by recursive

algorithms/SubtreeOfAnotherTree/Solution.java

@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public boolean isSubtree(TreeNode s, TreeNode t) {
+        if (s == null && t == null) {
+            return true;
+        } else if ((s == null && t != null) || (s != null && t == null)) {
+            return false;
+        } else if (isSameTree(s, t)) {
+            return true;
+        } else {
+            return isSubtree(s.left, t) || isSubtree(s.right, t);
+        }
+    }
+    
+    public boolean isSameTree(TreeNode s, TreeNode t) {
+        if (s.val == t.val) {
+            if (s.left == null && s.right == null && t.left == null && t.right == null) {
+                return true;
+            } else if (s.left != null && s.right != null && t.left != null && t.right != null) {
+                return isSameTree(s.left, t.left) && isSameTree(s.right, t.right);
+            } else if (s.left != null && s.right == null && t.left != null && t.right == null) {
+                return isSameTree(s.left, t.left);
+            } else if (s.left == null && s.right != null && t.left == null && t.right != null) {
+                return isSameTree(s.right, t.right);
+            }
+        }
+        return false;
+    }
+}

algorithms/SubtreeOfAnotherTree/solution.js

@@ -0,0 +1,38 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} s
+ * @param {TreeNode} t
+ * @return {boolean}
+ */
+var isSubtree = function(s, t) {
+    if (s === null && t === null) {
+        return true
+    } else if ((s === null && t !== null) || (s !== null && t === null)) {
+        return false
+    } else if (isSameTree(s, t)) {
+        return true
+    } else {
+        return isSubtree(s.left, t) || isSubtree(s.right, t)
+    }
+};
+
+var isSameTree = function(s, t) {
+    if (s.val === t.val) {
+        if (s.left === null && s.right === null && t.left === null && t.right === null) {
+            return true
+        } else if (s.left !== null && s.right !== null && t.left !== null && t.right !== null) {
+            return isSameTree(s.left, t.left) && isSameTree(s.right, t.right)
+        } else if (s.left !== null && s.right === null && t.left !== null && t.right === null) {
+            return isSameTree(s.left, t.left)
+        } else if (s.left === null && s.right !== null && t.left === null && t.right !== null) {
+            return isSameTree(s.right, t.right)
+        }
+    }
+    return false
+}

algorithms/SubtreeOfAnotherTree/solution.py

@@ -0,0 +1,34 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def isSubtree(self, s, t):
+        """
+        :type s: TreeNode
+        :type t: TreeNode
+        :rtype: bool
+        """
+        if not s and not t:
+            return True
+        elif (not s and t) or (s and not t):
+            return False
+        elif self.isSameTree(s, t):
+            return True
+        else:
+            return self.isSubtree(s.left, t) or self.isSubtree(s.right, t)
+    
+    def isSameTree(self, s, t):
+        if s.val == t.val:
+            if not s.left and not s.right and not t.left and not t.right:
+                return True
+            elif s.left and s.right and t.left and t.right:
+                return self.isSameTree(s.left, t.left) and self.isSameTree(s.right, t.right)
+            elif s.left and not s.right and t.left and not t.right:
+                return self.isSameTree(s.left, t.left)
+            elif not s.left and s.right and not t.left and t.right:
+                return self.isSameTree(s.right, t.right)
+        return False