Given a binary tree containing n nodes. The problem is to find the sum of all the parent node’s which have a child node with value x.
Examples:
Input : Binary tree with x = 2: 4 / \ 2 5 / \ / \ 7 2 2 3 Output : 11 4 / \ 2 5 / \ / \ 7 2 2 3 The highlighted nodes (4, 2, 5) above are the nodes having 2 as a child node.
Algorithm:
sumOfParentOfX(root,sum,x) if root == NULL return if (root->left && root->left->data == x) || (root->right && root->right->data == x) sum += root->data sumOfParentOfX(root->left, sum, x) sumOfParentOfX(root->right, sum, x) sumOfParentOfXUtil(root,x) Declare sum = 0 sumOfParentOfX(root, sum, x) return sum
Implementation:
C++
// C++ implementation to find the sum of all // the parent nodes having child node x #include <bits/stdc++.h> using namespace std;
// Node of a binary tree struct Node
{ int data;
Node *left, *right;
}; // function to get a new node Node* getNode( int data)
{ // allocate memory for the node
Node *newNode =
(Node*) malloc ( sizeof (Node));
// put in the data
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
} // function to find the sum of all the // parent nodes having child node x void sumOfParentOfX(Node* root, int & sum, int x)
{ // if root == NULL
if (!root)
return ;
// if left or right child of root is 'x', then
// add the root's data to 'sum'
if ((root->left && root->left->data == x) ||
(root->right && root->right->data == x))
sum += root->data;
// recursively find the required parent nodes
// in the left and right subtree
sumOfParentOfX(root->left, sum, x);
sumOfParentOfX(root->right, sum, x);
} // utility function to find the sum of all // the parent nodes having child node x int sumOfParentOfXUtil(Node* root, int x)
{ int sum = 0;
sumOfParentOfX(root, sum, x);
// required sum of parent nodes
return sum;
} // Driver program to test above int main()
{ // binary tree formation
Node *root = getNode(4); /* 4 */
root->left = getNode(2); /* / \ */
root->right = getNode(5); /* 2 5 */
root->left->left = getNode(7); /* / \ / \ */
root->left->right = getNode(2); /* 7 2 2 3 */
root->right->left = getNode(2);
root->right->right = getNode(3);
int x = 2;
cout << "Sum = "
<< sumOfParentOfXUtil(root, x);
return 0;
} |
Java
// Java implementation to find // the sum of all the parent // nodes having child node x class GFG
{ // sum static int sum = 0 ;
// Node of a binary tree static class Node
{ int data;
Node left, right;
}; // function to get a new node static Node getNode( int data)
{ // allocate memory for the node
Node newNode = new Node();
// put in the data
newNode.data = data;
newNode.left = newNode.right = null ;
return newNode;
} // function to find the sum of all the // parent nodes having child node x static void sumOfParentOfX(Node root, int x)
{ // if root == NULL
if (root == null )
return ;
// if left or right child
// of root is 'x', then
// add the root's data to 'sum'
if ((root.left != null && root.left.data == x) ||
(root.right != null && root.right.data == x))
sum += root.data;
// recursively find the required
// parent nodes in the left and
// right subtree
sumOfParentOfX(root.left, x);
sumOfParentOfX(root.right, x);
} // utility function to find the // sum of all the parent nodes // having child node x static int sumOfParentOfXUtil(Node root,
int x)
{ sum = 0 ;
sumOfParentOfX(root, x);
// required sum of parent nodes
return sum;
} // Driver Code public static void main(String args[])
{ // binary tree formation
Node root = getNode( 4 ); // 4
root.left = getNode( 2 ); // / \
root.right = getNode( 5 ); // 2 5
root.left.left = getNode( 7 ); // / \ / \
root.left.right = getNode( 2 ); // 7 2 2 3
root.right.left = getNode( 2 );
root.right.right = getNode( 3 );
int x = 2 ;
System.out.println( "Sum = " +
sumOfParentOfXUtil(root, x));
} } // This code is contributed by Arnab Kundu |
Python3
# Python3 implementation to find the Sum of # all the parent nodes having child node x # function to get a new node class getNode:
def __init__( self , data):
# put in the data
self .data = data
self .left = self .right = None
# function to find the Sum of all the # parent nodes having child node x def SumOfParentOfX(root, Sum , x):
# if root == None
if ( not root):
return
# if left or right child of root is 'x',
# then add the root's data to 'Sum'
if ((root.left and root.left.data = = x) or
(root.right and root.right.data = = x)):
Sum [ 0 ] + = root.data
# recursively find the required parent
# nodes in the left and right subtree
SumOfParentOfX(root.left, Sum , x)
SumOfParentOfX(root.right, Sum , x)
# utility function to find the Sum of all # the parent nodes having child node x def SumOfParentOfXUtil(root, x):
Sum = [ 0 ]
SumOfParentOfX(root, Sum , x)
# required Sum of parent nodes
return Sum [ 0 ]
# Driver Code if __name__ = = '__main__' :
# binary tree formation
root = getNode( 4 ) # 4
root.left = getNode( 2 ) # / \
root.right = getNode( 5 ) # 2 5
root.left.left = getNode( 7 ) # / \ / \
root.left.right = getNode( 2 ) # 7 2 2 3
root.right.left = getNode( 2 )
root.right.right = getNode( 3 )
x = 2
print ( "Sum = " , SumOfParentOfXUtil(root, x))
# This code is contributed by PranchalK |
C#
using System;
// C# implementation to find // the sum of all the parent // nodes having child node x public class GFG
{ // sum public static int sum = 0;
// Node of a binary tree public class Node
{ public int data;
public Node left, right;
} // function to get a new node public static Node getNode( int data)
{ // allocate memory for the node
Node newNode = new Node();
// put in the data
newNode.data = data;
newNode.left = newNode.right = null ;
return newNode;
} // function to find the sum of all the // parent nodes having child node x public static void sumOfParentOfX(Node root, int x)
{ // if root == NULL
if (root == null )
{
return ;
}
// if left or right child
// of root is 'x', then
// add the root's data to 'sum'
if ((root.left != null && root.left.data == x) ||
(root.right != null && root.right.data == x))
{
sum += root.data;
}
// recursively find the required
// parent nodes in the left and
// right subtree
sumOfParentOfX(root.left, x);
sumOfParentOfX(root.right, x);
} // utility function to find the // sum of all the parent nodes // having child node x public static int sumOfParentOfXUtil(Node root, int x)
{ sum = 0;
sumOfParentOfX(root, x);
// required sum of parent nodes
return sum;
} // Driver Code public static void Main( string [] args)
{ // binary tree formation
Node root = getNode(4); // 4
root.left = getNode(2); // / \
root.right = getNode(5); // 2 5
root.left.left = getNode(7); // / \ / \
root.left.right = getNode(2); // 7 2 2 3
root.right.left = getNode(2);
root.right.right = getNode(3);
int x = 2;
Console.WriteLine( "Sum = " + sumOfParentOfXUtil(root, x));
} } // This code is contributed by Shrikant13 |
Javascript
<script> // JavaScript implementation to find
// the sum of all the parent
// nodes having child node x
// sum
let sum = 0;
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
// function to get a new node
function getNode(data)
{
// allocate memory for the node
let newNode = new Node(data);
return newNode;
}
// function to find the sum of all the
// parent nodes having child node x
function sumOfParentOfX(root, x)
{
// if root == NULL
if (root == null )
return ;
// if left or right child
// of root is 'x', then
// add the root's data to 'sum'
if ((root.left != null && root.left.data == x) ||
(root.right != null && root.right.data == x))
sum += root.data;
// recursively find the required
// parent nodes in the left and
// right subtree
sumOfParentOfX(root.left, x);
sumOfParentOfX(root.right, x);
}
// utility function to find the
// sum of all the parent nodes
// having child node x
function sumOfParentOfXUtil(root, x)
{
sum = 0;
sumOfParentOfX(root, x);
// required sum of parent nodes
return sum;
}
// binary tree formation
let root = getNode(4); // 4
root.left = getNode(2); // / \
root.right = getNode(5); // 2 5
root.left.left = getNode(7); // / \ / \
root.left.right = getNode(2); // 7 2 2 3
root.right.left = getNode(2);
root.right.right = getNode(3);
let x = 2;
document.write( "Sum = " +
sumOfParentOfXUtil(root, x));
</script> |
Output
Sum = 11
Time Complexity: O(n).
Auxiliary space: O(n) for call stack as it is using recursion
Recommended Articles