Given a Binary Tree, the task is to check if the maximum sum level divides the binary tree into the two parts of two equal sum halves.
Examples:
Input: 1 / \ 2 3 / \ \ 4 5 8 / \ 2 4 Output: YES Explanation: The maximum sum level is 2 and its sum is (4 + 5 + 8 = 17) Sum of the upper half (1 + 2 + 3) = 6 Sum of the Lower half (2 + 4) = 6 Input: 10 / \ 20 30 / \ \ 4 5 1 Output: YES Explanation: The maximum sum level is 1 and its sum is (20 + 30 = 50) Sum of the upper half (10) = 10 Sum of the lower half (5 + 4 + 1) = 10
Approach: The idea is to use level order traversal to compute the sum of every level of the binary tree. Then, find the maximum sum of all the levels. Finally, check that the total sum of all the levels less than the maximum level sum is equal to the total sum of the levels of the greater than the maximum level sum.
Below is the implementation of the above approach:
C++
// C++ implementation to check if // maximum level sum divides the // Binary tree into two equal sum halves #include <bits/stdc++.h> using namespace std; // Structure of the node struct Node { int data; struct Node *left, *right; }; // Utility function to // create a new node struct Node* newNode( int x) { struct Node* temp = new Node; temp->data = x; temp->left = temp->right = NULL; return temp; }; // Function to check if // maximum level sum divides the // Binary tree into two equal sum halves bool check_horizontal( struct Node* root) { // Vector used to store the sum // of all levels of the Binary Tree vector< int > sumLevel; // In index variable we store the // level of the maximum level sum int index = -1, maxSum = 0, level = 0; queue<Node*> q; q.push(root); while (!q.empty()) { // Varible to store the // current level sum. int sum = 0; // Size of the Queue int n = q.size(); // Loop to iterate over the // elements nodes of current level for ( int i = 0; i < n; i++) { // Inserting the next level // elements to the Queue Node* temp = q.front(); sum += temp->data; if (temp->left != NULL) q.push(temp->left); if (temp->right != NULL) q.push(temp->right); // Popping out the current // level element from the Queue q.pop(); } // Storing the current level // sum into the vector sumLevel.push_back(sum); // Level of maximum // horizontal sum line if (sum > maxSum) { maxSum = sum; index = level; } level++; } // Find the left half and right // half sum and check if they are equal int leftSum = 0, rightSum = 0; for ( int i = 0; i < index; i++) { leftSum += sumLevel[i]; } for ( int i = index + 1; i < sumLevel.size(); i++) { rightSum += sumLevel[i]; } return (leftSum == rightSum); } // Driver Code int main() { struct Node* root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); root->right->right = newNode(8); root->right->right->left = newNode(2); root->right->right->right = newNode(4); // Condition to check if the // maxumum sum level divides // it into two equal half if (check_horizontal(root)) cout << "YES" << endl; else cout << "NO" << endl; } |
Java
// Java implementation to check if // maximum level sum divides the // Binary tree into two equal sum halves import java.util.*; class GFG{ // Structure of the node static class Node { int data; Node left, right; }; // Utility function to // create a new node static Node newNode( int x) { Node temp = new Node(); temp.data = x; temp.left = temp.right = null ; return temp; }; // Function to check if maximum // level sum divides the Binary // tree into two equal sum halves static boolean check_horizontal(Node root) { // Vector used to store the sum // of all levels of the Binary Tree Vector<Integer> sumLevel = new Vector<Integer>(); // In index variable we store the // level of the maximum level sum int index = - 1 , maxSum = 0 , level = 0 ; Queue<Node> q = new LinkedList<Node>(); q.add(root); while (!q.isEmpty()) { // Varible to store the // current level sum. int sum = 0 ; // Size of the Queue int n = q.size(); // Loop to iterate over the // elements nodes of current level for ( int i = 0 ; i < n; i++) { // Inserting the next level // elements to the Queue Node temp = q.peek(); sum += temp.data; if (temp.left != null ) q.add(temp.left); if (temp.right != null ) q.add(temp.right); // Popping out the current // level element from the Queue q.remove(); } // Storing the current level // sum into the vector sumLevel.add(sum); // Level of maximum // horizontal sum line if (sum > maxSum) { maxSum = sum; index = level; } level++; } // Find the left half and right // half sum and check if they are equal int leftSum = 0 , rightSum = 0 ; for ( int i = 0 ; i < index; i++) { leftSum += sumLevel.get(i); } for ( int i = index + 1 ; i < sumLevel.size(); i++) { rightSum += sumLevel.get(i); } return (leftSum == rightSum); } // Driver Code 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.right = newNode( 8 ); root.right.right.left = newNode( 2 ); root.right.right.right = newNode( 4 ); // Condition to check if the // maxumum sum level divides // it into two equal half if (check_horizontal(root)) System.out.print( "YES" + "\n" ); else System.out.print( "NO" + "\n" ); } } // This code is contributed by Amit Katiyar |
Python3
# Python 3 implementation to # check if maximum level sum # divides the Binary tree into # two equal sum halves # Structure of the node class newNode: def __init__( self , x): self .data = x self .left = None self .right = None # Function to check if # maximum level sum divides # the Binary tree into two # equal sum halves def check_horizontal(root): # Vector used to store the sum # of all levels of the Binary Tree sumLevel = [] # In index variable we store the # level of the maximum level sum index = - 1 maxSum = 0 level = 0 q = [] q.append(root) while ( len (q)): # Varible to store the # current level sum. sum = 0 # Size of the Queue n = len (q) # Loop to iterate over the # elements nodes of current # level for i in range (n): # Inserting the next level # elements to the Queue temp = q[ 0 ] sum + = temp.data if (temp.left ! = None ): q.append(temp.left) if (temp.right ! = None ): q.append(temp.right) # Popping out the current # level element from the # Queue q.remove(q[ 0 ]) # Storing the current level # sum into the vector sumLevel.append( sum ) # Level of maximum # horizontal sum line if ( sum > maxSum): maxSum = sum index = level level + = 1 # Find the left half and right # half sum and check if they # are equal leftSum = 0 rightSum = 0 for i in range (index): leftSum + = sumLevel[i] for i in range (index + 1 , len (sumLevel), 1 ): rightSum + = sumLevel[i] return (leftSum = = rightSum) # Driver Code if __name__ = = '__main__' : root = newNode( 1 ) root.left = newNode( 2 ) root.right = newNode( 3 ) root.left.left = newNode( 4 ) root.left.right = newNode( 5 ) root.right.right = newNode( 8 ) root.right.right.left = newNode( 2 ) root.right.right.right = newNode( 4 ) # Condition to check if the # maxumum sum level divides # it into two equal half if (check_horizontal(root)): print ( "YES" ) else : print ( "NO" ) # This code is contributed by SURENDRA_GANGWAR |
C#
// C# implementation to check if // maximum level sum divides the // Binary tree into two equal sum halves using System; using System.Collections.Generic; class GFG{ // Structure of // the node public class Node { public int data; public Node left, right; }; // Utility function to // create a new node static Node newNode( int x) { Node temp = new Node(); temp.data = x; temp.left = temp.right = null ; return temp; } // Function to check if maximum // level sum divides the Binary // tree into two equal sum halves static bool check_horizontal(Node root) { // List used to store the sum // of all levels of the Binary Tree List< int > sumLevel = new List< int >(); // In index variable we store the // level of the maximum level sum int index = -1, maxSum = 0, level = 0; Queue<Node> q = new Queue<Node>(); q.Enqueue(root); while (q.Count != 0) { // Varible to store the // current level sum. int sum = 0; // Size of the Queue int n = q.Count; // Loop to iterate over the // elements nodes of current level for ( int i = 0; i < n; i++) { // Inserting the next level // elements to the Queue Node temp = q.Peek(); sum += temp.data; if (temp.left != null ) q.Enqueue(temp.left); if (temp.right != null ) q.Enqueue(temp.right); // Popping out the current // level element from the Queue q.Dequeue(); } // Storing the current level // sum into the vector sumLevel.Add(sum); // Level of maximum // horizontal sum line if (sum > maxSum) { maxSum = sum; index = level; } level++; } // Find the left half and right // half sum and check if they are equal int leftSum = 0, rightSum = 0; for ( int i = 0; i < index; i++) { leftSum += sumLevel[i]; } for ( int i = index + 1; i < sumLevel.Count; i++) { rightSum += sumLevel[i]; } return (leftSum == rightSum); } // Driver Code 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.right = newNode(8); root.right.right.left = newNode(2); root.right.right.right = newNode(4); // Condition to check if the // maxumum sum level divides // it into two equal half if (check_horizontal(root)) Console.Write( "YES" + "\n" ); else Console.Write( "NO" + "\n" ); } } // This code is contributed by Rajput-Ji |
YES
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.