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: 

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

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

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