# Find multiplication of sums of data of leaves at same levels

Given a Binary Tree, return following value for it.
1) For every level, compute sum of all leaves if there are leaves at this level. Otherwise ignore it.
2) 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)  ```

We strongly recommend you to minimize your browser and try this yourself first.

One Simple Solution is to recursively compute leaf sum for all level starting from top to bottom. Then multiply sums of levels which have leaves. Time complexity of this solution would be O(n2).

An Efficient Solution is to use Queue based level order traversal. While doing the traversal, process all different levels separately. For every processed level, check if it has a leaves. If it has then compute sum of leaf nodes. Finally return product of all sums.

## C++

 `/* Iterative C++ program to find sum of data of all leaves ` `   ``of a binary tree on same level and then multiply sums ` `   ``obtained of all levels. */` `#include ` `using` `namespace` `std; ` ` `  `// A Binary Tree Node ` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node *left, *right; ` `}; ` ` `  `// helper function to check if a Node is leaf of tree ` `bool` `isLeaf(Node* root) ` `{ ` `    ``return` `(!root->left && !root->right); ` `} ` ` `  `/* Calculate sum of all leaf Nodes at each level and returns ` `   ``multiplication of sums */` `int` `sumAndMultiplyLevelData(Node* root) ` `{ ` `    ``// Tree is empty ` `    ``if` `(!root) ` `        ``return` `0; ` ` `  `    ``int` `mul = 1; ``/* To store result */` ` `  `    ``// Create an empty queue for level order tarversal ` `    ``queue q; ` ` `  `    ``// Enqueue Root and initialize height ` `    ``q.push(root); ` ` `  `    ``// Do level order traversal of tree ` `    ``while` `(1) { ` `        ``// NodeCount (queue size) indicates number of Nodes ` `        ``// at current lelvel. ` `        ``int` `NodeCount = q.size(); ` ` `  `        ``// If there are no Nodes at current level, we are done ` `        ``if` `(NodeCount == 0) ` `            ``break``; ` ` `  `        ``// Initialize leaf sum for current level ` `        ``int` `levelSum = 0; ` ` `  `        ``// A boolean variable to indicate if found a leaf ` `        ``// Node at current level or not ` `        ``bool` `leafFound = ``false``; ` ` `  `        ``// Dequeue all Nodes of current level and Enqueue all ` `        ``// Nodes of next level ` `        ``while` `(NodeCount > 0) { ` `            ``// Process next Node  of current level ` `            ``Node* Node = q.front(); ` ` `  `            ``/* if Node is a leaf, update sum at the level */` `            ``if` `(isLeaf(Node)) { ` `                ``leafFound = ``true``; ` `                ``levelSum += Node->data; ` `            ``} ` `            ``q.pop(); ` ` `  `            ``// Add children of Node ` `            ``if` `(Node->left != NULL) ` `                ``q.push(Node->left); ` `            ``if` `(Node->right != NULL) ` `                ``q.push(Node->right); ` `            ``NodeCount--; ` `        ``} ` ` `  `        ``// If we found at least one leaf, we multiply ` `        ``// result with level sum. ` `        ``if` `(leafFound) ` `            ``mul *= levelSum; ` `    ``} ` ` `  `    ``return` `mul; ``// Return result ` `} ` ` `  `// Utility 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; ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``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 value = "` `         ``<< sumAndMultiplyLevelData(root) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `/* Iterative Java program to find sum of data of all leaves ` `   ``of a binary tree on same level and then multiply sums ` `   ``obtained of all levels. */` ` `  `/* importing the necessary class */` `import` `java.util.LinkedList; ` `import` `java.util.Queue; ` `import` `java.util.Stack; ` ` `  `/* Class containing left and right child of current  ` ` ``node and key value*/` `class` `Node { ` ` `  `    ``int` `data; ` `    ``Node left, right; ` ` `  `    ``public` `Node(``int` `item) ` `    ``{ ` `        ``data = item; ` `        ``left = right = ``null``; ` `    ``} ` `} ` ` `  `class` `BinaryTree { ` ` `  `    ``Node root; ` ` `  `    ``// helper function to check if a Node is leaf of tree ` `    ``boolean` `isLeaf(Node node) ` `    ``{ ` `        ``return` `((node.left == ``null``) && (node.right == ``null``)); ` `    ``} ` ` `  `    ``/* Calculate sum of all leaf Nodes at each level and returns ` `     ``multiplication of sums */` `    ``int` `sumAndMultiplyLevelData() ` `    ``{ ` `        ``return` `sumAndMultiplyLevelData(root); ` `    ``} ` `    ``int` `sumAndMultiplyLevelData(Node node) ` `    ``{ ` `        ``// Tree is empty ` `        ``if` `(node == ``null``) { ` `            ``return` `0``; ` `        ``} ` ` `  `        ``int` `mul = ``1``; ``/* To store result */` ` `  `        ``// Create an empty queue for level order tarversal ` `        ``LinkedList q = ``new` `LinkedList(); ` ` `  `        ``// Enqueue Root and initialize height ` `        ``q.add(node); ` ` `  `        ``// Do level order traversal of tree ` `        ``while` `(``true``) { ` ` `  `            ``// NodeCount (queue size) indicates number of Nodes ` `            ``// at current lelvel. ` `            ``int` `NodeCount = q.size(); ` ` `  `            ``// If there are no Nodes at current level, we are done ` `            ``if` `(NodeCount == ``0``) { ` `                ``break``; ` `            ``} ` ` `  `            ``// Initialize leaf sum for current level ` `            ``int` `levelSum = ``0``; ` ` `  `            ``// A boolean variable to indicate if found a leaf ` `            ``// Node at current level or not ` `            ``boolean` `leafFound = ``false``; ` ` `  `            ``// Dequeue all Nodes of current level and Enqueue all ` `            ``// Nodes of next level ` `            ``while` `(NodeCount > ``0``) { ` `                ``Node node1; ` `                ``node1 = q.poll(); ` ` `  `                ``/* if Node is a leaf, update sum at the level */` `                ``if` `(isLeaf(node1)) { ` `                    ``leafFound = ``true``; ` `                    ``levelSum += node1.data; ` `                ``} ` ` `  `                ``// Add children of Node ` `                ``if` `(node1.left != ``null``) { ` `                    ``q.add(node1.left); ` `                ``} ` `                ``if` `(node1.right != ``null``) { ` `                    ``q.add(node1.right); ` `                ``} ` `                ``NodeCount--; ` `            ``} ` ` `  `            ``// If we found at least one leaf, we multiply ` `            ``// result with level sum. ` `            ``if` `(leafFound) { ` `                ``mul *= levelSum; ` `            ``} ` `        ``} ` ` `  `        ``return` `mul; ``// Return result ` `    ``} ` ` `  `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` ` `  `        ``/* creating a binary tree and entering  ` `         ``the nodes */` `        ``BinaryTree tree = ``new` `BinaryTree(); ` `        ``tree.root = ``new` `Node(``2``); ` `        ``tree.root.left = ``new` `Node(``7``); ` `        ``tree.root.right = ``new` `Node(``5``); ` `        ``tree.root.left.left = ``new` `Node(``8``); ` `        ``tree.root.left.right = ``new` `Node(``6``); ` `        ``tree.root.left.right.left = ``new` `Node(``1``); ` `        ``tree.root.left.right.right = ``new` `Node(``11``); ` `        ``tree.root.right.right = ``new` `Node(``9``); ` `        ``tree.root.right.right.left = ``new` `Node(``4``); ` `        ``tree.root.right.right.right = ``new` `Node(``10``); ` `        ``System.out.println(``"The final product value : "` `                           ``+ tree.sumAndMultiplyLevelData()); ` `    ``} ` `} ` ` `  `// This code is contributed by Mayank Jaiswal `

## Python3

 `"""Iterative Python3 program to find  ` `sum of data of all leaves of a binary ` `tree on same level and then multiply  ` `sums obtained of all levels."""` ` `  `# A Binary Tree Node ` `# Utility function to create a  ` `# new tree Node  ` `class` `newNode:  ` `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.left ``=` `self``.right ``=` `None` `         `  `# helper function to check if a ` `# Node is leaf of tree  ` `def` `isLeaf(root) : ` ` `  `    ``return` `(``not` `root.left ``and`  `            ``not` `root.right)  ` ` `  `""" Calculate sum of all leaf Nodes at each  ` `level and returns multiplication of sums """` `def` `sumAndMultiplyLevelData( root) : ` ` `  `    ``# Tree is empty  ` `    ``if` `(``not` `root) : ` `        ``return` `0` ` `  `    ``mul ``=` `1` `     `  `    ``""" To store result """` `    ``# Create an empty queue for level ` `    ``# order tarversal  ` `    ``q ``=` `[] ` ` `  `    ``# Enqueue Root and initialize height  ` `    ``q.append(root)  ` ` `  `    ``# Do level order traversal of tree  ` `    ``while` `(``1``): ` `         `  `        ``# NodeCount (queue size) indicates  ` `        ``# number of Nodes at current lelvel.  ` `        ``NodeCount ``=` `len``(q)  ` ` `  `        ``# If there are no Nodes at current ` `        ``# level, we are done  ` `        ``if` `(NodeCount ``=``=` `0``) : ` `            ``break` ` `  `        ``# Initialize leaf sum for  ` `        ``# current level  ` `        ``levelSum ``=` `0` ` `  `        ``# A boolean variable to indicate  ` `        ``# if found a leaf Node at current  ` `        ``# level or not  ` `        ``leafFound ``=` `False` ` `  `        ``# Dequeue all Nodes of current level  ` `        ``# and Enqueue all Nodes of next level  ` `        ``while` `(NodeCount > ``0``) : ` `             `  `            ``# Process next Node of current level  ` `            ``Node ``=` `q[``0``]  ` ` `  `            ``""" if Node is a leaf, update  ` `                ``sum at the level """` `            ``if` `(isLeaf(Node)) : ` `                ``leafFound ``=` `True` `                ``levelSum ``+``=` `Node.data  ` ` `  `            ``q.pop(``0``)  ` ` `  `            ``# Add children of Node  ` `            ``if` `(Node.left !``=` `None``) : ` `                ``q.append(Node.left)  ` `            ``if` `(Node.right !``=` `None``) : ` `                ``q.append(Node.right)  ` `            ``NodeCount``-``=``1` `                 `  `        ``# If we found at least one leaf,  ` `        ``# we multiply result with level sum.  ` `        ``if` `(leafFound) : ` `            ``mul ``*``=` `levelSum  ` `     `  `    ``return` `mul ``# Return result  ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``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``)  ` ` `  `    ``print``(``"Final product value = "``, ` `           ``sumAndMultiplyLevelData(root))  ` ` `  `# This code is contributed ` `# by SHUBHAMSINGH10 `

## C#

 `/* Iterative C# program to find sum  ` `of data of all leaves of a binary tree  ` `on same level and then multiply sums ` `obtained of all levels. */` ` `  `/* importing the necessary class */` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `/* Class containing left and right child ` ` ``of current node and key value*/` `public` `class` `Node  ` `{ ` ` `  `    ``public` `int` `data; ` `    ``public` `Node left, right; ` ` `  `    ``public` `Node(``int` `item) ` `    ``{ ` `        ``data = item; ` `        ``left = right = ``null``; ` `    ``} ` `} ` ` `  `public` `class` `BinaryTree  ` `{ ` ` `  `    ``Node root; ` ` `  `    ``// helper function to check if  ` `    ``// a Node is leaf of tree ` `    ``bool` `isLeaf(Node node) ` `    ``{ ` `        ``return` `((node.left == ``null``) &&  ` `                ``(node.right == ``null``)); ` `    ``} ` ` `  `    ``/* Calculate sum of all leaf ` `    ``Nodes at each level and returns ` `    ``multiplication of sums */` `    ``int` `sumAndMultiplyLevelData() ` `    ``{ ` `        ``return` `sumAndMultiplyLevelData(root); ` `    ``} ` `    ``int` `sumAndMultiplyLevelData(Node node) ` `    ``{ ` `        ``// Tree is empty ` `        ``if` `(node == ``null``) { ` `            ``return` `0; ` `        ``} ` ` `  `        ``int` `mul = 1; ``/* To store result */` ` `  `        ``// Create an empty queue for level order tarversal ` `        ``Queue q = ``new` `Queue(); ` ` `  `        ``// Enqueue Root and initialize height ` `        ``q.Enqueue(node); ` ` `  `        ``// Do level order traversal of tree ` `        ``while` `(``true``) { ` ` `  `            ``// NodeCount (queue size) indicates  ` `            ``// number of Nodes at current lelvel. ` `            ``int` `NodeCount = q.Count; ` ` `  `            ``// If there are no Nodes at current  ` `            ``// level, we are done ` `            ``if` `(NodeCount == 0)  ` `            ``{ ` `                ``break``; ` `            ``} ` ` `  `            ``// Initialize leaf sum for current level ` `            ``int` `levelSum = 0; ` ` `  `            ``// A boolean variable to indicate if found a leaf ` `            ``// Node at current level or not ` `            ``bool` `leafFound = ``false``; ` ` `  `            ``// Dequeue all Nodes of current level and  ` `            ``// Enqueue all Nodes of next level ` `            ``while` `(NodeCount > 0)  ` `            ``{ ` `                ``Node node1; ` `                ``node1 = q.Dequeue(); ` ` `  `                ``/* if Node is a leaf, update sum at the level */` `                ``if` `(isLeaf(node1)) ` `                ``{ ` `                    ``leafFound = ``true``; ` `                    ``levelSum += node1.data; ` `                ``} ` ` `  `                ``// Add children of Node ` `                ``if` `(node1.left != ``null``)  ` `                ``{ ` `                    ``q.Enqueue(node1.left); ` `                ``} ` `                ``if` `(node1.right != ``null``)  ` `                ``{ ` `                    ``q.Enqueue(node1.right); ` `                ``} ` `                ``NodeCount--; ` `            ``} ` ` `  `            ``// If we found at least one leaf, we multiply ` `            ``// result with level sum. ` `            ``if` `(leafFound)  ` `            ``{ ` `                ``mul *= levelSum; ` `            ``} ` `        ``} ` ` `  `        ``return` `mul; ``// Return result ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String []args) ` `    ``{ ` ` `  `        ``/* creating a binary tree and entering  ` `        ``the nodes */` `        ``BinaryTree tree = ``new` `BinaryTree(); ` `        ``tree.root = ``new` `Node(2); ` `        ``tree.root.left = ``new` `Node(7); ` `        ``tree.root.right = ``new` `Node(5); ` `        ``tree.root.left.left = ``new` `Node(8); ` `        ``tree.root.left.right = ``new` `Node(6); ` `        ``tree.root.left.right.left = ``new` `Node(1); ` `        ``tree.root.left.right.right = ``new` `Node(11); ` `        ``tree.root.right.right = ``new` `Node(9); ` `        ``tree.root.right.right.left = ``new` `Node(4); ` `        ``tree.root.right.right.right = ``new` `Node(10); ` `        ``Console.WriteLine(``"The final product value : "` `                        ``+ tree.sumAndMultiplyLevelData()); ` `    ``} ` `}  ` ` `  `// This code has been contributed by 29AjayKumar `

Output:

`Final product value = 208`

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.