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

Last Updated : 15 Mar, 2023

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 <bits/stdc++.h>
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 = "<<prod<<" , Sum = "<<sum;
     
    return 0;
}

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

<script>
 
// JavaScript program to find product and sum of 
// non-leaf nodes in a binary tree 
/* A binary tree node has data, pointer to 
left child and a pointer to right child */
class Node {
    constructor() {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
}
 
/* Helper function that allocates a new node with the 
given data and null left and right pointers. */
function newNode(data) 
{ 
    var node = new Node(); 
    node.data = data; 
    node.left = node.right = null; 
    return (node); 
} 
 
//var class
 class Int
{
constructor(){
    this.a = 0;
    }
}
 
// Computes the product of non-leaf 
// nodes in a tree 
function findProductSum(root,  prod,  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 
  
    // Binary Tree 
     root = newNode(1); 
    root.left = newNode(2); 
    root.right = newNode(3); 
    root.left.left = newNode(4); 
    root.left.right = newNode(5); 
     
    var prod = new Int();
    prod.a = 1; 
    var sum = new Int();
    sum.a = 0; 
     
    findProductSum(root, prod, sum); 
     
    document.write("Product = " + prod.a + " , Sum = " + sum.a); 
 
 
// This code contributed by aashish1995 
 
</script>

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

Print leftmost and rightmost nodes of a Binary Tree

Rajput-Ji

Improve

Article Tags :

Practice Tags :

Tree

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

C++

Java

Python3

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?