Open In App

Check if max sum level of Binary tree divides tree into two equal sum halves

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 using namespace std; // Structure of the nodestruct Node {    int data;    struct Node *left, *right;}; // Utility function to// create a new nodestruct 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 halvesbool check_horizontal(struct Node* root){    // Vector used to store the sum    // of all levels of the Binary Tree    vector sumLevel;         // In index variable we store the    // level of the maximum level sum    int index = -1, maxSum = 0, level = 0;     queue q;    q.push(root);     while (!q.empty()) {                 // Variable 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 Codeint 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    // maximum 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 halvesimport java.util.*; class GFG{ // Structure of the nodestatic class Node{    int data;    Node left, right;}; // Utility function to// create a new nodestatic 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 halvesstatic boolean check_horizontal(Node root){         // Vector used to store the sum    // of all levels of the Binary Tree    Vector sumLevel = new Vector();         // In index variable we store the    // level of the maximum level sum    int index = -1, maxSum = 0, level = 0;     Queue q = new LinkedList();    q.add(root);     while (!q.isEmpty())    {                 // Variable 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 Codepublic 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    // maximum 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 nodeclass 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 halvesdef 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)):               # Variable 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 Codeif __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    # maximum 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 halvesusing System;using System.Collections.Generic;class GFG{ // Structure of// the nodepublic class Node{  public int data;  public Node left, right;}; // Utility function to// create a new nodestatic 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 halvesstatic bool check_horizontal(Node root){  // List used to store the sum  // of all levels of the Binary Tree  List sumLevel = new List();   // In index variable we store the  // level of the maximum level sum  int index = -1, maxSum = 0, level = 0;   Queue q = new Queue();  q.Enqueue(root);   while (q.Count != 0)  {    // Variable 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 Codepublic 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  // maximum 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

Javascript



Output:

YES

Time complexity: O(n), where n is the number of nodes in the binary tree.

Auxiliary space: O(m), where m is the maximum number of nodes at any level in the binary tree.