sovle problem Sum Of Left Leaves

Author: P-ppc

README.md

@@ -33,4 +33,5 @@ All solutions will be accepted!
 |191|[Number Of 1 Bits](https://leetcode-cn.com/problems/number-of-1-bits/description/)|[java/py/js](./algorithms/NumberOf1Bits)|Easy|
 |258|[Add Digits](https://leetcode-cn.com/problems/add-digits/description/)|[java/py/js](./algorithms/AddDigits)|Easy|
 |520|[Detect Capital](https://leetcode-cn.com/problems/detect-capital/description/)|[java/py/js](./algorithms/DetectCaptial)|Easy|
-|682|[BaseBall Game](https://leetcode-cn.com/problems/baseball-game/description/)|[java/py/js](./algorithms/BaseBallGame)|Easy|
+|682|[BaseBall Game](https://leetcode-cn.com/problems/baseball-game/description/)|[java/py/js](./algorithms/BaseBallGame)|Easy|
+|404|[Sum Of Left Leaves](https://leetcode-cn.com/problems/sum-of-left-leaves/description/)|[java/py/js](./algorithms/SumOfLeftLeaves)|Easy|

algorithms/SumOfLeftLeaves/README.md

@@ -0,0 +1,2 @@
+# Sum Of Left Leaves
+We can use recursion to solve this problem

algorithms/SumOfLeftLeaves/Solution.java

@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int sumOfLeftLeaves(TreeNode root) {
+        if (root == null) {
+            return 0;
+        } else if (root.left == null && root.right == null) {
+            return 0;
+        }
+        return sumOfLeftLeaves(root.left, true) + sumOfLeftLeaves(root.right, false);
+    }
+    
+    public int sumOfLeftLeaves(TreeNode node, boolean isLeft) {
+        if (node == null) {
+            return 0;
+        } else if (node.left == null && node.right == null && isLeft) {
+            return node.val;
+        }
+        return sumOfLeftLeaves(node.left, true) + sumOfLeftLeaves(node.right, false);
+    }
+}

algorithms/SumOfLeftLeaves/solution.js

@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var sumOfLeftLeaves = function(root) {
+    if (!root) return 0
+    if (!root.left && !root.right) return 0
+    return sumOfLeftLeavesx(root.left, true) + sumOfLeftLeavesx(root.right, false)
+};
+
+function sumOfLeftLeavesx (node, isLeft) {
+    if (!node) return 0
+    if (!node.left && !node.right && isLeft) return node.val
+    return sumOfLeftLeavesx(node.left, true) + sumOfLeftLeavesx(node.right, false)
+}

algorithms/SumOfLeftLeaves/solution.py

@@ -0,0 +1,27 @@
+# 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 sumOfLeftLeaves(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root:
+            return 0
+        if not root.left and not root.right:
+            # root is not left leave
+            return 0
+        return self.sumOfLeftLeavesx(root.left) + self.sumOfLeftLeavesx(root.right, is_left = False)
+        
+    def sumOfLeftLeavesx(self, node, is_left = True):
+        if not node:
+            return 0
+        if not node.left and not node.right and is_left:
+            return node.val
+        return self.sumOfLeftLeavesx(node.left) + self.sumOfLeftLeavesx(node.right, is_left = False)
+