feat: update solutions to lc problems: No.0111,0199

* No.0111.Minimum Depth of Binary Tree
* No.0199.Binary Tree Right Side View

Author: yanglbme

solution/0100-0199/0104.Maximum Depth of Binary Tree/README.md

@@ -149,9 +149,7 @@ func max(a, b int) int {
  * @return {number}
  */
 var maxDepth = function (root) {
-    if (!root) {
-        return 0;
-    }
+    if (!root) return 0;
     const l = maxDepth(root.left);
     const r = maxDepth(root.right);
     return 1 + Math.max(l, r);

solution/0100-0199/0104.Maximum Depth of Binary Tree/README_EN.md

@@ -179,9 +179,7 @@ func max(a, b int) int {
  * @return {number}
  */
 var maxDepth = function (root) {
-    if (!root) {
-        return 0;
-    }
+    if (!root) return 0;
     const l = maxDepth(root.left);
     const r = maxDepth(root.right);
     return 1 + Math.max(l, r);

solution/0100-0199/0104.Maximum Depth of Binary Tree/Solution.js

@@ -11,9 +11,7 @@
  * @return {number}
  */
 var maxDepth = function (root) {
-    if (!root) {
-        return 0;
-    }
+    if (!root) return 0;
     const l = maxDepth(root.left);
     const r = maxDepth(root.right);
     return 1 + Math.max(l, r);

solution/0100-0199/0107.Binary Tree Level Order Traversal II/README.md

@@ -98,7 +98,7 @@ class Solution {
         q.offerLast(root);
         while (!q.isEmpty()) {
             List<Integer> t = new ArrayList<>();
-            for (int i = 0, n = q.size(); i < n; ++i) {
+            for (int i = q.size(); i > 0; --i) {
                 TreeNode node = q.pollFirst();
                 t.add(node.val);
                 if (node.left != null) {
@@ -138,8 +138,7 @@ public:
         while (!q.empty())
         {
             vector<int> t;
-            for (int i = 0, n = q.size(); i < n; ++i)
-            {
+            for (int i = q.size(); i > 0; --i) {
                 TreeNode* node = q.front();
                 q.pop();
                 t.push_back(node->val);
@@ -173,7 +172,7 @@ func levelOrderBottom(root *TreeNode) [][]int {
 	q := []*TreeNode{root}
 	for len(q) > 0 {
 		var t []int
-		for i, n := 0, len(q); i < n; i++ {
+		for i := len(q); i > 0; i-- {
 			node := q[0]
 			q = q[1:]
 			t = append(t, node.Val)
@@ -210,9 +209,8 @@ var levelOrderBottom = function (root) {
     if (!root) return ans;
     let q = [root];
     while (q.length) {
-        let n = q.length;
         let t = [];
-        while (n-- > 0) {
+        for (let i = q.length; i > 0; --i) {
             const node = q.shift();
             t.push(node.val);
             if (node.left) q.push(node.left);

solution/0100-0199/0107.Binary Tree Level Order Traversal II/README_EN.md

@@ -97,7 +97,7 @@ class Solution {
         q.offerLast(root);
         while (!q.isEmpty()) {
             List<Integer> t = new ArrayList<>();
-            for (int i = 0, n = q.size(); i < n; ++i) {
+            for (int i = q.size(); i > 0; --i) {
                 TreeNode node = q.pollFirst();
                 t.add(node.val);
                 if (node.left != null) {
@@ -137,8 +137,7 @@ public:
         while (!q.empty())
         {
             vector<int> t;
-            for (int i = 0, n = q.size(); i < n; ++i)
-            {
+            for (int i = q.size(); i > 0; --i) {
                 TreeNode* node = q.front();
                 q.pop();
                 t.push_back(node->val);
@@ -172,7 +171,7 @@ func levelOrderBottom(root *TreeNode) [][]int {
 	q := []*TreeNode{root}
 	for len(q) > 0 {
 		var t []int
-		for i, n := 0, len(q); i < n; i++ {
+		for i := len(q); i > 0; i-- {
 			node := q[0]
 			q = q[1:]
 			t = append(t, node.Val)
@@ -209,9 +208,8 @@ var levelOrderBottom = function (root) {
     if (!root) return ans;
     let q = [root];
     while (q.length) {
-        let n = q.length;
         let t = [];
-        while (n-- > 0) {
+        for (let i = q.length; i > 0; --i) {
             const node = q.shift();
             t.push(node.val);
             if (node.left) q.push(node.left);

solution/0100-0199/0107.Binary Tree Level Order Traversal II/Solution.cpp

@@ -18,8 +18,7 @@ class Solution {
         while (!q.empty())
         {
             vector<int> t;
-            for (int i = 0, n = q.size(); i < n; ++i)
-            {
+            for (int i = q.size(); i > 0; --i) {
                 TreeNode* node = q.front();
                 q.pop();
                 t.push_back(node->val);

solution/0100-0199/0107.Binary Tree Level Order Traversal II/Solution.go

@@ -14,7 +14,7 @@ func levelOrderBottom(root *TreeNode) [][]int {
 	q := []*TreeNode{root}
 	for len(q) > 0 {
 		var t []int
-		for i, n := 0, len(q); i < n; i++ {
+		for i := len(q); i > 0; i-- {
 			node := q[0]
 			q = q[1:]
 			t = append(t, node.Val)

solution/0100-0199/0107.Binary Tree Level Order Traversal II/Solution.java

@@ -23,7 +23,7 @@ public List<List<Integer>> levelOrderBottom(TreeNode root) {
         q.offerLast(root);
         while (!q.isEmpty()) {
             List<Integer> t = new ArrayList<>();
-            for (int i = 0, n = q.size(); i < n; ++i) {
+            for (int i = q.size(); i > 0; --i) {
                 TreeNode node = q.pollFirst();
                 t.add(node.val);
                 if (node.left != null) {

solution/0100-0199/0107.Binary Tree Level Order Traversal II/Solution.js

@@ -15,9 +15,8 @@ var levelOrderBottom = function (root) {
     if (!root) return ans;
     let q = [root];
     while (q.length) {
-        let n = q.length;
         let t = [];
-        while (n-- > 0) {
+        for (let i = q.length; i > 0; --i) {
             const node = q.shift();
             t.push(node.val);
             if (node.left) q.push(node.left);

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

@@ -41,6 +41,8 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+若左子树和右子树其中一个为空，那么需要返回比较大的那个子树的深度加 1；左右子树都不为空，返回最小深度加 1 即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -56,15 +58,16 @@
 #         self.right = right
 class Solution:
     def minDepth(self, root: TreeNode) -> int:
-        if root is None:
-            return 0
-        # 如果左子树和右子树其中一个为空，那么需要返回比较大的那个子树的深度+1
-        if root.left is None:
-            return 1 + self.minDepth(root.right)
-        if root.right is None:
-            return 1 + self.minDepth(root.left)
-        # 左右子树都不为空，返回最小深度+1即可
-        return 1 + min(self.minDepth(root.left), self.minDepth(root.right))
+        def dfs(root):
+            if root is None:
+                return 0
+            if root.left is None:
+                return 1 + dfs(root.right)
+            if root.right is None:
+                return 1 + dfs(root.left)
+            return 1 + min(dfs(root.left), dfs(root.right))
+
+        return dfs(root)
 ```
 
 ### **Java**
@@ -89,16 +92,20 @@ class Solution:
  */
 class Solution {
     public int minDepth(TreeNode root) {
+        return dfs(root);
+    }
+
+    private int dfs(TreeNode root) {
         if (root == null) {
             return 0;
         }
         if (root.left == null) {
-            return 1 + minDepth(root.right);
+            return 1 + dfs(root.right);
         }
         if (root.right == null) {
-            return 1 + minDepth(root.left);
+            return 1 + dfs(root.left);
         }
-        return 1 + Math.min(minDepth(root.left), minDepth(root.right));
+        return 1 + Math.min(dfs(root.left), dfs(root.right));
     }
 }
 ```
@@ -119,10 +126,13 @@ class Solution {
  * @return {number}
  */
 var minDepth = function (root) {
-    if (root == null) return 0;
-    if (root.left == null) return minDepth(root.right) + 1;
-    if (root.right == null) return minDepth(root.left) + 1;
-    return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
+    function dfs(root) {
+        if (!root) return 0;
+        if (!root.left) return 1 + dfs(root.right);
+        if (!root.right) return 1 + dfs(root.left);
+        return 1 + Math.min(dfs(root.left), dfs(root.right));
+    }
+    return dfs(root);
 };
 ```
 
@@ -143,20 +153,54 @@ var minDepth = function (root) {
 class Solution {
 public:
     int minDepth(TreeNode* root) {
-        if (root == nullptr) {
-            return 0;
-        }
-        if (root->left == nullptr) {
-            return 1 + minDepth(root->right);
-        }
-        if (root->right == nullptr) {
-            return 1 + minDepth(root->left);
-        }
-        return 1 + min(minDepth(root->left), minDepth(root->right));
+        return dfs(root);
+    }
+
+    int dfs(TreeNode* root) {
+        if (!root) return 0;
+        if (!root->left) return 1 + dfs(root->right);
+        if (!root->right) return 1 + dfs(root->left);
+        return 1 + min(dfs(root->left), dfs(root->right));
     }
 };
 ```
 
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func minDepth(root *TreeNode) int {
+	var dfs func(root *TreeNode) int
+	dfs = func(root *TreeNode) int {
+		if root == nil {
+			return 0
+		}
+		if root.Left == nil {
+			return 1 + dfs(root.Right)
+		}
+		if root.Right == nil {
+			return 1 + dfs(root.Left)
+		}
+		return 1 + min(dfs(root.Left), dfs(root.Right))
+	}
+	return dfs(root)
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
+
 ### **...**
 
 ```