solve problem

leet-code/112-path-sum/README.md

@@ -0,0 +1,57 @@
+# 112-path-sum
+
+Given the root of a binary tree and an integer `targetSum`, return `true` if the tree has a **root-to-leaf** path such that adding up all the values along the path equals `targetSum`.
+
+A **leaf** is a node with no children.
+
+---
+
+### Example 1
+
+**Input:**  
+`root = [5,4,8,11,null,13,4,7,2,null,null,null,1]`  
+`targetSum = 22`  
+
+**Output:**  
+`true`  
+
+**Explanation:**  
+The root-to-leaf path with the target sum is:  
+5 → 4 → 11 → 2  
+Sum = 22  
+
+### Example 2
+
+**Input:**  
+`root = [1,2,3]`  
+`targetSum = 5`  
+
+**Output:**  
+`false`  
+
+**Explanation:**  
+There are two root-to-leaf paths in the tree:
+
+1 → 2 : sum = 3  
+1 → 3 : sum = 4  
+There is no root-to-leaf path with sum = 5.
+
+### Example 3
+
+**Input:**  
+`root = []`  
+`targetSum = 0`  
+
+**Output:**  
+`false`  
+
+**Explanation:**  
+Since the tree is empty, there are no root-to-leaf paths.
+
+---
+
+### Constraints
+
+- The number of nodes in the tree is in the range `[0, 5000]`.
+- `-1000 <= Node.val <= 1000`
+- `-1000 <= targetSum <= 1000`

leet-code/112-path-sum/index.js

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} targetSum
+ * @return {boolean}
+ */
+var hasPathSum = function(root, targetSum) {
+    // assume the target sum is not present in the tree
+    // recrsively visit each node looking for a root-to-leaf sum that matches the target
+    function visit(node, accumulation) {
+        // defensive check to not process undefined or null nodes
+        if (!node) return false;
+        // sum the current node with the accumlated path value
+        accumulation += node.val
+        // determine if the node is a leaf node
+        const isLeaf = !node.left && !node.right
+        // mark the targetSum as found
+        if (isLeaf && accumulation === targetSum) { return true }
+        // visis the left and right subtree until the target is found or the paths have been exhausted
+        return visit(node.left, accumulation) || visit(node.right, accumulation)
+    }
+    // begin the search at the root of the tree
+    return visit(root, 0)
+};