# Print Sum and Product of all Non-Leaf nodes in Binary Tree

Given a Binary tree. The task is to find and print the product and sum of all internal nodes (non-leaf nodes) in the tree. In the above tree, only two nodes 1 and 2 are non-leaf nodes.
Therefore, product of non-leaf nodes = 1 * 2 = 2.
And sum of non-leaf nodes = 1 + 2 =3.

Examples:

```Input :
1
/   \
2     3
/ \   / \
4   5 6   7
\
8
Output : Product  = 36, Sum = 12
Non-leaf nodes are: 1, 2, 3, 6
```

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

Approach: The idea is to traverse the tree in any fashion and check if the current node is a non-leaf node or not. Take two variables product and sum to store the product and sum of non-leaf nodes respectively. If the current node is non-leaf node then multiply the node’s data to the variable product used to store the products of non-leaf nodes and add the node’s data to the variable sum used to store the sum of non-leaf nodes.

Below is the implementation of the above idea:

## C++

 `// CPP program to find product and sum of ` `// non-leaf nodes in a binary tree ` `#include ` `using` `namespace` `std; ` ` `  `/* A binary tree node has data, pointer to  ` `left child and a pointer to right child */` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* left; ` `    ``struct` `Node* right; ` `}; ` ` `  `/* Helper function that allocates a new node with the  ` `given data and NULL left and right pointers. */` `struct` `Node* newNode(``int` `data) ` `{ ` `    ``struct` `Node* node = ``new` `Node; ` `    ``node->data = data; ` `    ``node->left = node->right = NULL; ` `    ``return` `(node); ` `} ` ` `  `// Computes the product of non-leaf  ` `// nodes in a tree ` `void` `findProductSum(``struct` `Node* root, ``int``& prod, ``int``& sum) ` `{ ` `    ``// Base cases ` `    ``if` `(root == NULL || (root->left == NULL  ` `                            ``&& root->right == NULL)) ` `        ``return``; ` `     `  `    ``// if current node is non-leaf, ` `    ``// calculate product and sum ` `    ``if` `(root->left != NULL || root->right != NULL) ` `    ``{ ` `        ``prod *= root->data; ` `        ``sum += root->data; ` `    ``} ` `         `  `    ``// If root is Not NULL and its one of its ` `    ``// child is also not NULL ` `    ``findProductSum(root->left, prod, sum); ` `    ``findProductSum(root->right, prod, sum); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{    ` `    ``// Binary Tree ` `    ``struct` `Node* root = newNode(1); ` `    ``root->left = newNode(2); ` `    ``root->right = newNode(3); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(5); ` `     `  `    ``int` `prod = 1; ` `    ``int` `sum = 0; ` `     `  `    ``findProductSum(root, prod, sum); ` `     `  `    ``cout <<``"Product = "``<

## Java

 `// Java program to find product and sum of  ` `// non-leaf nodes in a binary tree  ` `class` `GFG ` `{ ` ` `  `/* A binary tree node has data, pointer to  ` `left child and a pointer to right child */` `static` `class` `Node  ` `{  ` `    ``int` `data;  ` `    ``Node left;  ` `    ``Node right;  ` `};  ` ` `  `/* Helper function that allocates a new node with the  ` `given data and null left and right pointers. */` `static` `Node newNode(``int` `data)  ` `{  ` `    ``Node node = ``new` `Node();  ` `    ``node.data = data;  ` `    ``node.left = node.right = ``null``;  ` `    ``return` `(node);  ` `}  ` ` `  `//int class ` `static` `class` `Int ` `{ ` `    ``int` `a; ` `} ` ` `  `// Computes the product of non-leaf  ` `// nodes in a tree  ` `static` `void` `findProductSum(Node root, Int prod, Int sum)  ` `{  ` `    ``// Base cases  ` `    ``if` `(root == ``null` `|| (root.left == ``null` `                            ``&& root.right == ``null``))  ` `        ``return``;  ` `     `  `    ``// if current node is non-leaf,  ` `    ``// calculate product and sum  ` `    ``if` `(root.left != ``null` `|| root.right != ``null``)  ` `    ``{  ` `        ``prod.a *= root.data;  ` `        ``sum.a += root.data;  ` `    ``}  ` `         `  `    ``// If root is Not null and its one of its  ` `    ``// child is also not null  ` `    ``findProductSum(root.left, prod, sum);  ` `    ``findProductSum(root.right, prod, sum);  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `main(String args[]) ` `{  ` `    ``// Binary Tree  ` `    ``Node root = newNode(``1``);  ` `    ``root.left = newNode(``2``);  ` `    ``root.right = newNode(``3``);  ` `    ``root.left.left = newNode(``4``);  ` `    ``root.left.right = newNode(``5``);  ` `     `  `    ``Int prod = ``new` `Int();prod.a = ``1``;  ` `    ``Int sum = ``new` `Int(); sum.a = ``0``;  ` `     `  `    ``findProductSum(root, prod, sum);  ` `     `  `    ``System.out.print(``"Product = "` `+ prod.a + ``" , Sum = "` `+ sum.a);  ` `} ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 program to find product and sum  ` `# of non-leaf nodes in a binary tree ` ` `  `# Helper function that allocates a new  ` `# node with the given data and None  ` `# left and right poers.                                  ` `class` `newNode:  ` ` `  `    ``# Construct to create a new node  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.data ``=` `key ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Computes the product of non-leaf  ` `# nodes in a tree  ` `class` `new: ` `    ``def` `findProductSum(sf,root) : ` `     `  `        ``# Base cases  ` `        ``if` `(root ``=``=` `None` `or` `(root.left ``=``=` `None` `and` `                             ``root.right ``=``=` `None``)) : ` `            ``return` `             `  `        ``# if current node is non-leaf,  ` `        ``# calculate product and sum  ` `        ``if` `(root.left !``=` `None` `or`  `            ``root.right !``=` `None``) : ` `             `  `            ``sf.prod ``*``=` `root.data  ` `            ``sf.``sum` `+``=` `root.data  ` `             `  `        ``# If root is Not None and its one  ` `        ``# of its child is also not None  ` `        ``sf.findProductSum(root.left)  ` `        ``sf.findProductSum(root.right) ` `     `  `    ``def` `main(sf): ` `        ``root ``=` `newNode(``1``)  ` `     `  `        ``root.left ``=` `newNode(``2``)  ` `        ``root.right ``=` `newNode(``3``)  ` `        ``root.left.left ``=` `newNode(``4``)  ` `        ``root.left.right ``=` `newNode(``5``) ` `     `  `        ``sf.prod ``=` `1` `        ``sf.``sum` `=` `0` `     `  `        ``sf.findProductSum(root) ` `     `  `        ``print``(``"Product ="``, sf.prod, ` `              ``", Sum ="``, sf.``sum``) ` `     `  `# Driver Code  ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``x ``=` `new() ` `    ``x.main() ` ` `  `# This code is contributed by ` `# Shubham Singh(SHUBHAMSINGH10) `

## C#

 `// C# program to find product and sum of  ` `// non-leaf nodes in a binary tree  ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `/* A binary tree node has data, pointer to  ` `left child and a pointer to right child */` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node left;  ` `    ``public` `Node right;  ` `};  ` ` `  `/* Helper function that allocates a new node with the  ` `given data and null left and right pointers. */` `static` `Node newNode(``int` `data)  ` `{  ` `    ``Node node = ``new` `Node();  ` `    ``node.data = data;  ` `    ``node.left = node.right = ``null``;  ` `    ``return` `(node);  ` `}  ` ` `  `// int class ` `public` `class` `Int ` `{ ` `    ``public` `int` `a; ` `} ` ` `  `// Computes the product of non-leaf  ` `// nodes in a tree  ` `static` `void` `findProductSum(Node root, Int prod, Int sum)  ` `{  ` `    ``// Base cases  ` `    ``if` `(root == ``null` `|| (root.left == ``null` `                            ``&& root.right == ``null``))  ` `        ``return``;  ` `     `  `    ``// if current node is non-leaf,  ` `    ``// calculate product and sum  ` `    ``if` `(root.left != ``null` `|| root.right != ``null``)  ` `    ``{  ` `        ``prod.a *= root.data;  ` `        ``sum.a += root.data;  ` `    ``}  ` `         `  `    ``// If root is Not null and its one of its  ` `    ``// child is also not null  ` `    ``findProductSum(root.left, prod, sum);  ` `    ``findProductSum(root.right, prod, sum);  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `Main(String []args) ` `{  ` `    ``// Binary Tree  ` `    ``Node root = newNode(1);  ` `    ``root.left = newNode(2);  ` `    ``root.right = newNode(3);  ` `    ``root.left.left = newNode(4);  ` `    ``root.left.right = newNode(5);  ` `     `  `    ``Int prod = ``new` `Int();prod.a = 1;  ` `    ``Int sum = ``new` `Int(); sum.a = 0;  ` `     `  `    ``findProductSum(root, prod, sum);  ` `     `  `    ``Console.Write(``"Product = "` `+ prod.a + ``" , Sum = "` `+ sum.a);  ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar  `

Output:

```Product = 2 , Sum = 3
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

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