给定一棵二叉树，任务是检查最大和级别是否将二叉树分成两个相等的和一半的两部分。
例子：
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
方法：思想是使用层序遍历来计算二叉树的每一层的总和。然后，找到所有级别的最大总和。最后，检查小于最大水平总和的所有水平总和是否等于大于最大水平总和的水平总和。
下面是上述方法的实现：
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 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 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()) {
// 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 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())
{
// 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_GANGWARC#
// 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 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)
{
// 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
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live