Merge pull request #37 from jeantimex/binary-tree-maximum-path-sum

Added binary tree max path sum problem.

Author: jeantimex

README.md

@@ -33,6 +33,7 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Flatten Binary Tree to Linked List](src/tree/flatten-binary-tree-to-linked-list.js)
 - [Populating Next Right Pointers in Each Node](src/tree/populating-next-right-pointers-in-each-node.js)
 - [Populating Next Right Pointers in Each Node II](src/tree/populating-next-right-pointers-in-each-node-ii.js)
+- [Binary Tree Maximum Path Sum](src/tree/binary-tree-maximum-path-sum.js)
 
 ### Dynamic Programming
 

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

@@ -0,0 +1,16 @@
+import { assert } from 'chai';
+import { serializeTree, deserializeTree } from 'utils/tree-util';
+import maxPathSum from '../binary-tree-maximum-path-sum';
+
+describe('Binary Tree Maximum Path Sum', () => {
+  const testCases = [['1', 1], ['1,2,3', 6], ['1,-1,-2', 1], ['0,0,1', 1]];
+
+  testCases.map((testCase, index) => {
+    it(`should calculate the max path sum for tree ${testCase[0]}`, () => {
+      const root = deserializeTree(testCase[0]);
+      const expected = testCase[1];
+      const actual = maxPathSum(root);
+      assert.equal(actual, expected);
+    });
+  });
+});

src/tree/binary-tree-maximum-path-sum.js

@@ -0,0 +1,43 @@
+/**
+ * Given a binary tree, find the maximum path sum.
+ * 
+ * For this problem, a path is defined as any sequence of nodes from some starting node to any node 
+ * in the tree along the parent-child connections. The path must contain at least one node and does 
+ * not need to go through the root.
+ * 
+ * For example:
+ * Given the below binary tree,
+ * 
+ *        1
+ *       / \
+ *      2   3
+ * 
+ * Return 6.
+ * 
+ * The helper function returns the max path including the current node's value.
+ */
+
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const maxPathSum = root => {
+  const helper = root => {
+    if (!root) {
+      return 0;
+    }
+
+    const left = Math.max(helper(root.left), 0);
+    const right = Math.max(helper(root.right), 0);
+
+    max = Math.max(max, root.val + left + right);
+
+    return root.val + Math.max(left, right);
+  };
+
+  let max = Number.MIN_SAFE_INTEGER;
+  helper(root);
+  return max;
+};
+
+export default maxPathSum;