Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Difference between sums of odd level and even level nodes in an N-ary Tree

  • Difficulty Level : Basic
  • Last Updated : 21 Jun, 2021

Given an N-ary Tree rooted at 1, the task is to find the difference between the sum of nodes at the odd level and the sum of nodes at even level.

Examples: 

Input:
                   4
               /  |   \
             2  3    -5
            / \       /  \
        -1   3   -2    6
Output: 10
Explanation:
Sum of nodes at even levels = 2 + 3 + (-5) = 0
Sum of nodes at odd levels = 4 + (-1) + 3 + (-2) + 6 = 10
Hence, the required difference is 10.

Input:       
              1
           / |  \
        2  -1  3
      /  \        \
    4    5        8
  /             / |    \
2            6  12   7  

Output: -13

Approach: To solve the problem, the idea is to find the respective sums of the nodes at the even and odd levels using Level Order Traversal and calculate the difference between them. Follow the steps below to solve the problem:

  • Initialize a Queue to store nodes and their respective levels.
  • Initialize variables evenSum and oddSum to store the sum of nodes at the even and odd levels respectively.
  • Push the root of the N-ary Tree along with its corresponding level, i.e., 1, into the Queue.   
  • Now, iterate and repeat the following steps until the Queue becomes empty:
    • Pop the nodes from the Queue. Store the level of the popped node in a variable, say currentLevel.
    • If currentLevel is even, add the value of the node to evenSum. Otherwise, add to oddSum.
    • Push all its children to the Queue and set their respective levels as currentLevel + 1.
  • Once the above steps are completed, calculate and print the difference between oddSum and evenSum.

Below is the implementation of the above approach:

C++




// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Structure of a node
// of an n-ary tree
struct Node {
    int val;
    vector<Node*> children;
};
 
// Function to create a
// new tree node
Node* newNode(int val)
{
    Node* temp = new Node;
    temp->val = val;
    return temp;
}
 
// Function to find the difference
// between of sums node values of
// odd and even levels in an N-ary tree
int evenOddLevelDifference(Node* root)
{
    // Store the sums of nodes at
    // even and odd levels
    int evenSum = 0, oddSum = 0;
 
    // Initialize a queue to store
    // pair of node and level
    queue<pair<Node*, int> > q;
 
    // Push the root into the
    // queue with level 1
    q.push({ root, 1 });
 
    // Iterate all levels
    // of tree are traversed
    while (!q.empty()) {
 
        // Store the node at the
        // front of the queue
        pair<Node*, int> currNode
            = q.front();
 
        // Pop the front node
        q.pop();
 
        // Store the current level
        int currLevel
            = currNode.second;
 
        // Store the current node value
        int currVal
            = currNode.first->val;
 
        // If current node
        // level is odd
        if (currLevel % 2)
 
            // Add to odd sum
            oddSum += currVal;
        else
 
            // Add to even sum
            evenSum += currVal;
 
        // Push all the children of current node
        // with increasing current level by 1
        for (auto child : currNode.first->children) {
            q.push({ child, currLevel + 1 });
        }
    }
 
    // Return the difference
    return (oddSum - evenSum);
}
 
// Driver Code
int main()
{
    // Create the N-ary Tree
    Node* root = newNode(4);
    root->children.push_back(newNode(2));
    root->children.push_back(newNode(3));
    root->children.push_back(newNode(-5));
    root->children[0]->children.push_back(newNode(-1));
    root->children[0]->children.push_back(newNode(3));
    root->children[2]->children.push_back(newNode(-2));
    root->children[2]->children.push_back(newNode(6));
 
    cout << evenOddLevelDifference(root);
 
    return 0;
}
Java



// Java program to implement
// the above approach
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
 
class GFG{
 
// Structure of a node
// of an n-ary tree
static class Node
{
    int val;
    ArrayList<Node> children;
 
    public Node(int val)
    {
        this.val = val;
        this.children = new ArrayList<Node>();
    }
};
 
static class Pair
{
    Node first;
    int second;
 
    public Pair(Node node, int val)
    {
        this.first = node;
        this.second = val;
    }
}
 
// Function to find the difference
// between of sums node values of
// odd and even levels in an N-ary tree
static int evenOddLevelDifference(Node root)
{
     
    // Store the sums of nodes at
    // even and odd levels
    int evenSum = 0, oddSum = 0;
 
    // Initialize a queue to store
    // pair of node and level
    Queue<Pair> q = new LinkedList<>();
 
    // Push the root into the
    // queue with level 1
    q.add(new Pair(root, 1));
 
    // Iterate all levels
    // of tree are traversed
    while (!q.isEmpty())
    {
         
        // Store the node at the
        // front of the queue
        Pair currNode = q.poll();
 
        // Store the current level
        int currLevel = currNode.second;
 
        // Store the current node value
        int currVal = currNode.first.val;
 
        // If current node
        // level is odd
        if (currLevel % 2 == 1)
         
            // Add to odd sum
            oddSum += currVal;
        else
         
            // Add to even sum
            evenSum += currVal;
 
        // Push all the children of current node
        // with increasing current level by 1
        for(Node child : currNode.first.children)
        {
            q.add(new Pair(child, currLevel + 1));
        }
    }
 
    // Return the difference
    return (oddSum - evenSum);
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Create the N-ary Tree
    Node root = new Node(4);
    root.children.add(new Node(2));
    root.children.add(new Node(3));
    root.children.add(new Node(-5));
    root.children.get(0).children.add(new Node(-1));
    root.children.get(0).children.add(new Node(3));
    root.children.get(2).children.add(new Node(-2));
    root.children.get(2).children.add(new Node(6));
 
    System.out.println(evenOddLevelDifference(root));
}
}
 
// This code is contributed by sanjeev2552
Python3



# Python3 program to implement
# the above approach
 
# Structure of a node
# of an n-ary tree
class Node:
     
    def __init__(self, val):
         
        self.val = val
        self.children = []
         
# Function to create a
# new tree node
def newNode(val):
 
    temp = Node(val)
     
    return temp
 
# Function to find the difference
# between of sums node values of
# odd and even levels in an N-ary tree
def evenOddLevelDifference(root):
 
    # Store the sums of nodes at
    # even and odd levels
    evenSum = 0
    oddSum = 0
  
    # Initialize a queue to store
    # pair of node and level
    q = []
  
    # Push the root into the
    # queue with level 1
    q.append([root, 1])
  
    # Iterate all levels
    # of tree are traversed
    while (len(q) != 0):
         
        # Store the node at the
        # front of the queue
        currNode = q[0]
  
        # Pop the front node
        q.pop(0)
  
        # Store the current level
        currLevel = currNode[1]
  
        # Store the current node value
        currVal = currNode[0].val
  
        # If current node
        # level is odd
        if (currLevel % 2 != 0):
  
            # Add to odd sum
            oddSum += currVal
        else:
  
            # Add to even sum
            evenSum += currVal
  
        # Push all the children of current node
        # with increasing current level by 1
        for child in currNode[0].children:
            q.append([child, currLevel + 1])
         
    # Return the difference
    return (oddSum - evenSum)
 
# Driver code
if __name__=="__main__":
     
    # Create the N-ary Tree
    root = newNode(4)
    root.children.append(newNode(2))
    root.children.append(newNode(3))
    root.children.append(newNode(-5))
    root.children[0].children.append(newNode(-1))
    root.children[0].children.append(newNode(3))
    root.children[2].children.append(newNode(-2))
    root.children[2].children.append(newNode(6))
  
    print(evenOddLevelDifference(root))
         
# This code is contributed by rutvik_56
C#



// C# program to implement
// the above approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG{
  
// Structure of a node
// of an n-ary tree
class Node
{
    public int val;
    public ArrayList children;
     
    public Node(int val)
    {
        this.val = val;
        this.children = new ArrayList();
    }
};
  
class Pair
{
    public Node first;
    public int second;
     
    public Pair(Node node, int val)
    {
        this.first = node;
        this.second = val;
    }
}
  
// Function to find the difference
// between of sums node values of
// odd and even levels in an N-ary tree
static int evenOddLevelDifference(Node root)
{
     
    // Store the sums of nodes at
    // even and odd levels
    int evenSum = 0, oddSum = 0;
  
    // Initialize a queue to store
    // pair of node and level
    Queue q = new Queue();
  
    // Push the root into the
    // queue with level 1
    q.Enqueue(new Pair(root, 1));
  
    // Iterate all levels
    // of tree are traversed
    while (q.Count != 0)
    {
         
        // Store the node at the
        // front of the queue
        Pair currNode = (Pair)q.Dequeue();
  
        // Store the current level
        int currLevel = currNode.second;
  
        // Store the current node value
        int currVal = currNode.first.val;
  
        // If current node
        // level is odd
        if (currLevel % 2 == 1)
          
            // Add to odd sum
            oddSum += currVal;
        else
          
            // Add to even sum
            evenSum += currVal;
  
        // Push all the children of current node
        // with increasing current level by 1
        foreach(Node child in currNode.first.children)
        {
            q.Enqueue(new Pair(child, currLevel + 1));
        }
    }
  
    // Return the difference
    return(oddSum - evenSum);
}
  
// Driver Code
public static void Main(string[] args)
{
     
    // Create the N-ary Tree
    Node root = new Node(4);
    root.children.Add(new Node(2));
    root.children.Add(new Node(3));
    root.children.Add(new Node(-5));
     
    ((Node)root.children[0]).children.Add(new Node(-1));
    ((Node)root.children[0]).children.Add(new Node(3));
    ((Node)root.children[2]).children.Add(new Node(-2));
    ((Node)root.children[2]).children.Add(new Node(6));
  
    Console.Write(evenOddLevelDifference(root));
}
}
 
// This code is contributed by pratham76
Javascript



<script>
 
    // JavaScript implementation of the above approach
     
    // Structure of a node of an n-ary tree
    // Structure of a Tree Node
    class Node
    {
        constructor(val) {
           this.children = [];
           this.val = val;
        }
    }
     
    // Function to find the difference
    // between of sums node values of
    // odd and even levels in an N-ary tree
    function evenOddLevelDifference(root)
    {
 
        // Store the sums of nodes at
        // even and odd levels
        let evenSum = 0, oddSum = 0;
 
        // Initialize a queue to store
        // pair of node and level
        let q = [];
 
        // Push the root into the
        // queue with level 1
        q.push([root, 1]);
 
        // Iterate all levels
        // of tree are traversed
        while (q.length != 0)
        {
 
            // Store the node at the
            // front of the queue
            let currNode = q[0];
            q.shift();
 
            // Store the current level
            let currLevel = currNode[1];
 
            // Store the current node value
            let currVal = currNode[0].val;
 
            // If current node
            // level is odd
            if (currLevel % 2 == 1)
 
                // Add to odd sum
                oddSum += currVal;
            else
 
                // Add to even sum
                evenSum += currVal;
 
            // Push all the children of current node
            // with increasing current level by 1
            for(let child = 0; child < (currNode[0].children).length;
            child++)
            {
                q.push([currNode[0].children[child], currLevel + 1]);
            }
        }
 
        // Return the difference
        return(oddSum - evenSum);
    }
     
    // Create the N-ary Tree
    let root = new Node(4);
    root.children.push(new Node(2));
    root.children.push(new Node(3));
    root.children.push(new Node(-5));
      
    (root.children[0]).children.push(new Node(-1));
    (root.children[0]).children.push(new Node(3));
    (root.children[2]).children.push(new Node(-2));
    (root.children[2]).children.push(new Node(6));
   
    document.write(evenOddLevelDifference(root));
     
</script>
Output: 
10
 
Time Complexity: O(N)
Auxiliary Space: O(N)
 

My Personal Notes
arrow_drop_up
Next

Difference between sums of odd level and even level nodes of a Binary Tree
Recommended Articles
Page :
Difference between sums of odd level and even level nodes of a Binary Tree
19, Aug 13
Difference between sums of odd position and even position nodes for each level of a Binary Tree
30, Apr 19
Modify Binary Tree by replacing all nodes at even and odd levels by their nearest even or odd perfect squares respectively
22, Feb 21
Print odd positioned nodes of odd levels in level order of the given binary tree
05, Sep 19
Print even positioned nodes of odd levels in level order of the given binary tree
06, Sep 19
Print odd positioned nodes of even levels in level order of the given binary tree
06, Sep 19
Print even positioned nodes of even levels in level order of the given binary tree
29, Apr 19
Difference between sum of even and odd valued nodes in a Binary Tree
09, Jul 20
Print levels with odd number of nodes and even number of nodes
27, Nov 18
Find if path length is even or odd between given Tree nodes for Q queries
01, Sep 21
Print nodes of a Binary Search Tree in Top Level Order and Reversed Bottom Level Order alternately
21, Sep 20
Print the nodes corresponding to the level value for each level of a Binary Tree
12, Oct 20
Calculate sum of all nodes present in a level for each level of a Tree
05, Feb 21
Modify a Binary Tree by adding a level of nodes with given value at a specified level
26, Apr 21
Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree
14, Sep 20
Check if a Binary Tree is an Even-Odd Tree or not
06, Oct 20
Swap first odd and even valued nodes from the beginning and end of a Linked List
03, Mar 21
Queries to find the maximum Xor value between X and the nodes of a given level of a perfect binary tree
15, May 19
Make all the elements of array odd by incrementing odd-indexed elements of odd-length subarrays
16, Dec 20
Connect Nodes at same Level (Level Order Traversal)
16, Aug 17
Count the nodes of the tree which make a pangram when concatenated with the sub-tree nodes
28, May 19
Print all the levels with odd and even number of nodes in it | Set-2
30, Nov 18
Print nodes between two given level numbers of a binary tree
19, Oct 14
Minimum difference between any two weighted nodes in Sum Tree of the given Tree
27, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
muskan_garg
@muskan_garg
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!