Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Sum of all the child nodes with even parent values in a Binary Tree

  • Difficulty Level : Medium
  • Last Updated : 22 Jun, 2021

Given a binary tree, the task is to find the sum of all the nodes whose parent is even.
Examples: 
 

Input:
       1
      / \
     3   8
        / \
       5   6
      /
     1

Output: 11
The only even nodes are 8 and 6 and 
the sum of their children is 5 + 6 = 11.

Input:
       2
      / \
     3   8
    /   / \
   2   5   6
      /     \
     1       3

Output: 25
3 + 8 + 5 + 6 + 3 = 25

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Approach: Initialise sum = 0 and perform a recursive traversal of the tree and check if the node is even or not, if the node is even then add the values of its children to the sum. Finally, print the sum.
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// A binary tree node
struct Node {
    int data;
    struct Node *left, *right;
};
 
// A utility function to allocate a new node
struct Node* newNode(int data)
{
    struct Node* newNode = new Node;
    newNode->data = data;
    newNode->left = newNode->right = NULL;
    return (newNode);
}
 
// This function visit each node in preorder fashion
// And adds the values of the children of a node with
// even value to the res variable
void calcSum(Node* root, int& res)
{
    // Base Case
    if (root == NULL)
        return;
 
    // If the value of the
    // current node if even
    if (root->data % 2 == 0) {
 
        // If the left child of the even
        // node exist then add it to the res
        if (root->left)
            res += root->left->data;
 
        // Do the same with the right child
        if (root->right)
            res += root->right->data;
    }
 
    // Visiting the left subtree and the right
    // subtree just like preorder traversal
    calcSum(root->left, res);
    calcSum(root->right, res);
}
 
// Function to return the sum of nodes
// whose parent has even value
int findSum(Node* root)
{
    // Initialize result
    int res = 0;
 
    calcSum(root, res);
    return res;
}
 
// Driver code
int main()
{
 
    // Creating the tree
    struct Node* root = newNode(2);
    root->left = newNode(3);
    root->right = newNode(8);
    root->left->left = newNode(2);
    root->right->left = newNode(5);
    root->right->right = newNode(6);
    root->right->left->left = newNode(1);
    root->right->right->right = newNode(3);
 
    // Print the required sum
    cout << findSum(root);
 
    return 0;
}
Java



// Java implementation of the approach
class GFG
{
 
// A binary tree node
static class Node
{
    int data;
    Node left, right;
};
static int res;
 
// A utility function to allocate a new node
static Node newNode(int data)
{
    Node newNode = new Node();
    newNode.data = data;
    newNode.left = newNode.right = null;
    return (newNode);
}
 
// This function visit each node in preorder fashion
// And adds the values of the children of a node with
// even value to the res variable
static void calcSum(Node root)
{
    // Base Case
    if (root == null)
        return;
 
    // If the value of the
    // current node if even
    if (root.data % 2 == 0)
    {
 
        // If the left child of the even
        // node exist then add it to the res
        if (root.left != null)
            res += root.left.data;
 
        // Do the same with the right child
        if (root.right != null)
            res += root.right.data;
    }
 
    // Visiting the left subtree and the right
    // subtree just like preorder traversal
    calcSum(root.left);
    calcSum(root.right);
}
 
// Function to return the sum of nodes
// whose parent has even value
static int findSum(Node root)
{
    // Initialize result
    res = 0;
 
    calcSum(root);
    return res;
}
 
// Driver code
public static void main(String[] args)
{
 
    // Creating the tree
    Node root = newNode(2);
    root.left = newNode(3);
    root.right = newNode(8);
    root.left.left = newNode(2);
    root.right.left = newNode(5);
    root.right.right = newNode(6);
    root.right.left.left = newNode(1);
    root.right.right.right = newNode(3);
 
    // Print the required sum
    System.out.print(findSum(root));
}
}
 
// This code is contributed by PrinciRaj1992
Python3



# Python3 implementation of the approach
result = 0;
 
# A binary tree node
class Node :
    def __init__(self,data) :
        self.data = data;
        self.left = None
        self.right = None;
 
# This function visit each node in preorder fashion
# And adds the values of the children of a node with
# even value to the res variable
def calcSum(root, res) :
 
    global result;
     
    # Base Case
    if (root == None) :
        return;
     
    # If the value of the
    # current node if even
    if (root.data % 2 == 0) :
         
        # If the left child of the even
        # node exist then add it to the res
        if (root.left) :
            res += root.left.data;
            result = res;
             
        # Do the same with the right child
        if (root.right) :
            res += root.right.data;
            result = res;
             
    # Visiting the left subtree and the right
    # subtree just like preorder traversal
    calcSum(root.left, res);
    calcSum(root.right, res);
 
# Function to return the sum of nodes
# whose parent has even value
def findSum(root) :
    res = 0;
    calcSum(root, res);
    print(result)
     
# Driver code
if __name__ == "__main__" :
 
    # Creating the tree
    root = Node(2);
    root.left = Node(3);
    root.right = Node(8);
    root.left.left = Node(2);
    root.right.left = Node(5);
    root.right.right = Node(6);
    root.right.left.left = Node(1);
    root.right.right.right = Node(3);
 
    # Print the required sum
    findSum(root);
 
# This code is contributed by AnkitRai01
C#



// C# implementation of the approach
using System;
 
class GFG
{
 
// A binary tree node
class Node
{
    public int data;
    public Node left, right;
};
static int res;
 
// A utility function to allocate a new node
static Node newNode(int data)
{
    Node newNode = new Node();
    newNode.data = data;
    newNode.left = newNode.right = null;
    return (newNode);
}
 
// This function visit each node in preorder fashion
// And adds the values of the children of a node with
// even value to the res variable
static void calcSum(Node root)
{
    // Base Case
    if (root == null)
        return;
 
    // If the value of the
    // current node if even
    if (root.data % 2 == 0)
    {
 
        // If the left child of the even
        // node exist then add it to the res
        if (root.left != null)
            res += root.left.data;
 
        // Do the same with the right child
        if (root.right != null)
            res += root.right.data;
    }
 
    // Visiting the left subtree and the right
    // subtree just like preorder traversal
    calcSum(root.left);
    calcSum(root.right);
}
 
// Function to return the sum of nodes
// whose parent has even value
static int findSum(Node root)
{
    // Initialize result
    res = 0;
 
    calcSum(root);
    return res;
}
 
// Driver code
public static void Main(String[] args)
{
 
    // Creating the tree
    Node root = newNode(2);
    root.left = newNode(3);
    root.right = newNode(8);
    root.left.left = newNode(2);
    root.right.left = newNode(5);
    root.right.right = newNode(6);
    root.right.left.left = newNode(1);
    root.right.right.right = newNode(3);
 
    // Print the required sum
    Console.Write(findSum(root));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
 
// JavaScript implementation of the approach
 
// A binary tree node
class Node
{
    constructor()
    {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
};
 
var res = 0;
 
// A utility function to allocate a new node
function newNode(data)
{
    var newNode = new Node();
    newNode.data = data;
    newNode.left = newNode.right = null;
    return (newNode);
}
 
// This function visit each node in preorder fashion
// And adds the values of the children of a node with
// even value to the res variable
function calcSum(root)
{
    // Base Case
    if (root == null)
        return;
 
    // If the value of the
    // current node if even
    if (root.data % 2 == 0)
    {
 
        // If the left child of the even
        // node exist then add it to the res
        if (root.left != null)
            res += root.left.data;
 
        // Do the same with the right child
        if (root.right != null)
            res += root.right.data;
    }
 
    // Visiting the left subtree and the right
    // subtree just like preorder traversal
    calcSum(root.left);
    calcSum(root.right);
}
 
// Function to return the sum of nodes
// whose parent has even value
function findSum(root)
{
    // Initialize result
    res = 0;
 
    calcSum(root);
    return res;
}
 
// Driver code
// Creating the tree
var root = newNode(2);
root.left = newNode(3);
root.right = newNode(8);
root.left.left = newNode(2);
root.right.left = newNode(5);
root.right.right = newNode(6);
root.right.left.left = newNode(1);
root.right.right.right = newNode(3);
// Print the required sum
document.write(findSum(root));
 
 
</script>
Output: 
25
 
Time Complexity: O(n) where n is number of nodes in the given Binary Tree.
 



My Personal Notes
arrow_drop_up
Previous
Python - Add audio files in kivy
Next

Finding the Frobenius Norm of a given matrix
Recommended Articles
Page :
Count all Grandparent-Parent-Child Triplets in a binary tree whose sum is greater than X
18, Dec 18
Sum of all parent-child differences in a Binary Tree
29, Apr 19
Sum of all the parent nodes having child node x
25, Sep 17
Sum of all the child nodes with even grandparents in a Binary Tree
16, May 20
Sum of nodes in a binary tree having only the left child nodes
09, Nov 21
Ways to color a skewed tree such that parent and child have different colors
10, Nov 17
Modify Binary Tree by replacing all nodes at even and odd levels by their nearest even or odd perfect squares respectively
22, Feb 21
Count of nodes in a Binary Tree whose child is its prime factors
09, Apr 20
Print the nodes having exactly one child in a Binary tree
04, May 20
Print even positioned nodes of even levels in level order of the given binary tree
29, Apr 19
Maximum parent children sum in Binary tree
04, Sep 18
Check if all the Nodes in a Binary Tree having common values are at least D distance apart
11, Aug 20
Print all even nodes of Binary Search Tree
29, Oct 18
Remove all subtrees consisting only of even valued nodes from a Binary Tree
08, Feb 21
Sum of nodes in a Binary Search Tree with values from a given range
29, Apr 21
Difference between sum of even and odd valued nodes in a Binary Tree
09, Jul 20
Find Height of Binary Tree represented by Parent array
05, Oct 14
Construct Binary Tree from given Parent Array representation
16, Oct 15
Lowest Common Ancestor in a Binary Tree | Set 2 (Using Parent Pointer)
07, Mar 16
Find right sibling of a binary tree with parent pointers
20, Aug 17
Construct Binary Tree from given Parent Array representation | Iterative Approach
20, Mar 19
Find the parent of a node in the given binary tree
11, Nov 19
Find parent of given node in a Binary Tree with given postorder traversal
09, Jun 20
Find the parent node of maximum product Siblings in given Binary Tree
02, Dec 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
mehul_02
@mehul_02
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!