Difference between odd level and even level leaf sum in given Binary Tree
Given a Binary Tree, the task is to find the difference of the sum of leaf nodes at the odd level and even level of the given tree.
Examples:
Input:
Output: -12
Explanation: Following are the operations performed to get the result.
odd_level_sum = 0, even_level_sum = 0
Level 1: No leaf node, so odd_level_sum = 0
Level 2: No leaf node, so even_level_sum = 0
Level 3: One leaf node: 6, so odd_level_sum = 0 + 6 = 6
Level 4: Three leaf nodes: 9, 10, 11, so even_level_sum = 0 + 9 + 10 + 11 = 30
Level 5: One leaf node: 12, so odd_level_sum = 6 + 12 = 18
Therefore, result = odd_level_sum – even_level_sum = 18 – 30 = -12Input:
Output: -12
Approach: The given problem can be solved by using the Level Order Traversal. Follow the steps below to solve the given problem.
- Create a queue q, to store the node. Also, create two variables odd_level_sum and even_level_sum to store the sum of leaf nodes at the odd and even levels of the tree respectively. The other variable level keeps track of the level in the traversal.
- Perform the level order traversal from the root node and store each node in the queue, and also check the current node for the leaf node. If it’s a leaf node then add its value in the odd_level_sum or even_level_sum by checking the level.
- After completing the above steps, print the difference between odd_level_sum and even_level_sum.
Below is the implementation of the above approach:
C++
// C++ program for above approach #include <bits/stdc++.h> using namespace std; // A tree node structure struct Node { int data; Node *left, *right; }; // Utility function to create // a new Binary Tree node Node* newNode( int data) { Node* temp = new Node; temp->data = data; temp->left = temp->right = NULL; return temp; } // Function to print the difference void printDifference(Node* root) { if (root == NULL) { cout << "No nodes present\n" ; return ; } int odd_level_sum = 0, even_level_sum = 0, level = 1; // queue to hold tree node with level queue< struct Node*> q; // Root node is at level 1 so level=1 q.push(root); // Do level Order Traversal of tree while (!q.empty()) { int n = q.size(); while (n--) { Node* temp = q.front(); q.pop(); if (temp->left == NULL && temp->right == NULL) { if (level & 1) { odd_level_sum += temp->data; } else { even_level_sum += temp->data; } continue ; } if (temp->left) { q.push(temp->left); } if (temp->right) { q.push(temp->right); } } level++; } cout << odd_level_sum - even_level_sum; } // Driver Code 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); root->left->left->right = newNode(8); root->left->right->right = newNode(9); root->right->right->left = newNode(10); root->right->right->right = newNode(11); root->left->left->right->right = newNode(12); printDifference(root); return 0; } |
Java
// Java program for above approach import java.util.LinkedList; import java.util.Queue; class GFG { // A tree node structure static class Node { int data; Node left; Node right; public Node( int data) { this .data = data; this .left = null ; this .right = null ; } }; // Utility function to create // a new Binary Tree node static Node Node( int data) { Node temp = new Node( 0 ); temp.data = data; temp.left = temp.right = null ; return temp; } // Function to print the difference static void printDifference(Node root) { if (root == null ) { System.out.println( "No nodes present" ); return ; } int odd_level_sum = 0 , even_level_sum = 0 , level = 1 ; // queue to hold tree node with level Queue<Node> q = new LinkedList<Node>(); // Root node is at level 1 so level=1 q.add(root); // Do level Order Traversal of tree while (!q.isEmpty()) { int n = q.size(); while (n-- > 0 ) { Node temp = q.peek(); q.remove(); if (temp.left == null && temp.right == null ) { if ((level & 1 ) > 0 ) { odd_level_sum += temp.data; } else { even_level_sum += temp.data; } continue ; } if (temp.left != null ) { q.add(temp.left); } if (temp.right != null ) { q.add(temp.right); } } level++; } System.out.println(odd_level_sum - even_level_sum); } // 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 ); root.left.left.right = new Node( 8 ); root.left.right.right = new Node( 9 ); root.right.right.left = new Node( 10 ); root.right.right.right = new Node( 11 ); root.left.left.right.right = new Node( 12 ); printDifference(root); } } // This code is contributed by saurabh_jaiswal. |
-12
Time Complexity: O(N)
Space Complexity: O(N)