Open In App

Difference between sums of odd level and even level nodes of a Binary Tree

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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

Recommended Practice

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




// CPP program to find
// difference between
// sums of odd level
// and even level nodes
// of binary tree
#include <bits/stdc++.h>
using namespace std;
 
// tree node
struct Node
{
    int data;
    Node *left, *right;
};
 
// returns a new
// tree Node
Node* newNode(int data)
{
    Node* temp = new Node();
    temp->data = data;
    temp->left = temp->right = NULL;
    return temp;
}
 
// return difference of
// sums of odd level
// and even level
int evenOddLevelDifference(Node* root)
{
    if (!root)
        return 0;
 
    // create a queue for
    // level order traversal
    queue<Node*> q;
    q.push(root);
 
    int level = 0;
    int evenSum = 0, oddSum = 0;
 
    // traverse until the
    // queue is empty
    while (!q.empty())
    {
        int size = q.size();
        level += 1;
 
        // traverse for
        // complete level
        while(size > 0)
        {
            Node* temp = q.front();
            q.pop();
 
            // check if level no.
            // is even or odd and
            // accordingly update
            // the evenSum or oddSum
            if(level % 2 == 0)
                evenSum += temp->data;
            else
                oddSum += temp->data;
         
            // check for left child
            if (temp->left)
            {
                q.push(temp->left);
            }
             
            // check for right child
            if (temp->right)
            {
                q.push(temp->right);
            }
            size -= 1;
        }
    }
     
    return (oddSum - evenSum);
}
 
// driver program
int main()
{
    // construct a tree
    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




// Java program to find 
// difference between 
// sums of odd level 
// and even level nodes 
// of binary tree
import java.io.*;
import java.util.*;
// User defined node class
class Node {
      int data;
      Node left, right;
        
      // Constructor to create a new tree node
      Node(int key)
      {
           data  = key;
           left = right = null;
      }
}
class GFG {
      // return difference of
      // sums of odd level  and even level
      static int evenOddLevelDifference(Node root)
      {
             if (root == null)
                 return 0;
 
             // create a queue for
             // level order traversal
             Queue<Node> q = new LinkedList<>();
             q.add(root);
 
             int level = 0;
             int evenSum = 0, oddSum = 0;
 
             // traverse until the
             // queue is empty
             while (q.size() != 0) {
                   int size = q.size();
                   level++;
                    
                   // traverse for complete level
                   while (size > 0) {
                          Node temp = q.remove();
 
                          // check if level no.
                          // is even or odd and
                          // accordingly update
                          // the evenSum or oddSum
                          if (level % 2 == 0)
                              evenSum += temp.data;
                          else
                              oddSum += temp.data;
 
                          // check for left child
                          if (temp.left != null)
                              q.add(temp.left);
                            
                          // check for right child
                          if (temp.right != null)
                              q.add(temp.right);
                          size--;
                   }
             }
             return (oddSum - evenSum); 
      }
 
      // Driver code
      public static void main(String args[])
      {
             // construct a tree
             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));
      }
}
// This code is contributed by rachana soma


Python3




# Python3 program to find maximum product
# of a level in Binary Tree
 
# Helper function that allocates a new
# node with the given data and None
# left and right pointers.                                    
class newNode:
 
    # Construct to create a new node
    def __init__(self, key):
        self.data = key
        self.left = None
        self.right = None
 
# return difference of sums of odd
# level and even level
def evenOddLevelDifference(root):
 
    if (not root):
        return 0
 
    # create a queue for
    # level order traversal
    q = []
    q.append(root)
 
    level = 0
    evenSum = 0
    oddSum = 0
 
    # traverse until the queue is empty
    while (len(q)):
     
        size = len(q)
        level += 1
 
        # traverse for complete level
        while(size > 0):
         
            temp = q[0] #.front()
            q.pop(0)
 
            # check if level no. is even or
            # odd and accordingly update
            # the evenSum or oddSum
            if(level % 2 == 0):
                evenSum += temp.data
            else:
                oddSum += temp.data
         
            # check for left child
            if (temp.left) :
             
                q.append(temp.left)
             
            # check for right child
            if (temp.right):
             
                q.append(temp.right)
             
            size -= 1
         
    return (oddSum - evenSum)
 
# Driver Code
if __name__ == '__main__':
     
    """
    Let us create Binary Tree shown
    in above example """
    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)
 
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)


C#




// C# program to find
// difference between
// sums of odd level
// and even level nodes
// of binary tree
using System;
using System.Collections.Generic;
 
// User defined node class
public class Node
{
    public int data;
    public Node left, right;
         
    // Constructor to create a new tree node
    public Node(int key)
    {
        data = key;
        left = right = null;
    }
}
 
public class GFG
{
    // return difference of
    // sums of odd level and even level
    static int evenOddLevelDifference(Node root)
    {
            if (root == null)
                return 0;
 
            // create a queue for
            // level order traversal
            Queue<Node> q = new Queue<Node>();
            q.Enqueue(root);
 
            int level = 0;
            int evenSum = 0, oddSum = 0;
 
            // traverse until the
            // queue is empty
            while (q.Count != 0)
            {
                int size = q.Count;
                level++;
                     
                // traverse for complete level
                while (size > 0)
                {
                        Node temp = q.Dequeue();
 
                        // check if level no.
                        // is even or odd and
                        // accordingly update
                        // the evenSum or oddSum
                        if (level % 2 == 0)
                            evenSum += temp.data;
                        else
                            oddSum += temp.data;
 
                        // check for left child
                        if (temp.left != null)
                            q.Enqueue(temp.left);
                             
                        // check for right child
                        if (temp.right != null)
                            q.Enqueue(temp.right);
                        size--;
                }
            }
            return (oddSum - evenSum);
    }
 
    // Driver code
    public static void Main(String []args)
    {
            // construct a tree
            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));
    }
}
 
// This code is contributed by 29AjayKumar


Javascript




<script>
// Javascript program to find 
// difference between 
// sums of odd level 
// and even level nodes 
// of binary tree
 
// User defined node class
class Node
{
    constructor(key)
    {
        this.data  = key;
        this.left = this.right = null;
    }
}
 
 // return difference of
      // sums of odd level  and even level
function evenOddLevelDifference(root)
{
    if (root == null)
                 return 0;
   
             // create a queue for
             // level order traversal
             let q = [];
             q.push(root);
   
             let level = 0;
             let evenSum = 0, oddSum = 0;
   
             // traverse until the
             // queue is empty
             while (q.length != 0) {
                   let size = q.length;
                   level++;
                      
                   // traverse for complete level
                   while (size > 0) {
                          let temp = q.shift();
   
                          // check if level no.
                          // is even or odd and
                          // accordingly update
                          // the evenSum or oddSum
                          if (level % 2 == 0)
                              evenSum += temp.data;
                          else
                              oddSum += temp.data;
   
                          // check for left child
                          if (temp.left != null)
                              q.push(temp.left);
                              
                          // check for right child
                          if (temp.right != null)
                              q.push(temp.right);
                          size--;
                   }
             }
             return (oddSum - evenSum); 
}
 
 // Driver code
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>");
 
// This code is contributed by rag2127
</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++




// A recursive program to find difference
// between sum of nodes at odd level
// and sum at even level
#include <bits/stdc++.h>
using namespace std;
 
// Binary Tree node
class node
{
    public:
    int data;
    node* left, *right;
};
 
// A utility function to allocate
// a new tree node with given data
node* newNode(int data)
{
    node* Node = new node();
    Node->data = data;
    Node->left = Node->right = NULL;
    return (Node);
}
 
// The main function that return
// difference between odd and even
// level nodes
int getLevelDiff(node *root)
{
// Base case
if (root == NULL)
        return 0;
 
// Difference for root is root's data - difference for
// left subtree - difference for right subtree
return root->data - getLevelDiff(root->left) -
                    getLevelDiff(root->right);
}
 
// Driver code
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;
}
 
// This code is contributed by rathbhupendra


C




// A recursive program to find difference between sum of nodes at
// odd level and sum at even level
#include <stdio.h>
#include <stdlib.h>
 
// Binary Tree node
struct node
{
    int data;
    struct node* left, *right;
};
 
// A utility function to allocate a new tree node with given data
struct node* newNode(int data)
{
    struct node* node = (struct node*)malloc(sizeof(struct node));
    node->data = data;
    node->left =  node->right = NULL;
    return (node);
}
 
// The main function that return difference between odd and even level
// nodes
int getLevelDiff(struct node *root)
{
   // Base case
   if (root == NULL)
         return 0;
 
   // Difference for root is root's data - difference for
   // left subtree - difference for right subtree
   return root->data - getLevelDiff(root->left) -
                                         getLevelDiff(root->right);
}
 
// Driver program to test above functions
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




// A recursive java program to find difference between sum of nodes at
// odd level and sum at even level
  
// A binary tree node
class Node
{
    int data;
    Node left, right;
  
    Node(int item)
    {
        data = item;
        left = right;
    }
}
  
class BinaryTree
{
    // The main function that return difference between odd and even level
    // nodes
    Node root;
  
    int getLevelDiff(Node node)
    {
        // Base case
        if (node == null)
            return 0;
 
        // Difference for root is root's data - difference for
        // left subtree - difference for right subtree
        return node.data - getLevelDiff(node.left) -
                                              getLevelDiff(node.right);
    }
  
    // Driver program to test above functions
    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");
  
    }
}
  
// This code has been contributed by Mayank Jaiswal


Python3




# A recursive program to find difference between sum of nodes
# at odd level and sum at even level
 
# A Binary Tree node
class Node:
 
    # Constructor to create a new node
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
# The main function that returns difference between odd and
# even level nodes
def getLevelDiff(root):
 
    # Base Case
    if root is None:
        return 0
 
    # Difference for root is root's data - difference for
    # left subtree - difference for right subtree
    return (root.data - getLevelDiff(root.left)-
        getLevelDiff(root.right))
 
# Driver program to test above function
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)))
 
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)


C#




using System;
 
// A recursive C# program to find
// difference between sum of nodes at
// odd level and sum at even level
 
// A binary tree node
public class Node
{
    public int data;
    public Node left, right;
 
    public Node(int item)
    {
        data = item;
        left = right;
    }
}
 
public class BinaryTree
{
    // The main function that return difference
    // between odd and even level nodes
    public Node root;
 
    public virtual int getLevelDiff(Node node)
    {
        // Base case
        if (node == null)
        {
            return 0;
        }
 
        // Difference for root is root's
        // data - difference for left subtree
        //  - difference for right subtree
        return node.data - getLevelDiff(node.left)
                        - getLevelDiff(node.right);
    }
 
    // Driver program to test above functions
    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");
 
    }
}
 
// This code is contributed by Shrikant13


Javascript




<script>
// A recursive javascript program to find difference between sum of nodes at
// odd level and sum at even level
   
// A binary tree node
class Node
{
    constructor(item)
    {
        this.data = item;
        this.left = this.right = null;
    }
}
 
// The main function that return difference between odd and even level
    // nodes
let root;
 
function getLevelDiff(node)
{
 
    // Base case
        if (node == null)
            return 0;
  
        // Difference for root is root's data - difference for
        // left subtree - difference for right subtree
        return node.data - getLevelDiff(node.left) -
                                              getLevelDiff(node.right);
}
 
// Driver program to test above functions
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");
 
// This code is contributed by avanitrachhadiya2155
</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++




// C++ code to implement the DFS approach
#include <iostream>
#include <stack>
using namespace std;
 
// Definition of a binary tree node
struct Node {
    int data;
    Node* left;
    Node* right;
};
 
// Function to create a new binary tree node
Node* newNode(int data)
{
    Node* node = new Node();
    node->data = data;
    node->left = nullptr;
    node->right = nullptr;
    return node;
}
 
// Function to get the difference between the sum of node
// values at even levels and odd levels
int getLevelDiff(Node* root)
{
    if (root == nullptr)
        return 0;
 
    stack<pair<Node*, int> > st;
    st.push(make_pair(
        root, 1)); // Push the root node with level 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;
}
// driver code
int main()
{
    // Constructing the binary tree
    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);
 
    // Function call to get the difference
    int diff = getLevelDiff(root);
 
    // Output the difference
    cout << "Difference between the sum of node values at "
            "even levels and odd levels: "
         << diff << endl;
 
    return 0;
}


Java




import java.util.Stack;
 
// Definition of a binary tree node
class Node {
    int data;
    Node left;
    Node right;
 
    // Constructor
    Node(int data)
    {
        this.data = data;
        left = null;
        right = null;
    }
}
 
// Custom Pair class
class Pair<T, U> {
    T first;
    U second;
 
    Pair(T first, U second)
    {
        this.first = first;
        this.second = second;
    }
}
 
public class Main {
    // Function to get the difference between the sum of
    // node values at even levels and odd levels
    static int getLevelDiff(Node root)
    {
        if (root == null)
            return 0;
 
        Stack<Pair<Node, Integer> > st = new Stack<>();
        st.push(new Pair<>(
            root, 1)); // Push the root node with level 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;
    }
 
    // Driver code
    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);
 
        // Function call to get the difference
        int diff = getLevelDiff(root);
 
        // Output the difference
        System.out.println(
            "Difference between the sum of node values at "
            + "even levels and odd levels: " + diff);
    }
}
// This code is contributed by Veerendra_Singh_Rajpoot


Python3




# Python code for the above approach
# Definition of a binary tree node
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
# Function to get the difference between the sum of node
# values at even levels and odd levels
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
 
# Driver code to test above function
# Constructing the binary tree
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)
 
# Function call to get the difference
diff = getLevelDiff(root)
 
# Output the difference
print("Difference between the sum of node values at even levels and odd levels:", diff)
# This code is contributed by Kirti Agarwal


C#




using System;
using System.Collections.Generic;
 
// Definition of a binary tree node
public class Node
{
    public int Data;
    public Node Left;
    public Node Right;
}
 
public class GFG
{
    // Function to create a new binary tree node
    public static Node NewNode(int data)
    {
        Node node = new Node();
        node.Data = data;
        node.Left = null;
        node.Right = null;
        return node;
    }
 
    // Function to get the difference between the sum of node
    // values at even levels and odd levels
    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)); // Push the root node with level 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;
    }
 
    // Driver code
    public static void Main(string[] args)
    {
        // Constructing the binary tree
        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);
 
        // Function call to get the difference
        int diff = GetLevelDiff(root);
 
        // Output the difference
        Console.WriteLine("Difference between the sum of node values at even levels and odd levels: " + diff);
    }
}


Javascript




// Definition of a binary tree node
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
 
// Function to get the difference between the sum of node
// values at even levels and odd levels
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;
}
 
// Driver code to test above function
// Constructing the binary tree
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);
 
// Function call to get the difference
const diff = getLevelDiff(root);
 
// Output the difference
console.log("Difference between the sum of node values at even levels and odd levels:", diff);
 
// THIS CODE IS CONTRIBUTED BY KIRTI AGARWAL


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
Previous
Next
Share your thoughts in the comments
Similar Reads