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

My Personal Notes arrow_drop_up