Difference between sums of odd level and even level nodes of a Binary Tree
Given a Binary Tree, find the difference between the sum of nodes at odd level and the sum of nodes at even level. Consider root as level 1, left and right children of root as level 2 and so on.
For example, in the following tree, sum of nodes at odd level is (5 + 1 + 4 + 8) which is 18. And sum of nodes at even level is (2 + 6 + 3 + 7 + 9) which is 27. The output for following tree should be 18 – 27 which is -9.
5
/ \
2 6
/ \ \
1 4 8
/ / \
3 7 9
A straightforward method is to use level order traversal. In the traversal, check level of current node, if it is odd, increment odd sum by data of current node, otherwise increment even sum. Finally return difference between odd sum and even sum. See following for implementation of this approach.
C implementation of level order traversal based approach to find the difference.
This approach is provided by Mandeep Singh. For Iterative approach, simply traverse the tree level by level (level order traversal), store sum of node values in even no. level in evenSum and rest in variable oddSum and finally return the difference.
Below is the simple implementation of the approach.
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
int data;
Node *left, *right;
};
Node* newNode( int data)
{
Node* temp = new Node();
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
int evenOddLevelDifference(Node* root)
{
if (!root)
return 0;
queue<Node*> q;
q.push(root);
int level = 0;
int evenSum = 0, oddSum = 0;
while (!q.empty())
{
int size = q.size();
level += 1;
while (size > 0)
{
Node* temp = q.front();
q.pop();
if (level % 2 == 0)
evenSum += temp->data;
else
oddSum += temp->data;
if (temp->left)
{
q.push(temp->left);
}
if (temp->right)
{
q.push(temp->right);
}
size -= 1;
}
}
return (oddSum - evenSum);
}
int main()
{
Node* root = newNode(5);
root->left = newNode(2);
root->right = newNode(6);
root->left->left = newNode(1);
root->left->right = newNode(4);
root->left->right->left = newNode(3);
root->right->right = newNode(8);
root->right->right->right = newNode(9);
root->right->right->left = newNode(7);
int result = evenOddLevelDifference(root);
cout << "difference between sums is :: " ;
cout << result << endl;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class Node {
int data;
Node left, right;
Node( int key)
{
data = key;
left = right = null ;
}
}
class GFG {
static int evenOddLevelDifference(Node root)
{
if (root == null )
return 0 ;
Queue<Node> q = new LinkedList<>();
q.add(root);
int level = 0 ;
int evenSum = 0 , oddSum = 0 ;
while (q.size() != 0 ) {
int size = q.size();
level++;
while (size > 0 ) {
Node temp = q.remove();
if (level % 2 == 0 )
evenSum += temp.data;
else
oddSum += temp.data;
if (temp.left != null )
q.add(temp.left);
if (temp.right != null )
q.add(temp.right);
size--;
}
}
return (oddSum - evenSum);
}
public static void main(String args[])
{
Node root = new Node( 5 );
root.left = new Node( 2 );
root.right = new Node( 6 );
root.left.left = new Node( 1 );
root.left.right = new Node( 4 );
root.left.right.left = new Node( 3 );
root.right.right = new Node( 8 );
root.right.right.right = new Node( 9 );
root.right.right.left = new Node( 7 );
System.out.println( "difference between sums is " +
evenOddLevelDifference(root));
}
}
|
Python3
class newNode:
def __init__( self , key):
self .data = key
self .left = None
self .right = None
def evenOddLevelDifference(root):
if ( not root):
return 0
q = []
q.append(root)
level = 0
evenSum = 0
oddSum = 0
while ( len (q)):
size = len (q)
level + = 1
while (size > 0 ):
temp = q[ 0 ]
q.pop( 0 )
if (level % 2 = = 0 ):
evenSum + = temp.data
else :
oddSum + = temp.data
if (temp.left) :
q.append(temp.left)
if (temp.right):
q.append(temp.right)
size - = 1
return (oddSum - evenSum)
if __name__ = = '__main__' :
root = newNode( 5 )
root.left = newNode( 2 )
root.right = newNode( 6 )
root.left.left = newNode( 1 )
root.left.right = newNode( 4 )
root.left.right.left = newNode( 3 )
root.right.right = newNode( 8 )
root.right.right.right = newNode( 9 )
root.right.right.left = newNode( 7 )
result = evenOddLevelDifference(root)
print ( "Difference between sums is" , result)
|
C#
using System;
using System.Collections.Generic;
public class Node
{
public int data;
public Node left, right;
public Node( int key)
{
data = key;
left = right = null ;
}
}
public class GFG
{
static int evenOddLevelDifference(Node root)
{
if (root == null )
return 0;
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
int level = 0;
int evenSum = 0, oddSum = 0;
while (q.Count != 0)
{
int size = q.Count;
level++;
while (size > 0)
{
Node temp = q.Dequeue();
if (level % 2 == 0)
evenSum += temp.data;
else
oddSum += temp.data;
if (temp.left != null )
q.Enqueue(temp.left);
if (temp.right != null )
q.Enqueue(temp.right);
size--;
}
}
return (oddSum - evenSum);
}
public static void Main(String []args)
{
Node root = new Node(5);
root.left = new Node(2);
root.right = new Node(6);
root.left.left = new Node(1);
root.left.right = new Node(4);
root.left.right.left = new Node(3);
root.right.right = new Node(8);
root.right.right.right = new Node(9);
root.right.right.left = new Node(7);
Console.WriteLine( "difference between sums is " +
evenOddLevelDifference(root));
}
}
|
Javascript
<script>
class Node
{
constructor(key)
{
this .data = key;
this .left = this .right = null ;
}
}
function evenOddLevelDifference(root)
{
if (root == null )
return 0;
let q = [];
q.push(root);
let level = 0;
let evenSum = 0, oddSum = 0;
while (q.length != 0) {
let size = q.length;
level++;
while (size > 0) {
let temp = q.shift();
if (level % 2 == 0)
evenSum += temp.data;
else
oddSum += temp.data;
if (temp.left != null )
q.push(temp.left);
if (temp.right != null )
q.push(temp.right);
size--;
}
}
return (oddSum - evenSum);
}
let root = new Node(5);
root.left = new Node(2);
root.right = new Node(6);
root.left.left = new Node(1);
root.left.right = new Node(4);
root.left.right.left = new Node(3);
root.right.right = new Node(8);
root.right.right.right = new Node(9);
root.right.right.left = new Node(7);
document.write( "difference between sums is " +
evenOddLevelDifference(root)+ "<br>" );
</script>
|
Output
difference between sums is :: -9
Time Complexity: O(N) where n is the number of nodes in the binary tree.
Auxiliary Space: O(N) where n is the number of nodes in the binary tree.
Another Approach
The problem can also be solved using simple recursive traversal. We can recursively calculate the required difference as, value of root’s data subtracted by the difference for subtree under left child and the difference for subtree under right child.
Below is the implementation of this approach.
C++
#include <bits/stdc++.h>
using namespace std;
class node
{
public :
int data;
node* left, *right;
};
node* newNode( int data)
{
node* Node = new node();
Node->data = data;
Node->left = Node->right = NULL;
return (Node);
}
int getLevelDiff(node *root)
{
if (root == NULL)
return 0;
return root->data - getLevelDiff(root->left) -
getLevelDiff(root->right);
}
int main()
{
node *root = newNode(5);
root->left = newNode(2);
root->right = newNode(6);
root->left->left = newNode(1);
root->left->right = newNode(4);
root->left->right->left = newNode(3);
root->right->right = newNode(8);
root->right->right->right = newNode(9);
root->right->right->left = newNode(7);
cout<<getLevelDiff(root)<< " is the required difference\n" ;
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node* left, *right;
};
struct node* newNode( int data)
{
struct node* node = ( struct node*) malloc ( sizeof ( struct node));
node->data = data;
node->left = node->right = NULL;
return (node);
}
int getLevelDiff( struct node *root)
{
if (root == NULL)
return 0;
return root->data - getLevelDiff(root->left) -
getLevelDiff(root->right);
}
int main()
{
struct node *root = newNode(5);
root->left = newNode(2);
root->right = newNode(6);
root->left->left = newNode(1);
root->left->right = newNode(4);
root->left->right->left = newNode(3);
root->right->right = newNode(8);
root->right->right->right = newNode(9);
root->right->right->left = newNode(7);
printf ( "%d is the required difference\n" , getLevelDiff(root));
getchar ();
return 0;
}
|
Java
class Node
{
int data;
Node left, right;
Node( int item)
{
data = item;
left = right;
}
}
class BinaryTree
{
Node root;
int getLevelDiff(Node node)
{
if (node == null )
return 0 ;
return node.data - getLevelDiff(node.left) -
getLevelDiff(node.right);
}
public static void main(String args[])
{
BinaryTree tree = new BinaryTree();
tree.root = new Node( 5 );
tree.root.left = new Node( 2 );
tree.root.right = new Node( 6 );
tree.root.left.left = new Node( 1 );
tree.root.left.right = new Node( 4 );
tree.root.left.right.left = new Node( 3 );
tree.root.right.right = new Node( 8 );
tree.root.right.right.right = new Node( 9 );
tree.root.right.right.left = new Node( 7 );
System.out.println(tree.getLevelDiff(tree.root) +
" is the required difference" );
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def getLevelDiff(root):
if root is None :
return 0
return (root.data - getLevelDiff(root.left) -
getLevelDiff(root.right))
root = Node( 5 )
root.left = Node( 2 )
root.right = Node( 6 )
root.left.left = Node( 1 )
root.left.right = Node( 4 )
root.left.right.left = Node( 3 )
root.right.right = Node( 8 )
root.right.right.right = Node( 9 )
root.right.right.left = Node( 7 )
print ( "%d is the required difference" % (getLevelDiff(root)))
|
C#
using System;
public class Node
{
public int data;
public Node left, right;
public Node( int item)
{
data = item;
left = right;
}
}
public class BinaryTree
{
public Node root;
public virtual int getLevelDiff(Node node)
{
if (node == null )
{
return 0;
}
return node.data - getLevelDiff(node.left)
- getLevelDiff(node.right);
}
public static void Main( string [] args)
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(5);
tree.root.left = new Node(2);
tree.root.right = new Node(6);
tree.root.left.left = new Node(1);
tree.root.left.right = new Node(4);
tree.root.left.right.left = new Node(3);
tree.root.right.right = new Node(8);
tree.root.right.right.right = new Node(9);
tree.root.right.right.left = new Node(7);
Console.WriteLine(tree.getLevelDiff(tree.root)
+ " is the required difference" );
}
}
|
Javascript
<script>
class Node
{
constructor(item)
{
this .data = item;
this .left = this .right = null ;
}
}
let root;
function getLevelDiff(node)
{
if (node == null )
return 0;
return node.data - getLevelDiff(node.left) -
getLevelDiff(node.right);
}
root = new Node(5);
root.left = new Node(2);
root.right = new Node(6);
root.left.left = new Node(1);
root.left.right = new Node(4);
root.left.right.left = new Node(3);
root.right.right = new Node(8);
root.right.right.right = new Node(9);
root.right.right.left = new Node(7);
document.write(getLevelDiff(root) +
" is the required difference" );
</script>
|
Output
-9 is the required difference
Time Complexity: O(N) where n is the number of nodes in the binary tree.
Auxiliary Space: O(h) where h is height of the binary tree due to recursion call.
Time complexity of both methods is O(n), but the second method is simple and easy to implement.
Another approach Modified Depth-First Search (DFS) with a Stack:
The basic idea behind the “Modified Depth-First Search (DFS) with a Stack” approach is to use an iterative process to traverse the binary tree while keeping track of the levels and their corresponding sums.
Below is the implementation:
C++
#include <iostream>
#include <stack>
using namespace std;
struct Node {
int data;
Node* left;
Node* right;
};
Node* newNode( int data)
{
Node* node = new Node();
node->data = data;
node->left = nullptr;
node->right = nullptr;
return node;
}
int getLevelDiff(Node* root)
{
if (root == nullptr)
return 0;
stack<pair<Node*, int > > st;
st.push(make_pair(
root, 1));
int oddSum = 0;
int evenSum = 0;
while (!st.empty()) {
Node* current = st.top().first;
int level = st.top().second;
st.pop();
if (level % 2 == 0)
evenSum += current->data;
else
oddSum += current->data;
if (current->right != nullptr)
st.push(make_pair(current->right, level + 1));
if (current->left != nullptr)
st.push(make_pair(current->left, level + 1));
}
return oddSum - evenSum;
}
int main()
{
Node* 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);
int diff = getLevelDiff(root);
cout << "Difference between the sum of node values at "
"even levels and odd levels: "
<< diff << endl;
return 0;
}
|
Java
import java.util.Stack;
class Node {
int data;
Node left;
Node right;
Node( int data)
{
this .data = data;
left = null ;
right = null ;
}
}
class Pair<T, U> {
T first;
U second;
Pair(T first, U second)
{
this .first = first;
this .second = second;
}
}
public class Main {
static int getLevelDiff(Node root)
{
if (root == null )
return 0 ;
Stack<Pair<Node, Integer> > st = new Stack<>();
st.push( new Pair<>(
root, 1 ));
int oddSum = 0 ;
int evenSum = 0 ;
while (!st.isEmpty()) {
Node current = st.peek().first;
int level = st.peek().second;
st.pop();
if (level % 2 == 0 )
evenSum += current.data;
else
oddSum += current.data;
if (current.right != null )
st.push(
new Pair<>(current.right, level + 1 ));
if (current.left != null )
st.push(
new Pair<>(current.left, level + 1 ));
}
return oddSum - evenSum;
}
public static void main(String[] args)
{
Node root = new Node( 1 );
root.left = new Node( 2 );
root.right = new Node( 3 );
root.left.left = new Node( 4 );
root.left.right = new Node( 5 );
root.right.left = new Node( 6 );
root.right.right = new Node( 7 );
int diff = getLevelDiff(root);
System.out.println(
"Difference between the sum of node values at "
+ "even levels and odd levels: " + diff);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def getLevelDiff(root):
if root is None :
return 0
stack = []
stack.append((root, 1 ))
oddSum = 0
evenSum = 0
while stack:
node, level = stack.pop()
if level % 2 = = 0 :
evenSum + = node.data
else :
oddSum + = node.data
if node.right:
stack.append((node.right, level + 1 ))
if node.left:
stack.append((node.left, level + 1 ))
return oddSum - evenSum
root = Node( 1 )
root.left = Node( 2 )
root.right = Node( 3 )
root.left.left = Node( 4 )
root.left.right = Node( 5 )
root.right.left = Node( 6 )
root.right.right = Node( 7 )
diff = getLevelDiff(root)
print ( "Difference between the sum of node values at even levels and odd levels:" , diff)
|
C#
using System;
using System.Collections.Generic;
public class Node
{
public int Data;
public Node Left;
public Node Right;
}
public class GFG
{
public static Node NewNode( int data)
{
Node node = new Node();
node.Data = data;
node.Left = null ;
node.Right = null ;
return node;
}
public static int GetLevelDiff(Node root)
{
if (root == null )
return 0;
Stack<Tuple<Node, int >> st = new Stack<Tuple<Node, int >>();
st.Push( new Tuple<Node, int >(root, 1));
int oddSum = 0;
int evenSum = 0;
while (st.Count > 0)
{
Tuple<Node, int > currentTuple = st.Pop();
Node current = currentTuple.Item1;
int level = currentTuple.Item2;
if (level % 2 == 0)
evenSum += current.Data;
else
oddSum += current.Data;
if (current.Right != null )
st.Push( new Tuple<Node, int >(current.Right, level + 1));
if (current.Left != null )
st.Push( new Tuple<Node, int >(current.Left, level + 1));
}
return oddSum - evenSum;
}
public static void Main( string [] args)
{
Node 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);
int diff = GetLevelDiff(root);
Console.WriteLine( "Difference between the sum of node values at even levels and odd levels: " + diff);
}
}
|
Javascript
class Node {
constructor(data) {
this .data = data;
this .left = null ;
this .right = null ;
}
}
function getLevelDiff(root) {
if (root === null ) {
return 0;
}
const stack = [];
stack.push({ node: root, level: 1 });
let oddSum = 0;
let evenSum = 0;
while (stack.length > 0) {
const { node, level } = stack.pop();
if (level % 2 === 0) {
evenSum += node.data;
} else {
oddSum += node.data;
}
if (node.right !== null ) {
stack.push({ node: node.right, level: level + 1 });
}
if (node.left !== null ) {
stack.push({ node: node.left, level: level + 1 });
}
}
return oddSum - evenSum;
}
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
const diff = getLevelDiff(root);
console.log( "Difference between the sum of node values at even levels and odd levels:" , diff);
|
Output
Difference between the sum of node values at even levels and odd levels: 18
Time Complexity: O(N) where n is the number of nodes in the binary tree.
Auxiliary Space: O(N) where n is the number of nodes in the binary tree.
Last Updated :
29 Aug, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...