Find the maximum path sum between two leaves of a binary tree using JavaScript

class TreeNode {
    constructor(val) {
        this.val = val;
        this.left = this.right = null;
    }
}

// Helper function to find the maximum 
// path sum from the given node to any leaf
function PathSum(node) 
{
    if (node === null) return 0;
    if (node.left === null && node.right === null)
        return node.val;
    // Leaf node

    const leftSum = node
        .left ? PathSum(node.left) : -Infinity;
    const rightSum = node
        .right ? PathSum(node.right) : -Infinity;

    return node
        .val + Math
            .max(leftSum, rightSum);
}

// Function to find the maximum path sum between 
// two leaf nodes considering the given node as root
function maxPathSumNode(node)
{
    if (node === null) return -Infinity;
    if (node.left === null || node.right === null)
        return -Infinity;

    const leftSum = PathSum(node.left);
    const rightSum = PathSum(node.right);

    return leftSum + rightSum + node.val;
}

// Function to traverse the tree
//  and update the maximum path sum
function traverseTree(node, maxSum) {
    if (node === null) return;

    const currentMax = maxPathSumNode(node);
    if (currentMax > maxSum.value) maxSum.
    value = currentMax;

    traverseTree(node.left, maxSum);
    traverseTree(node.right, maxSum);
}

// The main function to return
//  the maximum sum between two leaves
function maxSum(root) {
    let maxSum = { value: -Infinity };
    traverseTree(root, maxSum);
    return maxSum.value;
}

// Utility function to create a new tree node
function newNode(data) {
    return new TreeNode(data);
}

// Example usage
const root = newNode(-10);
root.left = newNode(9);
root.right = newNode(20);
root.right.left = newNode(15);
root.right.right = newNode(7);

console.log("Max path sum of the given binary tree is " + maxSum(root));

class TreeNode {
    constructor(val = 0, left = null, right = null)
    {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

class Solution {
    maxPathSum(root) {
        let ans = [-Infinity];
        // Initialize with negative 
        // infinity for comparison

        function DFS(root)
        {
            if (root === null)
            {
                return 0;
            }
            let lmax = Math
                .max(0, DFS(root.left));
            let rmax = Math
                .max(0, DFS(root.right));

            // Update the overall 
            // maximum path sum
            ans[0] = Math
                .max(ans[0], root.val + lmax + rmax);

            // Return the maximum path sum
            // that starts from the current node
            return root
                .val + Math
                    .max(lmax, rmax);
        }

        // Call the DFS function
        //  on the root node
        DFS(root);

        // Return the final maximum path sum
        return ans[0] !== -Infinity ? ans[0] : 0;
        // If ans is still -Infinity, return 0
    }
}

// Example input
let root = new TreeNode(-10);
root.left = new TreeNode(9);
root.right = new TreeNode(20);
root.right.left = new TreeNode(15);
root.right.right = new TreeNode(7);

let solution = new Solution();
console.log(solution.maxPathSum(root));

class TreeNode {
    constructor(val) {
        this.val = val;
        this.left = this.right = null;
    }
}

class Solution {
    constructor() {
        this.dp = new Map(); // Map to store the DP results
    }

    maxPathSum(root) {
        let maxSum = { value: -Infinity };
        this.findMaxPath(root, maxSum);
        return maxSum.value;
    }

    findMaxPath(node, maxSum) {
        if (node === null) return 0;

        // Check if the result for this node is already calculated
        if (this.dp.has(node)) return this.dp.get(node);

        // Calculate the maximum path sum of left and right children
        let leftMax = Math.max(0, this.findMaxPath(node.left, maxSum));
        let rightMax = Math.max(0, this.findMaxPath(node.right, maxSum));

        // Update the global maximum path sum including this node
        let currentMax = node.val + leftMax + rightMax;
        maxSum.value = Math.max(maxSum.value, currentMax);

        // Store the result in the DP table and return the maximum path sum 
        // starting from this node to its parent
        let result = node.val + Math.max(leftMax, rightMax);
        this.dp.set(node, result);

        return result;
    }
}

// Example usage
let root = new TreeNode(-10);
root.left = new TreeNode(9);
root.right = new TreeNode(20);
root.right.left = new TreeNode(15);
root.right.right = new TreeNode(7);

let solution = new Solution();
console.log("Max path sum of the given binary tree is " + solution.maxPathSum(root));