Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# 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 ```

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 a 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.

Algorithm:

• Create a function called newNode that takes an integer parameter, and data, and returns a new node with null left and right pointers. It gives back the newly made node.
•  With an integer variable named a, define the static class Int.
• Create the function findProductSum and define its three arguments: the root node, prod, and sum, two Int objects. This function calculates the product and sum of the binary tree’s non-leaf nodes. It carries out the subsequent actions:

•  Return whether either the root node or the root node’s left and right child nodes are null.
• Multiply the product by the node’s data, then add the node’s data to the sum if the root node has at least one non-null child.
• Recursively call the findProductSum function for the left child of the root node.
•  Recursively call the findProductSum function for the right child of the root node.

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 pointers.                                ``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`

## Javascript

 ``

Output

`Product = 2 , Sum = 3`

Complexity Analysis:

• Time Complexity: O(N)
• As we are visiting every node just once.
• Auxiliary Space: O(h)
• Here h is the height of the tree and extra space is used in recursion call stack. In the worst case(when tree is skewed) this can go upto O(N).

My Personal Notes arrow_drop_up