Given a binary tree and an integer K, the task is to write a program to count the number of nodes such that the path from the current node to a leaf consisting of only the left child of nodes has a sum greater than or equal to K.
Examples:
Input: K = 15,
Tree:
8
/ \
9 10
/ \ / \
11 12 13 7
/ \ / / / \
6 9 6 7 15 11Output: 4
Explanation: Nodes with left children sum ? ‘K’ are :
Node 8 = 9 + 11 + 6 = 26
Node 9 = 11 + 6 = 17
Node 10 = 13 + 7 = 20
Node 7 = 15Input: K = 20,
Tree:
3
/ \
16 10Output: 0
Explanation: No nodes with left children sum ? 20
Approach: To solve the problem follow the below idea:
One simple approach is to find the sum of left children nodes for every node and compare it with K.
Follow the steps to solve the problem:
- Maintain counter with name count
- Implement a recursive function leftNodeSum that recursively calculates the sum of the left nodes for every node in the tree
- Use a recursive function to traverse through every node
- Check the sum with K, if it is greater than K then increment the count.
- Return the count as the answer.
Below is the implementation of the above approach.
// C++ code for the above approach: #include <bits/stdc++.h> using namespace std;
// Node structure struct node {
int data;
struct node* left;
struct node* right;
node( int x)
{
this ->data = x;
this ->left = this ->right = NULL;
}
}; // Function to count left node sum int leftNodeSum( struct node* head)
{ if (!head)
return 0;
return head->data + leftNodeSum(head->left);
} // Function to traverse the tree int traverseNodes( struct node* head, int k, int * count)
{ if (!head)
return 0;
int sum = leftNodeSum(head->left);
if (sum >= k)
(*count)++;
traverseNodes(head->left, k, count);
traverseNodes(head->right, k, count);
} // Driver code int main()
{ int K = 15;
int count = 0;
struct node* start = NULL;
start = new node(8);
start->left = new node(9);
start->right = new node(10);
start->left->left = new node(11);
start->left->right = new node(12);
start->right->left = new node(13);
start->right->right = new node(7);
start->left->left->left = new node(6);
start->left->left->right = new node(9);
start->left->right->left = new node(6);
start->right->left->left = new node(7);
start->right->right->left = new node(15);
start->right->right->right = new node(11);
// Function call
traverseNodes(start, K, &count);
cout << count << endl;
return 0;
} |
// C code to implement the approach #include <stdio.h> #include <stdlib.h> // Structure of a tree node struct node {
int data;
struct node* left;
struct node* right;
}; int count = 0;
// Function to add a new node struct node* addNode( int data)
{ struct node* n
= ( struct node*) malloc ( sizeof ( struct node));
n->data = data;
n->left = NULL;
n->right = NULL;
return n;
} // Function to find the sum of left children int leftNodeSum( struct node* head)
{ if (!head)
return 0;
return head->data + leftNodeSum(head->left);
} // Function to traverse the tree int traverseNodes( struct node* head, int k)
{ if (!head)
return 0;
int sum = leftNodeSum(head->left);
if (sum >= k)
count++;
traverseNodes(head->left, k);
traverseNodes(head->right, k);
} // Driver code void main()
{ int K = 15;
struct node* start = NULL;
start = addNode(8);
start->left = addNode(9);
start->right = addNode(10);
start->left->left = addNode(11);
start->left->right = addNode(12);
start->right->left = addNode(13);
start->right->right = addNode(7);
start->left->left->left = addNode(6);
start->left->left->right = addNode(9);
start->left->right->left = addNode(6);
start->right->left->left = addNode(7);
start->right->right->left = addNode(15);
start->right->right->right = addNode(11);
// Function call
traverseNodes(start, K);
printf ( "%d" , count);
} |
// Java code for the above approach: import java.io.*;
// Node structure class node {
int data;
node left, right;
node( int x)
{
this .data = x;
this .left = this .right = null ;
}
} class GFG {
// Function to count left node sum
public static int leftNodeSum(node head)
{
if (head == null )
return 0 ;
return head.data + leftNodeSum(head.left);
}
// Function to traverse the tree
public static void traverseNodes(node head, int k,
int count[])
{
if (head == null )
return ;
int sum = leftNodeSum(head.left);
if (sum >= k)
count[ 0 ]++;
traverseNodes(head.left, k, count);
traverseNodes(head.right, k, count);
}
// Driver Code
public static void main(String[] args)
{
int K = 15 ;
int count[] = new int [ 1 ];
count[ 0 ] = 0 ;
node start = new node( 8 );
start.left = new node( 9 );
start.right = new node( 10 );
start.left.left = new node( 11 );
start.left.right = new node( 12 );
start.right.left = new node( 13 );
start.right.right = new node( 7 );
start.left.left.left = new node( 6 );
start.left.left.right = new node( 9 );
start.left.right.left = new node( 6 );
start.right.left.left = new node( 7 );
start.right.right.left = new node( 15 );
start.right.right.right = new node( 11 );
// Function call
traverseNodes(start, K, count);
System.out.println(count[ 0 ]);
}
} // This code is contributed by Rohit Pradhan |
# Python3 code to implement the approach # Class to define the structure of a tree node class node:
def __init__( self ):
self .data = None ;
self .left = None ;
self .right = None ;
count = 0
# Function to add a new node def addNode(data):
n = node()
n.data = data
n.left = None
n.right = None
return n
# Function to find the sum of left children def leftNodeSum(head):
if not head:
return 0
return head.data + leftNodeSum(head.left)
# Function to traverse the tree def traverseNodes(head, k):
global count
if not head:
return 0
sum = leftNodeSum(head.left)
if sum > = k:
count + = 1
traverseNodes(head.left, k)
traverseNodes(head.right, k)
# Driver code if __name__ = = '__main__' :
K = 15
start = None
start = addNode( 8 )
start.left = addNode( 9 )
start.right = addNode( 10 )
start.left.left = addNode( 11 )
start.left.right = addNode( 12 )
start.right.left = addNode( 13 )
start.right.right = addNode( 7 )
start.left.left.left = addNode( 6 )
start.left.left.right = addNode( 9 )
start.left.right.left = addNode( 6 )
start.right.left.left = addNode( 7 )
start.right.right.left = addNode( 15 )
start.right.right.right = addNode( 11 )
# Function call
traverseNodes(start, K)
print (count)
|
// Include namespace system using System;
// Node structure public class node
{ public int data;
public node left;
public node right;
public node( int x)
{
this .data = x;
this .left = this .right = null ;
}
} public class GFG
{ // Function to count left node sum
public static int leftNodeSum(node head)
{
if (head == null )
{
return 0;
}
return head.data + GFG.leftNodeSum(head.left);
}
// Function to traverse the tree
public static void traverseNodes(node head, int k, int [] count)
{
if (head == null )
{
return ;
}
var sum = GFG.leftNodeSum(head.left);
if (sum >= k)
{
count[0]++;
}
GFG.traverseNodes(head.left, k, count);
GFG.traverseNodes(head.right, k, count);
}
// Driver Code
public static void Main(String[] args)
{
var K = 15;
int [] count = new int [1];
count[0] = 0;
var start = new node(8);
start.left = new node(9);
start.right = new node(10);
start.left.left = new node(11);
start.left.right = new node(12);
start.right.left = new node(13);
start.right.right = new node(7);
start.left.left.left = new node(6);
start.left.left.right = new node(9);
start.left.right.left = new node(6);
start.right.left.left = new node(7);
start.right.right.left = new node(15);
start.right.right.right = new node(11);
// Function call
GFG.traverseNodes(start, K, count);
Console.WriteLine(count[0]);
}
} // This code is contributed by aadityaburujwale. |
class node { constructor(){ let data; let left; let right; } }; let count = 0; function addNode(data){
let n = new node();
n.data = data; n.left = null ;
n.right = null ;
return n;
} function leftNodeSum(head){
if (!head) return 0;
return head.data + leftNodeSum(head.left);
} function traverseNodes(head, k){
if (!head) return 0;
let sum = leftNodeSum(head.left); if (sum >= k)count++;
traverseNodes(head.left, k); traverseNodes(head.right, k); } let k = 15; let start = null ;
start = addNode(8); start.left = addNode(9); start.right = addNode(10); start.left.left = addNode(11); start.left.right = addNode(12); start.right.left = addNode(13); start.right.right = addNode(7); start.left.left.left = addNode(6); start.left.left.right = addNode(9); start.left.right.left = addNode(6); start.right.left.left = addNode(7); start.right.right.left = addNode(15); start.right.right.right = addNode(11); traverseNodes(start, k); console.log(count); |
4
Time Complexity: O(N^2)
Auxiliary Space: O(N) the space used by the recursion stack