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 \ 9Output: 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 = 63Input: Root of below tree 2 / \ 7 5 / \ \ 8 6 9 / \ / \ 1 11 4 10Output: 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++ 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.