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


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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.