# Sum of all parent-child differences in a Binary Tree

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

My Personal Notes arrow_drop_up Discovering ways to develop a plane for soaring career goals

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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.