# Find product of sums of data of leaves at same levels | Set 2

• Last Updated : 12 Jan, 2023

Given a Binary Tree, return following value for it.

• For every level, compute sum of all leaves if there are leaves at this level. Otherwise ignore it.
• Return multiplication of all sums.

Examples

Input: Root of below tree
2
/   \
7     5
\
9
Output: 63
First levels doesn't have leaves. Second level
has one leaf 7 and third level also has one
leaf 9. Therefore result is 7*9 = 63

Input: Root of below tree
2
/   \
7      5
/ \      \
8   6      9
/ \    /  \
1  11  4    10

Output: 208
First two levels don't have leaves. Third
level has single leaf 8. Last level has four
leaves 1, 11, 4 and 10. Therefore result is
8 * (1 + 11 + 4 + 10)

In the previous article we have seen a Queue based solution using level order traversal.
Here, we are simply doing preorder traversal of the binary tree, and we have used unordered_map in C++ STL to store sum of leaf nodes at same level. Then in a single traversal of the map, we’ve calculated the final product of level sums.

Below is the implementation of above approach:

## C++

 // C++ program to find product of sums// of data of leaves at same levels// using map in STL#include using namespace std; // Binary Tree Nodestruct Node {    int data;    Node* left;    Node* right;}; // Utility function to create// a new Tree nodeNode* newNode(int data){    Node* temp = new Node;    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // Helper function to calculate sum of// leaf nodes at same level and store in// an unordered_mapvoid productOfLevelSumUtil(Node* root,       unordered_map& level_sum,                                int level){     if (!root)        return;     // Check if current node is a leaf node    // If yes add it to sum of current level    if (!root->left && !root->right)        level_sum[level] += root->data;     // Traverse left subtree    productOfLevelSumUtil(root->left, level_sum,                          level + 1);     // Traverse right subtree    productOfLevelSumUtil(root->right, level_sum,                          level + 1);} // Function to calculate product of level sumsint productOfLevelSum(Node* root){    // Create a map to store sum of leaf    // nodes at same levels.    unordered_map level_sum;     // Call the helper function to    // calculate level sums of leaf nodes    productOfLevelSumUtil(root, level_sum, 0);     // variable to store final product    int prod = 1;     // Traverse the map to calculate product    // of level sums    for (auto it = level_sum.begin();                it != level_sum.end(); it++)        prod *= it->second;     // Return the result    return prod;} // Driver Codeint main(){    // Creating Binary Tree    Node* root = newNode(2);    root->left = newNode(7);    root->right = newNode(5);    root->left->right = newNode(6);    root->left->left = newNode(8);    root->left->right->left = newNode(1);    root->left->right->right = newNode(11);    root->right->right = newNode(9);    root->right->right->left = newNode(4);    root->right->right->right = newNode(10);     cout << "Final product is = "         << productOfLevelSum(root) << endl;     return 0;}

## Java

 // Java program to find product of sums// of data of leaves at same levels// using map in STLimport java.util.*;public class GFG{    // Binary Tree Node    static class Node {                int data;        Node left, right;                Node(int item)        {            data = item;            left = right = null;        }    }         // Root of the Binary Tree    Node root;    public GFG()    {        root = null;    }         // Utility function to create    // a new Tree node    static Node newNode(int data)    {        Node temp = new Node(data);        return (temp);    }       // Create a map to store sum of leaf    // nodes at same levels.    static HashMap level_sum = new HashMap<>();       // Helper function to calculate sum of    // leaf nodes at same level and store in    // an unordered_map    static void productOfLevelSumUtil(Node root, int level)    {           if (root == null)            return;           // Check if current node is a leaf node        // If yes add it to sum of current level        if (root.left == null && root.right == null)        {            if(level_sum.containsKey(level))            {                 level_sum.put(level, level_sum.get(level) + root.data);            }            else{                level_sum.put(level, root.data);            }        }           // Traverse left subtree        productOfLevelSumUtil(root.left, level + 1);           // Traverse right subtree        productOfLevelSumUtil(root.right, level + 1);    }       // Function to calculate product of level sums    static int productOfLevelSum(Node root)    {        // Call the helper function to        // calculate level sums of leaf nodes        productOfLevelSumUtil(root, 0);           // variable to store final product        int prod = 1;           // Traverse the map to calculate product        // of level sums        for (Map.Entry it : level_sum.entrySet())        {            prod *= it.getValue();        }           // Return the result        return prod;    }         public static void main(String[] args) {        // Creating Binary Tree        GFG tree = new GFG();        tree.root = newNode(2);        tree.root.left = newNode(7);        tree.root.right = newNode(5);        tree.root.left.right = newNode(6);        tree.root.left.left = newNode(8);        tree.root.left.right.left = newNode(1);        tree.root.left.right.right = newNode(11);        tree.root.right.right = newNode(9);        tree.root.right.right.left = newNode(4);        tree.root.right.right.right = newNode(10);                 System.out.print("Final product is = " + productOfLevelSum(tree.root));    }} // This code is contributed by divyeshrabadiya07.

## Python3

 # Python program to find product of sums# of data of leaves at same levels# using map # Binary Tree Nodeclass Node:    def __init__(self, data):        self.left = None        self.right = None        self.data = data # Utility function to create# a new Tree nodedef newNode(data):    temp = Node(data)    return temp # Create a map to store sum of leaf# nodes at same levels.level_sum = {} # Helper function to calculate sum of# leaf nodes at same level and store in# a dictionarydef productOfLevelSumUtil(root, level):    if root is None:        return     # Check if current node is a leaf node    # If yes add it to sum of current level    if root.left is None and root.right is None:        if level in level_sum:            level_sum[level] += root.data        else:            level_sum[level] = root.data     # Traverse left subtree    productOfLevelSumUtil(root.left, level + 1)     # Traverse right subtree    productOfLevelSumUtil(root.right, level + 1) # Function to calculate product of level sumsdef productOfLevelSum(root):    # Call the helper function to    # calculate level sums of leaf nodes    productOfLevelSumUtil(root, 0)     # variable to store final product    prod = 1     # Traverse the dictionary to calculate product    # of level sums    for key in level_sum:        prod *= level_sum[key]     # Return the result    return prod # Creating Binary Treeroot = newNode(2)root.left = newNode(7)root.right = newNode(5)root.left.right = newNode(6)root.left.left = newNode(8)root.left.right.left = newNode(1);root.left.right.right = newNode(11);root.right.right = newNode(9);root.right.right.left = newNode(4);root.right.right.right = newNode(10); print("Final product is = " + str(productOfLevelSum(root)));#This code is contributed by Potta Lokesh

## C#

 // C# program to find product of sums// of data of leaves at same levels// using map in STLusing System;using System.Collections;using System.Collections.Generic; // Binary Tree Nodeclass Node {           public int data;    public Node left, right;       public Node(int item)    {        data = item;        left = right = null;    }}     public class GFG {         // Root of the Binary Tree    Node root;    public GFG()    {        root = null;    }        // Utility function to create    // a new Tree node    static Node newNode(int data)    {        Node temp = new Node(data);        return (temp);    }      // Create a map to store sum of leaf    // nodes at same levels.    static Dictionary level_sum = new Dictionary();      // Helper function to calculate sum of    // leaf nodes at same level and store in    // an unordered_map    static void productOfLevelSumUtil(Node root, int level)    {          if (root == null)            return;          // Check if current node is a leaf node        // If yes add it to sum of current level        if (root.left == null && root.right == null)        {            if(level_sum.ContainsKey(level))            {                  level_sum[level] += root.data;            }            else{                level_sum[level] = root.data;            }        }          // Traverse left subtree        productOfLevelSumUtil(root.left, level + 1);          // Traverse right subtree        productOfLevelSumUtil(root.right, level + 1);    }      // Function to calculate product of level sums    static int productOfLevelSum(Node root)    {        // Call the helper function to        // calculate level sums of leaf nodes        productOfLevelSumUtil(root, 0);          // variable to store final product        int prod = 1;          // Traverse the map to calculate product        // of level sums        foreach(KeyValuePair it in level_sum)        {            prod *= it.Value;        }          // Return the result        return prod;    }   static void Main() {           // Creating Binary Tree    GFG tree = new GFG();    tree.root = newNode(2);    tree.root.left = newNode(7);    tree.root.right = newNode(5);    tree.root.left.right = newNode(6);    tree.root.left.left = newNode(8);    tree.root.left.right.left = newNode(1);    tree.root.left.right.right = newNode(11);    tree.root.right.right = newNode(9);    tree.root.right.right.left = newNode(4);    tree.root.right.right.right = newNode(10);        Console.Write("Final product is = " + productOfLevelSum(tree.root));  }} // This code is contributed by decode2207.

## Javascript



Output

Final product is = 208

Complexity Analysis:

• Time Complexity: O(N)
• Auxiliary Space: O(N)

Where N is the number of nodes in the Binary Tree

My Personal Notes arrow_drop_up