# Count nodes with sum of path made by only left child nodes at least K

Last Updated : 30 Sep, 2022

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   11

Output: 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 = 15

Input:  K = 20,
Tree:
3
/       \
16     10

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

 `// C++ code for the above approach:`   `#include ` `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

 `// C code to implement the approach`   `#include ` `#include `   `// 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

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

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

## C#

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

## Javascript

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

Output

`4`

Time Complexity: O(N^2)
Auxiliary Space: O(N) the space used by the recursion stack

Previous
Next