 Open in App
Not now

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

• Difficulty Level : Basic
• Last Updated : 16 Aug, 2022

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

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`

## Javascript

 ``

Output:

`-21`

Time complexity: O(N) where N is no of nodes in given binary tree

My Personal Notes arrow_drop_up
Related Articles