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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

Product = 2 , Sum = 3


My Personal Notes arrow_drop_up

Strategy Path planning and Destination matters in success No need to worry about in between temporary failures

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.