feat: add python and java solutions to leetcode problem: No.0872

See https://leetcode-cn.com/problems/leaf-similar-trees/

Author: yanglbme

solution/0800-0899/0872.Leaf-Similar Trees/README.md

@@ -27,22 +27,76 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+深度优先搜索。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
+        def dfs(root, leaves):
+            if root is None:
+                return
+            if root.left is None and root.right is None:
+                leaves.append(root.val)
+                return
+            dfs(root.left, leaves)
+            dfs(root.right, leaves)
+        l1, l2 = [], []
+        dfs(root1, l1)
+        dfs(root2, l2)
+        return l1 == l2
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+/**
+ * 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 leafSimilar(TreeNode root1, TreeNode root2) {
+        List<Integer> l1 = new ArrayList<>();
+        List<Integer> l2 = new ArrayList<>();
+        dfs(root1, l1);
+        dfs(root2, l2);
+        return l1.equals(l2);
+    }
+
+    private void dfs(TreeNode root, List<Integer> leaves) {
+        if (root == null) return;
+        if (root.left == null && root.right == null) {
+            leaves.add(root.val);
+            return;
+        }
+        dfs(root.left, leaves);
+        dfs(root.right, leaves);
+    }
+}
 ```
 
 ### **...**

solution/0800-0899/0872.Leaf-Similar Trees/README_EN.md

@@ -29,13 +29,65 @@
 ### **Python3**
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
+        def dfs(root, leaves):
+            if root is None:
+                return
+            if root.left is None and root.right is None:
+                leaves.append(root.val)
+                return
+            dfs(root.left, leaves)
+            dfs(root.right, leaves)
+        l1, l2 = [], []
+        dfs(root1, l1)
+        dfs(root2, l2)
+        return l1 == l2
 ```
 
 ### **Java**
 
 ```java
-
+/**
+ * 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 leafSimilar(TreeNode root1, TreeNode root2) {
+        List<Integer> l1 = new ArrayList<>();
+        List<Integer> l2 = new ArrayList<>();
+        dfs(root1, l1);
+        dfs(root2, l2);
+        return l1.equals(l2);
+    }
+
+    private void dfs(TreeNode root, List<Integer> leaves) {
+        if (root == null) return;
+        if (root.left == null && root.right == null) {
+            leaves.add(root.val);
+            return;
+        }
+        dfs(root.left, leaves);
+        dfs(root.right, leaves);
+    }
+}
 ```
 
 ### **...**

solution/0800-0899/0872.Leaf-Similar Trees/Solution.java

@@ -4,25 +4,31 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     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 leafSimilar(TreeNode root1, TreeNode root2) {
-        List<Integer> rootA = new ArrayList<>();
-        List<Integer> rootB = new ArrayList<>();
-        dfs(root1, rootA);
-        dfs(root2, rootB);
-        return rootA.equals(rootB);
+        List<Integer> l1 = new ArrayList<>();
+        List<Integer> l2 = new ArrayList<>();
+        dfs(root1, l1);
+        dfs(root2, l2);
+        return l1.equals(l2);
     }
 
-    private void dfs(TreeNode root, List<Integer> res) {
-        if (root != null) {
-            if (root.left == null && root.right == null) {
-                res.add(root.val);
-            }
-            dfs(root.left, res);
-            dfs(root.right, res);
+    private void dfs(TreeNode root, List<Integer> leaves) {
+        if (root == null) return;
+        if (root.left == null && root.right == null) {
+            leaves.add(root.val);
+            return;
         }
+        dfs(root.left, leaves);
+        dfs(root.right, leaves);
     }
 }

solution/0800-0899/0872.Leaf-Similar Trees/Solution.py

@@ -0,0 +1,20 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
+        def dfs(root, leaves):
+            if root is None:
+                return
+            if root.left is None and root.right is None:
+                leaves.append(root.val)
+                return
+            dfs(root.left, leaves)
+            dfs(root.right, leaves)
+        l1, l2 = [], []
+        dfs(root1, l1)
+        dfs(root2, l2)
+        return l1 == l2