feat: add solutions to leetcode problem: No.0111

See https://leetcode-cn.com/problems/minimum-depth-of-binary-tree

Author: yanglbme

README.md

@@ -87,6 +87,7 @@
 1. [二叉树的层次遍历](/solution/0100-0199/0102.Binary%20Tree%20Level%20Order%20Traversal/README.md)
 1. [二叉树的层次遍历 II](/solution/0100-0199/0107.Binary%20Tree%20Level%20Order%20Traversal%20II/README.md)
 1. [二叉树的最大深度](/solution/0100-0199/0104.Maximum%20Depth%20of%20Binary%20Tree/README.md)
+1. [二叉树的最小深度](/solution/0100-0199/0111.Minimum%20Depth%20of%20Binary%20Tree/README.md)
 1. [从前序与中序遍历序列构造二叉树](/solution/0100-0199/0105.Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README.md)
 1. [从中序与后序遍历序列构造二叉树](/solution/0100-0199/0106.Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/README.md)
 1. [二叉树的最近公共祖先](/solution/0200-0299/0235.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree/README.md)

README_EN.md

@@ -85,6 +85,7 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 1. [Binary Tree Level Order Traversal](/solution/0100-0199/0102.Binary%20Tree%20Level%20Order%20Traversal/README_EN.md)
 1. [Binary Tree Level Order Traversal II](/solution/0100-0199/0107.Binary%20Tree%20Level%20Order%20Traversal%20II/README_EN.md)
 1. [Maximum Depth of Binary Tree](/solution/0100-0199/0104.Maximum%20Depth%20of%20Binary%20Tree/README_EN.md)
+1. [Minimum Depth of Binary Tree](/solution/0100-0199/0111.Minimum%20Depth%20of%20Binary%20Tree/README_EN.md)
 1. [Construct Binary Tree from Preorder and Inorder Traversal](/solution/0100-0199/0105.Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README_EN.md)
 1. [Construct Binary Tree from Inorder and Postorder Traversal](/solution/0100-0199/0106.Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/README_EN.md)
 1. [Lowest Common Ancestor of a Binary Tree](/solution/0200-0299/0236.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree/README_EN.md)

solution/0100-0199/0111.Minimum Depth of Binary Tree/README.md

@@ -34,15 +34,57 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```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 minDepth(self, root: TreeNode) -> int:
+        if root is None:
+            return 0
+        if root.left is None and root.right is None:
+            return 1
+        l = self.minDepth(root.left)
+        r = self.minDepth(root.right)
+        # 如果左子树和右子树其中一个为空，那么需要返回比较大的那个子树的深度
+        if root.left is None or root.right is None:
+            return l + r + 1
+        # 左右子树都不为空，返回最小深度+1即可
+        return min(l, r) + 1
 ```
 
 ### **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 int minDepth(TreeNode root) {
+        if (root == null) return 0;
+        if (root.left == null && root.right == null) return 1;
+        int l = minDepth(root.left);
+        int r = minDepth(root.right);
+        if (root.left == null || root.right == null) return l + r + 1;
+        return Math.min(l, r) + 1;
+    }
+}
 ```
 
 ### **...**

solution/0100-0199/0111.Minimum Depth of Binary Tree/README_EN.md

@@ -35,13 +35,55 @@
 ### **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 minDepth(self, root: TreeNode) -> int:
+        if root is None:
+            return 0
+        if root.left is None and root.right is None:
+            return 1
+        l = self.minDepth(root.left)
+        r = self.minDepth(root.right)
+        # 如果左子树和右子树其中一个为空，那么需要返回比较大的那个子树的深度
+        if root.left is None or root.right is None:
+            return l + r + 1
+        # 左右子树都不为空，返回最小深度+1即可
+        return min(l, r) + 1
 ```
 
 ### **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 int minDepth(TreeNode root) {
+        if (root == null) return 0;
+        if (root.left == null && root.right == null) return 1;
+        int l = minDepth(root.left);
+        int r = minDepth(root.right);
+        if (root.left == null || root.right == null) return l + r + 1;
+        return Math.min(l, r) + 1;
+    }
+}
 ```
 
 ### **...**

solution/0100-0199/0111.Minimum Depth of Binary Tree/Solution.java

@@ -4,19 +4,22 @@
  *     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 int minDepth(TreeNode root) {
         if (root == null) return 0;
-
-        if (root.left == null && root.right != null) {
-            return 1 + minDepth(root.right);
-        }
-        if (root.right == null && root.left != null) {
-            return 1 + minDepth(root.left);
-        }
-        return 1 + Math.min(minDepth(root.left), minDepth(root.right));
+        if (root.left == null && root.right == null) return 1;
+        int l = minDepth(root.left);
+        int r = minDepth(root.right);
+        if (root.left == null || root.right == null) return l + r + 1;
+        return Math.min(l, r) + 1;
     }
 }

solution/0100-0199/0111.Minimum Depth of Binary Tree/Solution.py

@@ -0,0 +1,19 @@
+# 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 minDepth(self, root: TreeNode) -> int:
+        if root is None:
+            return 0
+        if root.left is None and root.right is None:
+            return 1
+        l = self.minDepth(root.left)
+        r = self.minDepth(root.right)
+        # 如果左子树和右子树其中一个为空，那么需要返回比较大的那个子树的深度
+        if root.left is None or root.right is None:
+            return l + r + 1
+        # 左右子树都不为空，返回最小深度+1即可
+        return min(l, r) + 1