Related Articles
Sum of all parent-child differences in a Binary Tree
• Last Updated : 19 Jun, 2019

Given a binary tree, find the sum of all parent-child differences for all the non-leaf nodes of the given binary tree.
Note that parent-child difference is (parent node’s value – (sum of child node’s values)).

Examples:

```Input:
1
/   \
2     3
/ \   / \
4   5 6   7
\
8
Output: -23
1st parent-child difference = 1 -(2 + 3) = -4
2nd parent-child difference = 2 -(4 + 5) = -7
3rd parent-child difference = 3 -(6 + 7) = -10
4th parent-child difference = 6 - 8 = -2
Total sum = -23

Input:
1
/   \
2     3
\   /
5 6
Output: -10
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: The idea is to traverse the tree in any fashion and check if the node is the leaf node or not. If the node is non-leaf node, add (node data – sum of children node data) to result.

Efficient Approach: In the final result, a close analysis suggests that each internal node ( nodes which are neither root nor leaf) once gets treated as a child and once as a parent hence their contribution in the final result is zero. Also, the root is only treated as a parent once and in a similar fashion, all leaf nodes are treated as children once. Hence, the final result is (value of root – sum of all leaf nodes).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Structure for a binary tree node ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// Returns a new node ` `Node* newNode(``int` `data) ` `{ ` `    ``Node* temp = ``new` `Node(); ` `    ``temp->data = data; ` `    ``temp->left = temp->right = NULL; ` `} ` ` `  `// Utility function which calculates ` `// the sum of all leaf nodes ` `void` `leafSumFunc(Node* root, ``int``* leafSum) ` `{ ` `    ``if` `(!root) ` `        ``return``; ` ` `  `    ``// Add root data to sum if ` `    ``// root is a leaf node ` `    ``if` `(!root->left && !root->right) ` `        ``*leafSum += root->data; ` ` `  `    ``// Recursively check in the left ` `    ``// and the right sub-tree ` `    ``leafSumFunc(root->left, leafSum); ` `    ``leafSumFunc(root->right, leafSum); ` `} ` ` `  `// Function to return the required result ` `int` `sumParentChildDiff(Node* root) ` `{ ` ` `  `    ``// If root is null ` `    ``if` `(!root) ` `        ``return` `0; ` ` `  `    ``// If only node is the root node ` `    ``if` `(!root->left && !root->right) ` `        ``return` `root->data; ` ` `  `    ``// Find the sum of all the leaf nodes ` `    ``int` `leafSum = 0; ` `    ``leafSumFunc(root, &leafSum); ` ` `  `    ``// Root - sum of all the leaf nodes ` `    ``return` `(root->data - leafSum); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Construct binary tree ` `    ``Node* root = newNode(1); ` `    ``root->left = newNode(2); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(5); ` `    ``root->right = newNode(3); ` `    ``root->right->right = newNode(7); ` `    ``root->right->left = newNode(6); ` ` `  `    ``cout << sumParentChildDiff(root); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `class` `GFG ` `{ ` ` `  `// Structure for a binary tree node ` `static` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}; ` ` `  `// Returns a new node ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `temp; ` `} ` `static` `int` `leafSum; ` ` `  `// Utility function which calculates ` `// the sum of all leaf nodes ` `static` `void` `leafSumFunc(Node root ) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return``; ` ` `  `    ``// Add root data to sum if ` `    ``// root is a leaf node ` `    ``if` `(root.left == ``null` `&& root.right == ``null``) ` `        ``leafSum += root.data; ` ` `  `    ``// Recursively check in the left ` `    ``// and the right sub-tree ` `    ``leafSumFunc(root.left); ` `    ``leafSumFunc(root.right); ` `} ` ` `  `// Function to return the required result ` `static` `int` `sumParentChildDiff(Node root) ` `{ ` ` `  `    ``// If root is null ` `    ``if` `(root == ``null``) ` `        ``return` `0``; ` ` `  `    ``// If only node is the root node ` `    ``if` `(root.left == ``null` `&& root.right == ``null``) ` `        ``return` `root.data; ` ` `  `    ``// Find the sum of all the leaf nodes ` `    ``leafSum = ``0``; ` `    ``leafSumFunc(root); ` ` `  `    ``// Root - sum of all the leaf nodes ` `    ``return` `(root.data - leafSum); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``// Construct binary tree ` `    ``Node root = newNode(``1``); ` `    ``root.left = newNode(``2``); ` `    ``root.left.left = newNode(``4``); ` `    ``root.left.right = newNode(``5``); ` `    ``root.right = newNode(``3``); ` `    ``root.right.right = newNode(``7``); ` `    ``root.right.left = newNode(``6``); ` ` `  `    ``System.out.println( sumParentChildDiff(root)); ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Structure for a binary tree node  ` `class` `Node: ` `     `  `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Utility function which calculates  ` `# the sum of all leaf nodes  ` `def` `leafSumFunc(root, leafSum):  ` ` `  `    ``if` `not` `root: ` `        ``return` `0` ` `  `    ``# Add root data to sum  ` `    ``# if root is a leaf node  ` `    ``if` `not` `root.left ``and` `not` `root.right:  ` `        ``leafSum ``+``=` `root.data ` `         `  `    ``# Recursively check in the  ` `    ``# left and the right sub-tree  ` `    ``leafSum ``=` `max``(leafSumFunc(root.left,  ` `                              ``leafSum), leafSum) ` `    ``leafSum ``=` `max``(leafSumFunc(root.right,  ` `                              ``leafSum), leafSum) ` `    ``return` `leafSum ` ` `  `# Function to return the required result  ` `def` `sumParentChildDiff(root):  ` ` `  `    ``# If root is None  ` `    ``if` `not` `root:  ` `        ``return` `0` ` `  `    ``# If only node is the root node  ` `    ``if` `not` `root.left ``and` `not` `root.right: ` `        ``return` `root.data  ` ` `  `    ``# Find the sum of all the leaf nodes  ` `    ``leafSum ``=` `leafSumFunc(root, ``0``)  ` ` `  `    ``# Root - sum of all the leaf nodes  ` `    ``return` `root.data ``-` `leafSum  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``# Construct binary tree  ` `    ``root ``=` `Node(``1``)  ` `    ``root.left ``=` `Node(``2``)  ` `    ``root.left.left ``=` `Node(``4``)  ` `    ``root.left.right ``=` `Node(``5``)  ` `    ``root.right ``=` `Node(``3``)  ` `    ``root.right.right ``=` `Node(``7``)  ` `    ``root.right.left ``=` `Node(``6``)  ` ` `  `    ``print``(sumParentChildDiff(root))  ` ` `  `# This code is contributed by Rituraj Jain `

## C#

 `// C# implementation of the approach ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `// Structure for a binary tree node ` `public` `class` `Node ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` `}; ` ` `  `// Returns a new node ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `temp; ` `} ` `static` `int` `leafSum; ` ` `  `// Utility function which calculates ` `// the sum of all leaf nodes ` `static` `void` `leafSumFunc(Node root ) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return``; ` ` `  `    ``// Add root data to sum if ` `    ``// root is a leaf node ` `    ``if` `(root.left == ``null` `&& root.right == ``null``) ` `        ``leafSum += root.data; ` ` `  `    ``// Recursively check in the left ` `    ``// and the right sub-tree ` `    ``leafSumFunc(root.left); ` `    ``leafSumFunc(root.right); ` `} ` ` `  `// Function to return the required result ` `static` `int` `sumParentChildDiff(Node root) ` `{ ` ` `  `    ``// If root is null ` `    ``if` `(root == ``null``) ` `        ``return` `0; ` ` `  `    ``// If only node is the root node ` `    ``if` `(root.left == ``null` `&& root.right == ``null``) ` `        ``return` `root.data; ` ` `  `    ``// Find the sum of all the leaf nodes ` `    ``leafSum = 0; ` `    ``leafSumFunc(root); ` ` `  `    ``// Root - sum of all the leaf nodes ` `    ``return` `(root.data - leafSum); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``// Construct binary tree ` `    ``Node root = newNode(1); ` `    ``root.left = newNode(2); ` `    ``root.left.left = newNode(4); ` `    ``root.left.right = newNode(5); ` `    ``root.right = newNode(3); ` `    ``root.right.right = newNode(7); ` `    ``root.right.left = newNode(6); ` ` `  `    ``Console.WriteLine( sumParentChildDiff(root)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```-21
```

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :