Sum of decimal equivalents of binary node values in each level of a Binary Tree
Given a Binary Tree consisting of nodes with values 0 and 1 only, the task is to find the total sum of the decimal equivalents of the binary numbers formed by connecting nodes at the same level from left to right, on each level.
Examples:
Input: Below is the given Tree:
0
/ \
1 0
/ \ / \
0 1 1 1
Output: 9
Explanation:
Binary number formed at level 1 is “0” and its decimal equivalent is 0.
Binary number formed at level 2 is “10” and its decimal equivalent is 2.
Binary number formed at level 3 is “0111” and its decimal equivalent is 7.
Therefore, total sum = 0 + 2 + 7 = 9.
Input: Below is the given Tree:
0
/
1
/ \
1 0
Output: 3
Approach: The idea is to perform level order traversal using a queue and find the sum of numbers formed at each level. Follow the steps below to solve the problem:
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
class TreeNode {
public :
int val;
TreeNode *left, *right;
TreeNode( int key) {
val = key;
left = right = NULL;
}
};
int convertBinaryToDecimal(vector< int > arr) {
int ans = 0;
for ( int i : arr) ans = (ans << 1) | i;
return ans;
}
void decimalEquilvalentAtEachLevel(TreeNode *root) {
int ans = 0;
queue<TreeNode *> que;
que.push(root);
while ( true ) {
int length = que.size();
if (length == 0) break ;
vector< int > eachLvl;
while (length > 0) {
TreeNode *temp = que.front();
que.pop();
eachLvl.push_back(temp->val);
if (temp->left != NULL) que.push(temp->left);
if (temp->right != NULL) que.push(temp->right);
length -= 1;
}
ans += convertBinaryToDecimal(eachLvl);
}
cout << ans << endl;
}
int main()
{
TreeNode *root = new TreeNode(0);
root->left = new TreeNode(1);
root->right = new TreeNode(0);
root->left->left = new TreeNode(0);
root->left->right = new TreeNode(1);
root->right->left = new TreeNode(1);
root->right->right = new TreeNode(1);
decimalEquilvalentAtEachLevel(root);
return 0;
}
|
Java
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
class GFG {
static class TreeNode {
int val;
TreeNode left, right;
public TreeNode( int key) {
val = key;
left = right = null ;
}
}
static int convertBinaryToDecimal(ArrayList<Integer> arr) {
int ans = 0 ;
for ( int i : arr)
ans = (ans << 1 ) | i;
return ans;
}
static void decimalEquilvalentAtEachLevel(TreeNode root) {
int ans = 0 ;
Queue<TreeNode> que = new LinkedList<>();
que.add(root);
while ( true ) {
int length = que.size();
if (length == 0 )
break ;
ArrayList<Integer> eachLvl = new ArrayList<>();
while (length > 0 ) {
TreeNode temp = que.poll();
eachLvl.add(temp.val);
if (temp.left != null )
que.add(temp.left);
if (temp.right != null )
que.add(temp.right);
length -= 1 ;
}
ans += convertBinaryToDecimal(eachLvl);
}
System.out.println(ans);
}
public static void main(String[] args) {
TreeNode root = new TreeNode( 0 );
root.left = new TreeNode( 1 );
root.right = new TreeNode( 0 );
root.left.left = new TreeNode( 0 );
root.left.right = new TreeNode( 1 );
root.right.left = new TreeNode( 1 );
root.right.right = new TreeNode( 1 );
decimalEquilvalentAtEachLevel(root);
}
}
|
Python3
class TreeNode:
def __init__( self , val = 0 ,
left = None , right = None ):
self .val = val
self .left = left
self .right = right
def convertBinaryToDecimal(arr):
ans = 0
for i in arr:
ans = (ans << 1 ) | i
return ans
def decimalEquilvalentAtEachLevel(root):
ans = 0
que = [root]
while True :
length = len (que)
if not length:
break
eachLvl = []
while length:
temp = que.pop( 0 )
eachLvl.append(temp.val)
if temp.left:
que.append(temp.left)
if temp.right:
que.append(temp.right)
length - = 1
ans + = convertBinaryToDecimal(eachLvl)
print (ans)
root = TreeNode( 0 )
root.left = TreeNode( 1 )
root.right = TreeNode( 0 )
root.left.left = TreeNode( 0 )
root.left.right = TreeNode( 1 )
root.right.left = TreeNode( 1 )
root.right.right = TreeNode( 1 )
decimalEquilvalentAtEachLevel(root)
|
C#
using System;
using System.Collections.Generic;
class GFG{
class TreeNode{
public int val;
public TreeNode left,right;
};
static TreeNode newNode( int key){
TreeNode temp = new TreeNode();
temp.val = key;
temp.left = temp.right = null ;
return temp;
}
static int convertBinaryToDecimal(List< int > arr)
{
int ans = 0;
foreach ( int i in arr)
ans = (ans << 1) | i;
return ans;
}
static void decimalEquilvalentAtEachLevel(TreeNode root){
int ans = 0;
Queue<TreeNode> que = new Queue<TreeNode>();
que.Enqueue(root);
while ( true ){
int length = que.Count;
if (length == 0)
break ;
List< int > eachLvl = new List< int >();
while (length > 0){
TreeNode temp = que.Peek();
que.Dequeue();
eachLvl.Add(temp.val);
if (temp.left != null )
que.Enqueue(temp.left);
if (temp.right!= null )
que.Enqueue(temp.right);
length -= 1;
}
ans += convertBinaryToDecimal(eachLvl);
}
Console.WriteLine(ans);
}
public static void Main()
{
TreeNode root = newNode(0);
root.left = newNode(1);
root.right = newNode(0);
root.left.left = newNode(0);
root.left.right = newNode(1);
root.right.left = newNode(1);
root.right.right = newNode(1);
decimalEquilvalentAtEachLevel(root);
}
}
|
Javascript
<script>
class TreeNode{
constructor()
{
this .val = 0;
this .left = null ;
this .right = null ;
}
};
function newNode( key){
var temp = new TreeNode();
temp.val = key;
temp.left = temp.right = null ;
return temp;
}
function convertBinaryToDecimal(arr)
{
var ans = 0;
for ( var i of arr)
ans = (ans << 1) | i;
return ans;
}
function decimalEquilvalentAtEachLevel( root){
var ans = 0;
var que = [];
que.push(root);
while ( true ){
var length = que.length;
if (length == 0)
break ;
var eachLvl = [];
while (length > 0){
var temp = que[0];
que.shift();
eachLvl.push(temp.val);
if (temp.left != null )
que.push(temp.left);
if (temp.right!= null )
que.push(temp.right);
length -= 1;
}
ans += convertBinaryToDecimal(eachLvl);
}
document.write(ans);
}
var root = newNode(0);
root.left = newNode(1);
root.right = newNode(0);
root.left.left = newNode(0);
root.left.right = newNode(1);
root.right.left = newNode(1);
root.right.right = newNode(1);
decimalEquilvalentAtEachLevel(root);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(log(N))
New Approach:- Here is another approach to solving this problem
Below is the implementation of the above approach:
C++
#include <iostream>
#include <queue>
using namespace std;
class TreeNode {
public :
int val;
TreeNode* left;
TreeNode* right;
TreeNode( int val) {
this ->val = val;
this ->left = nullptr;
this ->right = nullptr;
}
};
int decimalEquivalentAtEachLevel(TreeNode* root) {
if (!root) {
return 0;
}
queue<TreeNode*> q;
q.push(root);
int level_sum = 0;
while (!q.empty()) {
int level_size = q.size();
int level_sum_temp = 0;
while (level_size > 0) {
TreeNode* node = q.front();
q.pop();
level_sum_temp = level_sum_temp * 2 + node->val;
if (node->left) {
q.push(node->left);
}
if (node->right) {
q.push(node->right);
}
level_size--;
}
level_sum += level_sum_temp;
}
return level_sum;
}
int main() {
TreeNode* root = new TreeNode(0);
root->left = new TreeNode(1);
root->right = new TreeNode(0);
root->left->left = new TreeNode(0);
root->left->right = new TreeNode(1);
root->right->left = new TreeNode(1);
root->right->right = new TreeNode(1);
int result = decimalEquivalentAtEachLevel(root);
cout << result << endl;
delete root->left->right;
delete root->left->left;
delete root->right->right;
delete root->right->left;
delete root->left;
delete root->right;
delete root;
return 0;
}
|
Java
import java.util.LinkedList;
import java.util.Queue;
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode( int val) {
this .val = val;
this .left = null ;
this .right = null ;
}
}
public class BinaryTree {
public static int decimalEquivalentAtEachLevel(TreeNode root) {
if (root == null ) {
return 0 ;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
int levelSum = 0 ;
while (!queue.isEmpty()) {
int levelSize = queue.size();
int levelSumTemp = 0 ;
while (levelSize > 0 ) {
TreeNode node = queue.poll();
levelSumTemp = levelSumTemp * 2 + node.val;
if (node.left != null ) {
queue.add(node.left);
}
if (node.right != null ) {
queue.add(node.right);
}
levelSize--;
}
levelSum += levelSumTemp;
}
return levelSum;
}
private static void deleteTree(TreeNode root) {
if (root == null ) {
return ;
}
deleteTree(root.left);
deleteTree(root.right);
root.left = null ;
root.right = null ;
}
public static void main(String[] args) {
TreeNode root = new TreeNode( 0 );
root.left = new TreeNode( 1 );
root.right = new TreeNode( 0 );
root.left.left = new TreeNode( 0 );
root.left.right = new TreeNode( 1 );
root.right.left = new TreeNode( 1 );
root.right.right = new TreeNode( 1 );
int result = decimalEquivalentAtEachLevel(root);
System.out.println(result);
deleteTree(root);
}
}
|
Python
from collections import deque
class TreeNode:
def __init__( self , val):
self .val = val
self .left = None
self .right = None
def decimalEquivalentAtEachLevel(root):
if not root:
return 0
queue = deque()
queue.append(root)
level_sum = 0
while queue:
level_size = len (queue)
level_sum_temp = 0
while level_size > 0 :
node = queue.popleft()
level_sum_temp = level_sum_temp * 2 + node.val
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
level_size - = 1
level_sum + = level_sum_temp
return level_sum
root = TreeNode( 0 )
root.left = TreeNode( 1 )
root.right = TreeNode( 0 )
root.left.left = TreeNode( 0 )
root.left.right = TreeNode( 1 )
root.right.left = TreeNode( 1 )
root.right.right = TreeNode( 1 )
result = decimalEquivalentAtEachLevel(root)
print (result)
|
C#
using System;
using System.Collections.Generic;
public class TreeNode
{
public int val;
public TreeNode left;
public TreeNode right;
public TreeNode( int val)
{
this .val = val;
this .left = null ;
this .right = null ;
}
}
public class BinaryTree
{
public static int DecimalEquivalentAtEachLevel(TreeNode root)
{
if (root == null )
{
return 0;
}
Queue<TreeNode> queue = new Queue<TreeNode>();
queue.Enqueue(root);
int level_sum = 0;
while (queue.Count > 0)
{
int level_size = queue.Count;
int level_sum_temp = 0;
while (level_size > 0)
{
TreeNode node = queue.Dequeue();
level_sum_temp = level_sum_temp * 2 + node.val;
if (node.left != null )
{
queue.Enqueue(node.left);
}
if (node.right != null )
{
queue.Enqueue(node.right);
}
level_size--;
}
level_sum += level_sum_temp;
}
return level_sum;
}
public static void Main()
{
TreeNode root = new TreeNode(0);
root.left = new TreeNode(1);
root.right = new TreeNode(0);
root.left.left = new TreeNode(0);
root.left.right = new TreeNode(1);
root.right.left = new TreeNode(1);
root.right.right = new TreeNode(1);
int result = DecimalEquivalentAtEachLevel(root);
Console.WriteLine(result);
DeleteTree(root);
Console.ReadLine();
}
private static void DeleteTree(TreeNode root)
{
if (root == null )
{
return ;
}
DeleteTree(root.left);
DeleteTree(root.right);
root.left = null ;
root.right = null ;
}
}
|
Javascript
class TreeNode {
constructor(val) {
this .val = val;
this .left = null ;
this .right = null ;
}
}
function decimalEquivalentAtEachLevel(root) {
if (!root) {
return 0;
}
const queue = [];
queue.push(root);
let levelSum = 0;
while (queue.length > 0) {
const levelSize = queue.length;
let levelSumTemp = 0;
for (let i = 0; i < levelSize; i++) {
const node = queue.shift();
levelSumTemp = levelSumTemp * 2 + node.val;
if (node.left) {
queue.push(node.left);
}
if (node.right) {
queue.push(node.right);
}
}
levelSum += levelSumTemp;
}
return levelSum;
}
const root = new TreeNode(0);
root.left = new TreeNode(1);
root.right = new TreeNode(0);
root.left.left = new TreeNode(0);
root.left.right = new TreeNode(1);
root.right.left = new TreeNode(1);
root.right.right = new TreeNode(1);
const result = decimalEquivalentAtEachLevel(root);
console.log(result);
|
Time complexity: O(N)
Auxiliary space: O(M)
Last Updated :
04 Oct, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...