Sum of all nodes at Kth level in a Binary Tree
Last Updated :
24 Nov, 2023
Given a binary tree with N nodes and an integer K, the task is to find the sum of all the nodes present at the Kth level.
Examples:
Input:
K = 1
Output: 70
Input:
K = 2
Output: 120
Approach:
- Traverse the Binary Tree using Level Order Traversal and queue
- During traversal, pop each element out of the queue and push it’s child (if available) in the queue.
- Keep the track of the current level of the Binary tree.
- To track the current level, declare a variable level and increase it whenever a child is traversed from the parent.
- When the current level of the tree i.e. the variable level meets the required Kth level, pop the elements from the queue and calculate their sum.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
struct node* left;
struct node* right;
};
struct node* newNode( int data)
{
struct node* temp = new struct node;
temp->data = data;
temp->left = nullptr;
temp->right = nullptr;
return temp;
};
int sumOfNodesAtNthLevel( struct node* root,
int k)
{
if (root == nullptr)
return 0;
queue< struct node*> que;
que.push(root);
int level = 0;
int sum = 0;
int flag = 0;
while (!que.empty()) {
int size = que.size();
while (size--) {
struct node* ptr = que.front();
que.pop();
if (level == k) {
flag = 1;
sum += ptr->data;
}
else {
if (ptr->left)
que.push(ptr->left);
if (ptr->right)
que.push(ptr->right);
}
}
level++;
if (flag == 1)
break ;
}
return sum;
}
int main()
{
struct node* root = new struct node;
root = newNode(50);
root->left = newNode(30);
root->right = newNode(70);
root->left->left = newNode(20);
root->left->right = newNode(40);
root->right->left = newNode(60);
int level = 2;
int result = sumOfNodesAtNthLevel(root, level);
cout << result;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class node
{
int data;
node left;
node right;
};
static node newNode( int data)
{
node temp = new node();
temp.data = data;
temp.left = null ;
temp.right = null ;
return temp;
};
static int sumOfNodesAtNthLevel(node root,
int k)
{
if (root == null )
return 0 ;
Queue<node> que = new LinkedList<>();
que.add(root);
int level = 0 ;
int sum = 0 ;
int flag = 0 ;
while (!que.isEmpty())
{
int size = que.size();
while (size-- > 0 )
{
node ptr = que.peek();
que.remove();
if (level == k)
{
flag = 1 ;
sum += ptr.data;
}
else {
if (ptr.left != null )
que.add(ptr.left);
if (ptr.right != null )
que.add(ptr.right);
}
}
level++;
if (flag == 1 )
break ;
}
return sum;
}
public static void main(String[] args)
{
node root = new node();
root = newNode( 50 );
root.left = newNode( 30 );
root.right = newNode( 70 );
root.left.left = newNode( 20 );
root.left.right = newNode( 40 );
root.right.left = newNode( 60 );
int level = 2 ;
int result = sumOfNodesAtNthLevel(root, level);
System.out.print(result);
}
}
|
Python3
class newNode :
def __init__( self , data) :
self .data = data;
self .left = None ;
self .right = None ;
def sumOfNodesAtNthLevel(root, k) :
if (root = = None ) :
return 0 ;
que = [];
que.append(root);
level = 0 ;
sum = 0 ;
flag = 0 ;
while ( len (que) ! = 0 ) :
size = len (que);
while (size ! = 0 ) :
size - = 1 ;
ptr = que[ 0 ];
que.pop( 0 );
if (level = = k) :
flag = 1 ;
sum + = ptr.data;
else :
if (ptr.left) :
que.append(ptr.left);
if (ptr.right) :
que.append(ptr.right);
level + = 1 ;
if (flag = = 1 ) :
break ;
return sum ;
if __name__ = = "__main__" :
root = newNode( 50 );
root.left = newNode( 30 );
root.right = newNode( 70 );
root.left.left = newNode( 20 );
root.left.right = newNode( 40 );
root.right.left = newNode( 60 );
level = 2 ;
result = sumOfNodesAtNthLevel(root, level);
print (result);
|
C#
using System;
using System.Collections.Generic;
class GFG
{
class node
{
public int data;
public node left;
public node right;
};
static node newNode( int data)
{
node temp = new node();
temp.data = data;
temp.left = null ;
temp.right = null ;
return temp;
}
static int sumOfNodesAtNthLevel(node root,
int k)
{
if (root == null )
return 0;
List<node> que = new List<node>();
que.Add(root);
int level = 0;
int sum = 0;
int flag = 0;
while (que.Count != 0)
{
int size = que.Count;
while (size-- >0)
{
node ptr = que[0];
que.RemoveAt(0);
if (level == k)
{
flag = 1;
sum += ptr.data;
}
else
{
if (ptr.left != null )
que.Add(ptr.left);
if (ptr.right != null )
que.Add(ptr.right);
}
}
level++;
if (flag == 1)
break ;
}
return sum;
}
public static void Main(String[] args)
{
node root = new node();
root = newNode(50);
root.left = newNode(30);
root.right = newNode(70);
root.left.left = newNode(20);
root.left.right = newNode(40);
root.right.left = newNode(60);
int level = 2;
int result = sumOfNodesAtNthLevel(root, level);
Console.Write(result);
}
}
|
Javascript
<script>
class node
{
constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
};
function newNode(data)
{
var temp = new node();
temp.data = data;
temp.left = null ;
temp.right = null ;
return temp;
}
function sumOfNodesAtNthLevel(root, k)
{
if (root == null )
return 0;
var que = [];
que.push(root);
var level = 0;
var sum = 0;
var flag = 0;
while (que.length != 0)
{
var size = que.length;
while (size-- >0)
{
var ptr = que[0];
que.shift();
if (level == k)
{
flag = 1;
sum += ptr.data;
}
else
{
if (ptr.left != null )
que.push(ptr.left);
if (ptr.right != null )
que.push(ptr.right);
}
}
level++;
if (flag == 1)
break ;
}
return sum;
}
var root = new node();
root = newNode(50);
root.left = newNode(30);
root.right = newNode(70);
root.left.left = newNode(20);
root.left.right = newNode(40);
root.right.left = newNode(60);
var level = 2;
var result = sumOfNodesAtNthLevel(root, level);
document.write(result);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N) because using auxiliary space for queue que
Approach 2: Recursive DFS
In this approach, we can traverse the tree in a Depth First Search (DFS) manner, and maintain a level count. Whenever we reach a node at the kth level, we add its value to a sum. We continue this process for all nodes in the tree and return the final sum.
Initialize a variable sum to 0.
Define a recursive function that takes in a root node, a current level, and a target level:
a. If the current node is null, return 0.
b. If the current level equals the target level, add the value of the current node to the sum.
c. Recursively call the function on the left subtree with an incremented level.
d. Recursively call the function on the right subtree with an incremented level.
e. Return the sum.
Call the recursive function with the root node, the starting level of 1, and the target level.
Here’s the C++ code:
C++
#include <iostream>
using namespace std;
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode( int x) : val(x), left(NULL), right(NULL) {}
};
int sumAtKthLevel(TreeNode* root, int k, int level = 0) {
if (root == NULL) {
return 0;
}
if (level == k) {
return root->val;
}
return sumAtKthLevel(root->left, k, level + 1) + sumAtKthLevel(root->right, k, level + 1);
}
int main() {
TreeNode* root = new TreeNode(50);
root->left = new TreeNode(30);
root->right = new TreeNode(70);
root->left->left = new TreeNode(20);
root->left->right = new TreeNode(40);
root->right->left = new TreeNode(60);
int k = 2;
int sum = sumAtKthLevel(root, k);
cout << "The sum of nodes at level " << k << " is " << sum << endl;
return 0;
}
|
Java
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode( int x) {
val = x;
left = null ;
right = null ;
}
}
public class BinaryTreeSumAtKthLevel {
static int sumAtKthLevel(TreeNode root, int k, int level) {
if (root == null ) {
return 0 ;
}
if (level == k) {
return root.val;
}
return sumAtKthLevel(root.left, k, level + 1 ) + sumAtKthLevel(root.right, k, level + 1 );
}
public static void main(String[] args) {
TreeNode root = new TreeNode( 50 );
root.left = new TreeNode( 30 );
root.right = new TreeNode( 70 );
root.left.left = new TreeNode( 20 );
root.left.right = new TreeNode( 40 );
root.right.left = new TreeNode( 60 );
int k = 2 ;
int sum = sumAtKthLevel(root, k, 0 );
System.out.println( "The sum of nodes at level " + k + " is " + sum);
}
}
|
Python3
class TreeNode:
def __init__( self , x):
self .val = x
self .left = None
self .right = None
def sumAtKthLevel(root, k, level = 0 ):
if root is None :
return 0
if level = = k:
return root.val
return sumAtKthLevel(root.left, k, level + 1 ) + sumAtKthLevel(root.right, k, level + 1 )
if __name__ = = "__main__" :
root = TreeNode( 50 )
root.left = TreeNode( 30 )
root.right = TreeNode( 70 )
root.left.left = TreeNode( 20 )
root.left.right = TreeNode( 40 )
root.right.left = TreeNode( 60 )
k = 2
sum_val = sumAtKthLevel(root, k)
print (f "The sum of nodes at level {k} is {sum_val}" )
|
C#
using System;
public class TreeNode
{
public int val;
public TreeNode left;
public TreeNode right;
public TreeNode( int x)
{
val = x;
left = null ;
right = null ;
}
}
public class Program
{
public static int SumAtKthLevel(TreeNode root, int k, int level = 0)
{
if (root == null )
{
return 0;
}
if (level == k)
{
return root.val;
}
int leftSum = SumAtKthLevel(root.left, k, level + 1);
int rightSum = SumAtKthLevel(root.right, k, level + 1);
return leftSum + rightSum;
}
public static void Main( string [] args)
{
TreeNode root = new TreeNode(50);
root.left = new TreeNode(30);
root.right = new TreeNode(70);
root.left.left = new TreeNode(20);
root.left.right = new TreeNode(40);
root.right.left = new TreeNode(60);
int k = 2;
int sum = SumAtKthLevel(root, k);
Console.WriteLine( "The sum of nodes at level " + k + " is " + sum);
}
}
|
Javascript
class TreeNode {
constructor(val) {
this .val = val;
this .left = null ;
this .right = null ;
}
}
function sumAtKthLevel(root, k, level = 0) {
if (root === null ) {
return 0;
}
if (level === k) {
return root.val;
}
return (
sumAtKthLevel(root.left, k, level + 1) +
sumAtKthLevel(root.right, k, level + 1)
);
}
function main() {
const root = new TreeNode(50);
root.left = new TreeNode(30);
root.right = new TreeNode(70);
root.left.left = new TreeNode(20);
root.left.right = new TreeNode(40);
root.right.left = new TreeNode(60);
const k = 2;
const sum = sumAtKthLevel(root, k);
console.log(`The sum of nodes at level ${k} is ${sum}`);
}
main();
|
Output
The sum of nodes at level 2 is 120
Time complexity: O(n), where n is the number of nodes in the tree. We visit every node once.
Space complexity: O(h), where h is the height of the tree. The maximum amount of space used in the call stack is equal to the maximum depth of the recursion, which is the height of the tree.
Share your thoughts in the comments
Please Login to comment...