Find product of sums of data of leaves at same levels

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)

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++ program to find product of sums 
// of data of leaves at same levels 
// using map in STL 
#include <bits/stdc++.h> 
using namespace std; 
  
// Binary Tree Node 
struct Node { 
    int data; 
    Node* left; 
    Node* right; 
}; 
  
// Utitlity function to create 
// a new Tree node 
Node* 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_map 
void productOfLevelSumUtil(Node* root, 
       unordered_map<int, int>& 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 sums 
int productOfLevelSum(Node* root) 
{ 
    // Create a map to store sum of leaf 
    // nodes at same levels. 
    unordered_map<int, int> 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 Code 
int 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; 
} 

Output:

Final product is = 208

Time Complexity: O(N)
Auxiliary Space: O(N)
Where N is the number of nodes in the Binary Tree.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Recommended Posts: