Merge pull request #32 from jeantimex/path-sum

Added path sum.

Author: jeantimex

README.md

@@ -28,6 +28,7 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Convert Sorted Array to Binary Search Tree](src/tree/convert-sorted-array-to-binary-search-tree.js)
 - [Balanced Binary Tree](src/tree/balanced-binary-tree.js)
 - [Minimum Depth of Binary Tree](src/tree/minimum-depth-of-binary-tree.js)
+- [Path Sum](src/tree/path-sum.js)
 
 ### Dynamic Programming
 

src/tree/__tests__/path-sum-test.js

@@ -0,0 +1,24 @@
+import { assert } from 'chai';
+import { serializeTree, deserializeTree } from 'utils/tree-util';
+import hasPathSum from '../path-sum';
+
+describe('Path Sum', () => {
+  const testCases = [
+    ['', 0, false],
+    ['5,4,8,11,null,13,4,7,2,null,null,null,1', 22, true],
+    ['1', 0, false],
+    ['1', 1, true],
+    ['1,2', 3, true],
+    ['1,null,2', 3, true],
+  ];
+
+  testCases.map((testCase, index) => {
+    it(`should validate if there's a path for ${testCase[0]}`, () => {
+      const root = deserializeTree(testCase[0]);
+      const sum = testCase[1];
+      const expected = testCase[2];
+      const actual = hasPathSum(root, sum);
+      assert.equal(actual, expected);
+    });
+  });
+});

src/tree/path-sum.js

@@ -0,0 +1,34 @@
+/**
+ * Given a binary tree and a sum, determine if the tree has a root-to-leaf path such 
+ * that adding up all the values along the path equals the given sum.
+ * 
+ * For example:
+ * Given the below binary tree and sum = 22,
+ *               5
+ *              / \
+ *             4   8
+ *            /   / \
+ *           11  13  4
+ *          /  \      \
+ *         7    2      1
+ * return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.
+ */
+
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {boolean}
+ */
+const hasPathSum = (root, sum) => {
+  if (!root) {
+    return false;
+  }
+
+  if (!root.left && !root.right) {
+    return root.val === sum;
+  }
+
+  return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
+};
+
+export default hasPathSum;