Sum of nodes at maximum depth of a Binary Tree

<script>

// Javascript code to find the sum of the nodes 
// which are present at the maximum depth.
var sum = 0, max_level = -1000000000; 

class Node 
{ 
    constructor()
    {
        this.d = 0;
        this.l = null;
        this.r = null;
    } 
}; 

// Function to return a new node 
function createNode(d) 
{ 
    var node; 
    node = new Node(); 
    node.d = d; 
    node.l = null; 
    node.r = null; 
    return node; 
} 

// Function to find the sum of the node 
// which are present at the maximum depth. 
// While traversing the nodes compare the level 
// of the node with max_level 
// (Maximum level till the current node). 
// If the current level exceeds the maximum level, 
// update the max_level as current level. 
// If the max level and current level are same, 
// add the root data to current sum. 
function sumOfNodesAtMaxDepth(ro, level) 
{ 
    if (ro == null) 
        return; 
        
    if (level > max_level) 
    { 
        sum = ro . d; 
        max_level = level; 
    } 
    else if (level == max_level) 
    { 
        sum = sum + ro . d; 
    } 
    sumOfNodesAtMaxDepth(ro.l, level + 1); 
    sumOfNodesAtMaxDepth(ro.r, level + 1); 
} 

// Driver Code 
var root; 
root = createNode(1); 
root.l = createNode(2); 
root.r = createNode(3); 
root.l.l = createNode(4); 
root.l.r = createNode(5); 
root.r.l = createNode(6); 
root.r.r = createNode(7); 

sumOfNodesAtMaxDepth(root, 0); 

document.write(sum); 

// This code is contributed by rrrtnx

</script>

<script>
    // Javascript code for sum of nodes at maximum depth 
    
    // Structure of a tree node. 
    class Node
    {
        constructor(data) {
           this.left = null;
           this.right = null;
           this.data = data;
        }
    }

    // function to find the sum of nodes at
    // maximum depth arguments are node and
    // max, where max is to match the depth
    // of node at every call to node, if
    // max will be equal to 1, means
    // we are at deepest node.
    function sumMaxLevelRec(node, max)
    {
    
        // base case
        if (node == null)
            return 0;    
 
        // max == 1 to track the node
        // at deepest level
        if (max == 1)
            return node.data;   
 
        // recursive call to left and right nodes
        return sumMaxLevelRec(node.left, max - 1) +
               sumMaxLevelRec(node.right, max - 1);
    }
 
    function sumMaxLevel(root) {
 
        // call to function to calculate
        // max depth
        let MaxDepth = maxDepth(root);
         
        return sumMaxLevelRec(root, MaxDepth);
    }
 
    // maxDepth function to find the
    // max depth of the tree
    function maxDepth(node)
    {
        // base case
        if (node == null)
            return 0;    
 
        // either leftDepth of rightDepth is
        // greater add 1 to include height
        // of node at which call is
        return 1 + Math.max(maxDepth(node.left),
                           maxDepth(node.right));    
    }
    
        /*      1
                / \
                2   3
              / \ / \
              4 5 6 7     */

    // Constructing tree
    let root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.left.left = new Node(4);
    root.left.right = new Node(5);
    root.right.left = new Node(6);
    root.right.right = new Node(7);


    // call to calculate required sum
    document.write(sumMaxLevel(root));

// This code is contributed by divyesh072019.
</script>

<script>

// JavaScript code to print the sum 
// of leaves present at maximum
// depth of a binary tree

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

function createNode(d)
{
    let node;
        node = new TreeNode();
        node.val = d;
        node.left = null;
        node.right = null;
        return node;
}

// Iterative function to find the sum of the deepest
    // nodes.
function deepestLeavesSum(root)
{
    // if the root is null then return 0
        if (root== null) {
            return 0;
        }
          // Initialize an empty queue.
        let qu= [];
        // push the root of the tree into the queue
        qu.push(root);
        // initialize sum of current level to 0
        let sumOfCurrLevel= 0;
          // loop until the queue is not empty
        while (qu.length!=0) {
            let size = qu.length;
            sumOfCurrLevel = 0;
            while (size-- > 0) {
                let head = qu.shift();
                sumOfCurrLevel += head.val;
                // if the left child of the head is not null
                if (head.left!= null) {
                    //push the child into the queue
                    qu.push(head.left);
                }
                // if the right child is not null
                if (head.right!= null) {
                   // push the child into the queue
                    qu.push(head.right);
                }
            }
        }
        return sumOfCurrLevel;
}

let root = createNode(1);
root.left = createNode(2);
root.right = createNode(3);
root.left.left = createNode(4);
root.left.right = createNode(5);
root.right.left = createNode(6);
root.right.right = createNode(7);
document.write(deepestLeavesSum(root));

// This code is contributed by avanitrachhadiya2155

</script>