Sum of subtree depths for every node of a given Binary Tree
Given a binary tree consisting of N nodes, the task is to find the sum of depths of all subtree nodes in a given binary tree.
Examples:
Input:
Output: 26
Explanation:
The leaf nodes having value 8, 9, 5, 6, and 7 have the sum of subtree depths equal to 0.
Node 4 has a total of 2 nodes in its subtree, both in the same level. Therefore, sum of subtree depth is equal to 2.
Node 2 has a total of 4 nodes in its subtree, 2 in each level. Therefore, the sum of subtree depth is equal to 6.
Node 3 has a total of 2 nodes in its subtree, both at the same level. Therefore, the sum of subtree depth is equal to 2.
Node 1 has a total of 8 nodes in its subtree, 2 in the first level, 4 in the 2nd level, and 2 in the last. Therefore, sum of subtree depths is equal to 16.
Therefore, the total sum of all subtree depths is equal to 2 + 6 + 2 + 16 = 26
Input:
Output: 5
Naive Approach: The simplest approach is to traverse the tree and for every node, calculate the sum of depths of all nodes from that node recursively and print the final sum obtained.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
class TreeNode {
public :
int data;
TreeNode* left;
TreeNode* right;
};
TreeNode* newNode( int data)
{
TreeNode* Node = new TreeNode();
Node->data = data;
Node->left = NULL;
Node->right = NULL;
return (Node);
}
int sumofdepth(TreeNode* root, int d)
{
if (root == NULL)
return 0;
return d + sumofdepth(root->left, d + 1)
+ sumofdepth(root->right, d + 1);
}
int sumofallsubtrees(TreeNode* root)
{
if (root == NULL)
return 0;
return sumofdepth(root, 0)
+ sumofallsubtrees(root->left)
+ sumofallsubtrees(root->right);
}
int main()
{
TreeNode* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->right->left = newNode(6);
root->right->right = newNode(7);
root->left->left->left = newNode(8);
root->left->left->right = newNode(9);
cout << sumofallsubtrees(root);
return 0;
}
|
Java
class GFG{
static class TreeNode
{
int data;
TreeNode left, right;
}
static TreeNode newNode( int data)
{
TreeNode Node = new TreeNode();
Node.data = data;
Node.left = Node.right = null ;
return (Node);
}
static int sumofdepth(TreeNode root, int d)
{
if (root == null )
return 0 ;
return d + sumofdepth(root.left, d + 1 ) +
sumofdepth(root.right, d + 1 );
}
static int sumofallsubtrees(TreeNode root)
{
if (root == null )
return 0 ;
return sumofdepth(root, 0 ) +
sumofallsubtrees(root.left) +
sumofallsubtrees(root.right);
}
public static void main(String[] args)
{
TreeNode root = newNode( 1 );
root.left = newNode( 2 );
root.right = newNode( 3 );
root.left.left = newNode( 4 );
root.left.right = newNode( 5 );
root.right.left = newNode( 6 );
root.right.right = newNode( 7 );
root.left.left.left = newNode( 8 );
root.left.left.right = newNode( 9 );
System.out.println(sumofallsubtrees(root));
}
}
|
Python3
class TreeNode:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def sumofdepth(root, d):
if (root = = None ):
return 0
return (d + sumofdepth(root.left, d + 1 ) +
sumofdepth(root.right, d + 1 ))
def sumofallsubtrees(root):
if (root = = None ):
return 0
return (sumofdepth(root, 0 ) + sumofallsubtrees(root.left) +
sumofallsubtrees(root.right))
if __name__ = = '__main__' :
root = TreeNode( 1 )
root.left = TreeNode( 2 )
root.right = TreeNode( 3 )
root.left.left = TreeNode( 4 )
root.left.right = TreeNode( 5 )
root.right.left = TreeNode( 6 )
root.right.right = TreeNode( 7 )
root.left.left.left = TreeNode( 8 )
root.left.left.right = TreeNode( 9 )
print (sumofallsubtrees(root))
|
C#
using System;
public class GFG{
class TreeNode
{
public int data;
public TreeNode left, right;
}
static TreeNode newNode( int data)
{
TreeNode Node = new TreeNode();
Node.data = data;
Node.left = Node.right = null ;
return (Node);
}
static int sumofdepth(TreeNode root, int d)
{
if (root == null )
return 0;
return d + sumofdepth(root.left, d + 1) +
sumofdepth(root.right, d + 1);
}
static int sumofallsubtrees(TreeNode root)
{
if (root == null )
return 0;
return sumofdepth(root, 0) +
sumofallsubtrees(root.left) +
sumofallsubtrees(root.right);
}
public static void Main(String[] args)
{
TreeNode root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(6);
root.right.right = newNode(7);
root.left.left.left = newNode(8);
root.left.left.right = newNode(9);
Console.WriteLine(sumofallsubtrees(root));
}
}
|
Javascript
<script>
class TreeNode
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
function newNode(data)
{
let Node = new TreeNode(data);
return (Node);
}
function sumofdepth(root, d)
{
if (root == null )
return 0;
return d + sumofdepth(root.left, d + 1) +
sumofdepth(root.right, d + 1);
}
function sumofallsubtrees(root)
{
if (root == null )
return 0;
return sumofdepth(root, 0) +
sumofallsubtrees(root.left) +
sumofallsubtrees(root.right);
}
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(6);
root.right.right = newNode(7);
root.left.left.left = newNode(8);
root.left.left.right = newNode(9);
document.write(sumofallsubtrees(root));
</script>
|
Time complexity: O(N2)
Auxiliary Space: O(N)
Efficient Approach: The above approach can be optimized based on the following observations:
Suppose X and Y are the number of nodes in left and right subtrees respectively and S1 and S2 are the sum of depths of nodes in left and right subtrees.
Then, the sum of depths of the current node can be calculated as S1 + S2 + x + y, where depths of x + y nodes increase by 1.
Follow the steps below to solve the problem:
- Define a recursive DFS function say sumofsubtree(root) as:
- Initialize a pair p which stores the total nodes in the current nodes subtree and the total sum of depths of all node in the current subtree
- Check if the left child is not NULL and then recursively call the function sumoftree(root->left) and increment the p.first by the total number of nodes in the left subtree and increment the p.second by the total sum of depths for all node in the left subtree.
- Check if the right child is not NULL and then recursively call the function sumoftree(root->right) and increment the p.first by the total number of nodes in the right subtree and increment the p.second by the total sum of depths for all node in the right subtree.
- Increment the total ans by p.second and return pair p.
- Call the DFS function sumoftree(root) and print the result obtained ans.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
class TreeNode {
public :
int data;
TreeNode* left;
TreeNode* right;
};
TreeNode* newNode( int data)
{
TreeNode* Node = new TreeNode();
Node->data = data;
Node->left = NULL;
Node->right = NULL;
return (Node);
}
pair< int , int > sumofsubtree(TreeNode* root,
int & ans)
{
pair< int , int > p = make_pair(1, 0);
if (root->left) {
pair< int , int > ptemp
= sumofsubtree(root->left, ans);
p.second += ptemp.first
+ ptemp.second;
p.first += ptemp.first;
}
if (root->right) {
pair< int , int > ptemp
= sumofsubtree(root->right, ans);
p.second += ptemp.first
+ ptemp.second;
p.first += ptemp.first;
}
ans += p.second;
return p;
}
int main()
{
TreeNode* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->right->left = newNode(6);
root->right->right = newNode(7);
root->left->left->left = newNode(8);
root->left->left->right = newNode(9);
int ans = 0;
sumofsubtree(root, ans);
cout << ans;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int ans;
static class pair
{
int first, second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
}
static class TreeNode
{
int data;
TreeNode left;
TreeNode right;
};
static TreeNode newNode( int data)
{
TreeNode Node = new TreeNode();
Node.data = data;
Node.left = null ;
Node.right = null ;
return (Node);
}
static pair sumofsubtree(TreeNode root)
{
pair p = new pair( 1 , 0 );
if (root.left != null )
{
pair ptemp
= sumofsubtree(root.left);
p.second += ptemp.first
+ ptemp.second;
p.first += ptemp.first;
}
if (root.right != null )
{
pair ptemp
= sumofsubtree(root.right);
p.second += ptemp.first
+ ptemp.second;
p.first += ptemp.first;
}
ans += p.second;
return p;
}
public static void main(String[] args)
{
TreeNode root = newNode( 1 );
root.left = newNode( 2 );
root.right = newNode( 3 );
root.left.left = newNode( 4 );
root.left.right = newNode( 5 );
root.right.left = newNode( 6 );
root.right.right = newNode( 7 );
root.left.left.left = newNode( 8 );
root.left.left.right = newNode( 9 );
ans = 0 ;
sumofsubtree(root);
System.out.print(ans);
}
}
|
Python3
class TreeNode:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
ans = 0
def newNode(data):
Node = TreeNode(data)
return (Node)
def sumofsubtree(root):
global ans
p = [ 1 , 0 ]
if (root.left ! = None ):
ptemp = sumofsubtree(root.left)
p[ 1 ] + = ptemp[ 0 ] + ptemp[ 1 ]
p[ 0 ] + = ptemp[ 0 ]
if (root.right ! = None ):
ptemp = sumofsubtree(root.right)
p[ 1 ] + = ptemp[ 0 ] + ptemp[ 1 ]
p[ 0 ] + = ptemp[ 0 ]
ans + = p[ 1 ]
return p
root = newNode( 1 )
root.left = newNode( 2 )
root.right = newNode( 3 )
root.left.left = newNode( 4 )
root.left.right = newNode( 5 )
root.right.left = newNode( 6 )
root.right.right = newNode( 7 )
root.left.left.left = newNode( 8 )
root.left.left.right = newNode( 9 )
sumofsubtree(root)
print (ans)
|
C#
using System;
public class GFG
{
static int ans;
class pair
{
public int first, second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
}
class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
};
static TreeNode newNode( int data)
{
TreeNode Node = new TreeNode();
Node.data = data;
Node.left = null ;
Node.right = null ;
return (Node);
}
static pair sumofsubtree(TreeNode root)
{
pair p = new pair(1, 0);
if (root.left != null )
{
pair ptemp
= sumofsubtree(root.left);
p.second += ptemp.first
+ ptemp.second;
p.first += ptemp.first;
}
if (root.right != null )
{
pair ptemp
= sumofsubtree(root.right);
p.second += ptemp.first
+ ptemp.second;
p.first += ptemp.first;
}
ans += p.second;
return p;
}
public static void Main(String[] args)
{
TreeNode root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(6);
root.right.right = newNode(7);
root.left.left.left = newNode(8);
root.left.left.right = newNode(9);
ans = 0;
sumofsubtree(root);
Console.Write(ans);
}
}
|
Javascript
<script>
var ans;
class pair {
constructor(first, second) {
this .first = first;
this .second = second;
}
}
class TreeNode {
constructor() {
this .data = 0;
this .left = null ;
this .right = null ;
}
}
function newNode(data) {
var Node = new TreeNode();
Node.data = data;
Node.left = null ;
Node.right = null ;
return Node;
}
function sumofsubtree(root) {
var p = new pair(1, 0);
if (root.left != null ) {
var ptemp = sumofsubtree(root.left);
p.second += ptemp.first + ptemp.second;
p.first += ptemp.first;
}
if (root.right != null ) {
var ptemp = sumofsubtree(root.right);
p.second += ptemp.first + ptemp.second;
p.first += ptemp.first;
}
ans += p.second;
return p;
}
var root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(6);
root.right.right = newNode(7);
root.left.left.left = newNode(8);
root.left.left.right = newNode(9);
ans = 0;
sumofsubtree(root);
document.write(ans);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Last Updated :
17 Sep, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...