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

Last Updated : 3 May, 2026

Given a Binary Tree, the task is to find the difference between the sum of nodes at the odd level and the sum of nodes at the even level.

Examples:

Input:

Print-Nodes-in-Top-View-of-Binary-Tree-1

Output: -4
Explanation: sum at odd levels - sum at even levels = (1) - (2 + 3) = 1 - 5 = -4

Input:

Serialize-and-Deserialize-a-Binary-Tree-example

Output: 60
Explanation: Sum at odd levels - Sum at even levels = (10 + 40 + 60) - (20 + 30) = 110 - 50 = 60

Try It Yourself
redirect icon

Table of Content

Using Recursion - O(n) Time and O(h) Space

The idea is to perform a recursive traversal of the binary tree while keeping track of the current level of each node. At each node, we check if the level is odd or even and add the node's data to the respective sum. The recursion continues for both the left and right children, with the level being incremented by 1 for each level deeper in the tree. Finally, the difference between the odd level sum and the even level sum is returned.

C++
// C++ program to find the difference between 
// sums of odd and even level in a Binary tree 
// using Recursion
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
  
    Node(int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

void getLevelDiffHelper(Node* root, int level, 
                          int& oddSum, int& evenSum) {
  
    // Base case: If the node is nullptr, return
    if (root == nullptr) {
        return;
    }
    
    // Add to oddSum or evenSum based on the level
    if (level % 2 != 0) {
        oddSum += root->data; 
    } 
    else {
        evenSum += root->data; 
    }

    // Recur for left and right children with 
    // incremented level
    getLevelDiffHelper(root->left, 
                          level + 1, oddSum, evenSum);
  
    getLevelDiffHelper(root->right,
                          level + 1, oddSum, evenSum);
}

int getLevelDiff(Node* root) {
  
    // Initialize sums for odd and even levels
    int oddSum = 0, evenSum = 0;
  
    // Start the recursion from level 1
    getLevelDiffHelper(root, 1, oddSum, evenSum);

    // Return the difference between odd
    // and even sums
    return oddSum - evenSum;
}

int main() {
  
    // Hardcoded input binary tree
    //       10
    //      /  \
    //     20   30
    //    /  \         
    //  40    60 
    Node* root = new Node(10);
    root->left = new Node(20);
    root->right = new Node(30);
    root->left->left = new Node(40);
    root->left->right = new Node(60);

    cout << getLevelDiff(root) << endl;

    return 0;
}
C
// C program to find the difference between 
// sums of odd and even level in a Binary tree 
// using Recursion
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// Helper function for getLevelDiff
void getLevelDiffHelper(struct Node* root, int level, 
                        int* oddSum, int* evenSum) {

    // Base case: If the node is NULL, return
    if (root == NULL) {
        return;
    }

    // Add to oddSum or evenSum based on the level
    if (level % 2 != 0) {
        *oddSum += root->data;
    }
    else {
        *evenSum += root->data;
    }

    // Recur for left and right children with 
    // incremented level
    getLevelDiffHelper(root->left, level + 1, 
                                 oddSum, evenSum);
  
    getLevelDiffHelper(root->right, level + 1, 
                                 oddSum, evenSum);
}

// Function to calculate the difference between
// sums of odd and even levels
int getLevelDiff(struct Node* root) {

    // Initialize sums for odd and even levels
    int oddSum = 0, evenSum = 0;

    // Start the recursion from level 1
    getLevelDiffHelper(root, 1, &oddSum, &evenSum);

    // Return the difference between odd
    // and even sums
    return oddSum - evenSum;
}

struct Node* createNode(int x) {
    struct Node* newNode = 
        (struct Node*)malloc(sizeof(struct Node));

    newNode->data = x;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

int main() {

    // Hardcoded input binary tree
    //       10
    //      /  \
    //     20   30
    //    /  \         
    //  40    60 
    struct Node* root = createNode(10);
    root->left = createNode(20);
    root->right = createNode(30);
    root->left->left = createNode(40);
    root->left->right = createNode(60);

    printf("%d\n", getLevelDiff(root));

    return 0;
}
Java
// Java program to find the difference between 
// sums of odd and even level in a Binary tree 
// using Recursion
import java.util.*;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    static void getLevelDiffHelper(Node root, int level, 
                                   int[] oddSum, int[] evenSum) {

        // Base case: If the node is null, return
        if (root == null) {
            return;
        }

        // Add to oddSum or evenSum based on the level
        if (level % 2 != 0) {
            oddSum[0] += root.data; 
        } else {
            evenSum[0] += root.data; 
        }

        // Recur for left and right children with 
        // incremented level
        getLevelDiffHelper(root.left, 
                           level + 1, oddSum, evenSum);
        getLevelDiffHelper(root.right,
                           level + 1, oddSum, evenSum);
    }

    static int getLevelDiff(Node root) {

        // Initialize sums for odd and even levels
        int[] oddSum = {0}, evenSum = {0};

        // Start the recursion from level 1
        getLevelDiffHelper(root, 1, oddSum, evenSum);

        // Return the difference between odd
        // and even sums
        return oddSum[0] - evenSum[0];
    }

    public static void main(String[] args) {

        // Hardcoded input binary tree
        //       10
        //      /  \
        //     20   30
        //    /  \         
        //  40    60 
        Node root = new Node(10);
        root.left = new Node(20);
        root.right = new Node(30);
        root.left.left = new Node(40);
        root.left.right = new Node(60);

        System.out.println(getLevelDiff(root));
    }
}
Python
# Python program to find the difference between 
# sums of odd and even level in a Binary tree 
# using Recursion
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

def getLevelDiffHelper(root, level, oddSum, evenSum):
    
    # Base case: If the node is None, return
    if root is None:
        return
    
    # Add to oddSum or evenSum based on the level
    if level % 2 != 0:
        oddSum[0] += root.data
    else:
        evenSum[0] += root.data
    
    # Recur for left and right children with 
    # incremented level
    getLevelDiffHelper(root.left, level + 1, oddSum, evenSum)
    getLevelDiffHelper(root.right, level + 1, oddSum, evenSum)

def getLevelDiff(root):
    
    # Initialize sums for odd and even levels
    oddSum = [0]
    evenSum = [0]
    
    # Start the recursion from level 1
    getLevelDiffHelper(root, 1, oddSum, evenSum)
    
    # Return the difference between odd
    # and even sums
    return oddSum[0] - evenSum[0]

if __name__ == "__main__":

    # Hardcoded input binary tree
    #       10
    #      /  \
    #     20   30
    #    /  \         
    #  40    60 
    root = Node(10)
    root.left = Node(20)
    root.right = Node(30)
    root.left.left = Node(40)
    root.left.right = Node(60)

    print(getLevelDiff(root))
C#
// C# program to find the difference between 
// sums of odd and even level in a Binary tree 
// using Recursion
using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    static void getLevelDiffHelper(Node root, int level, 
                                   ref int oddSum, ref int evenSum) {

        // Base case: If the node is null, return
        if (root == null) {
            return;
        }

        // Add to oddSum or evenSum based on the level
        if (level % 2 != 0) {
            oddSum += root.data; 
        } else {
            evenSum += root.data; 
        }

        // Recur for left and right children with 
        // incremented level
        getLevelDiffHelper(root.left, 
                           level + 1, ref oddSum, ref evenSum);
      
        getLevelDiffHelper(root.right,
                           level + 1, ref oddSum, ref evenSum);
    }

    static int getLevelDiff(Node root) {

        // Initialize sums for odd and even levels
        int oddSum = 0, evenSum = 0;

        // Start the recursion from level 1
        getLevelDiffHelper(root, 1, ref oddSum, ref evenSum);

        // Return the difference between odd
        // and even sums
        return oddSum - evenSum;
    }

    static void Main(string[] args) {

        // Hardcoded input binary tree
        //       10
        //      /  \
        //     20   30
        //    /  \         
        //  40    60 
        Node root = new Node(10);
        root.left = new Node(20);
        root.right = new Node(30);
        root.left.left = new Node(40);
        root.left.right = new Node(60);

        Console.WriteLine(getLevelDiff(root));
    }
}
JavaScript
// JavaScript program to find the difference between 
// sums of odd and even level in a Binary tree 
// using Recursion
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

function getLevelDiffHelper(root, level,
                              oddSum, evenSum) {
    
    // Base case: If the node is null, return
    if (root === null) {
        return;
    }
    
    // Add to oddSum or evenSum based on the level
    if (level % 2 !== 0) {
        oddSum.value += root.data;
    } else {
        evenSum.value += root.data;
    }
    
    // Recur for left and right children with 
    // incremented level
    getLevelDiffHelper(root.left, level + 1,
                                     oddSum, evenSum);

    getLevelDiffHelper(root.right, level + 1,
                                     oddSum, evenSum);
}

function getLevelDiff(root) {
    
    // Initialize sums for odd and even levels
    const oddSum = { value: 0 };
    const evenSum = { value: 0 };
    
    // Start the recursion from level 1
    getLevelDiffHelper(root, 1, oddSum, evenSum);
    
    // Return the difference between odd
    // and even sums
    return oddSum.value - evenSum.value;
}

// Hardcoded input binary tree
//       10
//      /  \
//     20   30
//    /  \         
//  40    60 
const root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.left = new Node(40);
root.left.right = new Node(60);

console.log(getLevelDiff(root));

Output
60

Using Level Order Traversal - O(n) Time and O(n) Space

The idea is to use line by line level-order traversal (BFS) to process nodes level by level. We maintain a queue to traverse nodes level by level and use a boolean flag to alternate between odd and even levels. As we visit each node, we add its value to the appropriate sum (either oddSum or evenSum). After processing all nodes, the difference between the odd and even level sums is returned.

C++
// C++ program to find difference between
// sums of odd and even level in a tree
#include <bits/stdc++.h>
using namespace std;

class Node {
  public:
    int data;
    Node *left, *right;

    Node(int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

int getLevelDiff(Node *root) {

    // If the tree is empty
    if (root == nullptr) {
        return 0;
    }

    // Queue for level-order traversal
    queue<Node *> q;
    q.push(root);

    int oddSum = 0, evenSum = 0;
    bool isOdd = true;

    while (!q.empty()) {
        int size = q.size();

        for (int i = 0; i < size; i++) {
            Node *curr = q.front();
            q.pop();

            // Add to oddSum or evenSum
            if (isOdd) {
                oddSum += curr->data;
            }
            else {
                evenSum += curr->data;
            }

            // Push left and right children
            // to the queue
            if (curr->left) {
                q.push(curr->left);
            }
            if (curr->right) {
                q.push(curr->right);
            }
        }

        // Toggle odd/even level
        isOdd = !isOdd;
    }

    return oddSum - evenSum;
}

int main() {

    // Hardcoded input binary tree
    //       10
    //      /  \
    //     20   30
    //    /  \         
    //  40    60
    Node *root = new Node(10);
    root->left = new Node(20);
    root->right = new Node(30);
    root->left->left = new Node(40);
    root->left->right = new Node(60);

    cout << getLevelDiff(root) << endl;

    return 0;
}
Java
// Java program to find difference between
// sums of odd and even level in a tree
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 getLevelDiff(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);
    }

    public static void main(String args[]) {
      
       // Create a hard coded tree
        //       10
        //     /    \
        //    20    30
        //  /   \
        // 40  60
        Node root = new Node(10);        
        root.left = new Node(20);        
        root.right = new Node(30);       
        root.left.left = new Node(40);
        root.left.right = new Node(60);

        System.out.println(getLevelDiff(root));
    }
}
Python
# Python program to find difference between 
# sums of odd and even level in a tree
from collections import deque

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

def getLevelDiff(root):
    
    # If the tree is empty
    if root is None:
        return 0

    # Queue for level-order traversal
    q = deque()
    q.append(root)

    oddSum = 0
    evenSum = 0
    isOdd = True

    while q:
        size = len(q)

        for i in range(size):
            curr = q.popleft()

            # Add to oddSum or evenSum
            if isOdd:
                oddSum += curr.data
            else:
                evenSum += curr.data

            # Push left and right children 
            # to the queue
            if curr.left:
                q.append(curr.left)
            if curr.right:
                q.append(curr.right)

        # Toggle odd/even level
        isOdd = not isOdd

    return oddSum - evenSum


if __name__ == "__main__":
  
    # Hardcoded input binary tree
    #       10
    #      /  \
    #     20   30
    #    /  \         
    #  40    60 
    root = Node(10)
    root.left = Node(20)
    root.right = Node(30)
    root.left.left = Node(40)
    root.left.right = Node(60)

    print(getLevelDiff(root))
C#
// C# program to find difference between
// sums of odd and even level in a tree
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int key) {
        data = key;
        left = right = null;
    }
}

class GfG {
  
    static int getLevelDiff(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);
    }

     static void Main(String[] args) {
       
       // Create a hard coded tree
        //       10
        //     /    \
        //    20    30
        //  /   \
        // 40  60
        Node root = new Node(10);        
        root.left = new Node(20);        
        root.right = new Node(30);       
        root.left.left = new Node(40);
        root.left.right = new Node(60);

        Console.WriteLine(getLevelDiff(root));
    }
}
JavaScript
// JavaScript program to find the difference between
// sums of odd and even levels in a tree
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

function getLevelDiff(root) {

    // If the tree is empty
    if (root === null) {
        return 0;
    }

    // Queue for level-order traversal
    let q = [];
    q.push(root);

    let oddSum = 0, evenSum = 0;
    let isOdd = true;

    while (q.length > 0) {
        let size = q.length;

        // Process all nodes at the current level
        for (let i = 0; i < size; i++) {
            let curr = q.shift();

            // Add to oddSum or evenSum
            if (isOdd) {
                oddSum += curr.data;
            }
            else {
                evenSum += curr.data;
            }

            // Push left and right children to the queue
            if (curr.left !== null) {
                q.push(curr.left);
            }
            if (curr.right !== null) {
                q.push(curr.right);
            }
        }

        // Toggle odd/even level
        isOdd = !isOdd;
    }

    return oddSum - evenSum;
}

// Hardcoded input binary tree
//       10
//      /  \
//     20   30
//    /  \         
//  40    60
let root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.left = new Node(40);
root.left.right = new Node(60);

console.log(getLevelDiff(root));

Output
60
Comment
Article Tags:
Tree
DSA
Amazon

Explore