给定具有正节点和负节点的二叉树，任务是找到其中级别和的最大绝对差。
例子：
Input:
4
/ \
2 -5
/ \ / \
-1 3 -2 6
Output: 9
Explanation:
Sum of all nodes of 0 level is 4
Sum of all nodes of 1 level is -3
Sum of all nodes of 2 level is 6
Hence maximum absolute difference
of level sum = 9 (6 - (-3))
Input:
1
/ \
2 3
/ \ \
4 5 8
/ \
6 7
Output: 16
方法：求最大电平总和的最大绝对差，我们只需要求最大电平总和和最小电平总和，因为最大和最小电平总和的绝对差总是给我们最大绝对差，即
Maximum absolute difference = abs(Maximum level sum – Minimum level sum)
以下是上述观察算法的步骤：
- 这个想法是对树进行级别顺序遍历。
- 在做遍历的时候，分别处理不同层次的节点。
- 对于正在处理的每个级别，计算级别中节点的总和并跟踪最大和最小级别总和。
- 然后返回最大和最小水平总和的绝对差。
下面是上述方法的实现：
C++
// C++ program to find the maximum
// absolute difference of level
// sum in Binary Tree
#include
using namespace std;
// Class containing left and
// right child of current
// node and key value
struct Node
{
int data;
Node *left, *right;
};
Node *newNode(int data)
{
Node *node = new Node();
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
// Function to find the maximum
// absolute difference of level
// sum in binary tree
// using level order traversal
int maxAbsDiffLevelSum(Node *root)
{
// Initialize value of maximum
// and minimum level sum
int maxsum = INT_MIN;
int minsum = INT_MAX;
queue qu;
qu.push(root);
// Do Level order traversal
// keeping track of number
// of nodes at every level.
while (!qu.empty())
{
// Get the size of queue when
// the level order traversal
// for one level finishes
int sz = qu.size();
// Iterate for all the nodes in
// the queue currently
int sum = 0;
for(int i = 0; i < sz; i++)
{
// Dequeue an node from queue
Node *t = qu.front();
qu.pop();
// Add this node's value to
// the current sum.
sum += t->data;
// Enqueue left and
// right children of
// dequeued node
if (t->left != NULL)
qu.push(t->left);
if (t->right != NULL)
qu.push(t->right);
}
// Update the maximum
// level sum value
maxsum = max(maxsum, sum);
// Update the minimum
// level sum value
minsum = min(minsum, sum);
}
// return the maximum absolute
// difference of level sum
return abs(maxsum - minsum);
}
// Driver code
int main()
{
Node *root = new Node();
root = newNode(4);
root->left = newNode(2);
root->right = newNode(-5);
root->left->left = newNode(-1);
root->left->right = newNode(3);
root->right->left = newNode(-2);
root->right->right = newNode(6);
/* Constructed Binary tree is:
4
/ \
2 -5
/ \ / \
-1 3 -2 6 */
cout << maxAbsDiffLevelSum(root) << endl;
}
// This code is contributed by sanjeev2552 Java
// Java program to find the maximum
// absolute difference of level
// sum in Binary Tree
import java.util.*;
// Class containing left and
// right child of current
// node and key value
class Node {
int data;
Node left, right;
public Node(int item)
{
data = item;
left = right = null;
}
}
class BinaryTree {
// Root of the Binary Tree
Node root;
public BinaryTree()
{
root = null;
}
// Function to find
// the maximum absolute
// difference of level
// sum in binary tree
// using level order traversal
public int maxAbsDiffLevelSum()
{
// Initialize value of maximum
// and minimum level sum
int maxsum = Integer.MIN_VALUE;
int minsum = Integer.MAX_VALUE;
Queue qu = new LinkedList<>();
qu.offer(root);
// Do Level order traversal
// keeping track of number
// of nodes at every level.
while (!qu.isEmpty()) {
// Get the size of queue when
// the level order traversal
// for one level finishes
int sz = qu.size();
// Iterate for all the nodes in
// the queue currently
int sum = 0;
for (int i = 0; i < sz; i++) {
// Dequeue an node from queue
Node t = qu.poll();
// Add this node's value to
// the current sum.
sum += t.data;
// Enqueue left and
// right children of
// dequeued node
if (t.left != null)
qu.offer(t.left);
if (t.right != null)
qu.offer(t.right);
}
// Update the maximum
// level sum value
maxsum = Math.max(maxsum, sum);
// Update the minimum
// level sum value
minsum = Math.min(minsum, sum);
}
// return the maximum absolute
// difference of level sum
return Math.abs(maxsum - minsum);
}
// Driver code
public static void main(String[] args)
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(4);
tree.root.left = new Node(2);
tree.root.right = new Node(-5);
tree.root.left.left = new Node(-1);
tree.root.left.right = new Node(3);
tree.root.right.left = new Node(-2);
tree.root.right.right = new Node(6);
/* Constructed Binary tree is:
4
/ \
2 -5
/ \ / \
-1 3 -2 6 */
System.out.println(
tree.maxAbsDiffLevelSum());
}
} Python3
# Python 3 program to find
# the maximum absolute difference
# of level sum in Binary Tree
import sys
# Class containing left and
# right child of current
# node and key value
class newNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Function to find the maximum
# absolute difference of level
# sum in binary tree
# using level order traversal
def maxAbsDiffLevelSum(root):
# Initialize value of maximum
# and minimum level sum
maxsum = -sys.maxsize - 1
minsum = sys.maxsize
qu = []
qu.append(root)
# Do Level order traversal
# keeping track of number
# of nodes at every level.
while (len(qu) > 0):
# Get the size of queue when
# the level order traversal
# for one level finishes
sz = len(qu)
# Iterate for all the nodes in
# the queue currently
sum = 0
for i in range(sz):
# Dequeue an node from
# queue
t = qu[0]
qu.remove(qu[0])
# Add this node's value
# to the current sum.
sum += t.data
# Enqueue left and
# right children of
# dequeued node
if (t.left != None):
qu.append(t.left)
if (t.right != None):
qu.append(t.right)
# Update the maximum
# level sum value
maxsum = max(maxsum, sum)
# Update the minimum
# level sum value
minsum = min(minsum, sum)
# return the maximum absolute
# difference of level sum
return abs(maxsum - minsum)
# Driver code
if __name__ == '__main__':
root = newNode(4)
root.left = newNode(2)
root.right = newNode(-5)
root.left.left = newNode(-1)
root.left.right = newNode(3)
root.right.left = newNode(-2)
root.right.right = newNode(6)
'''/* Constructed Binary tree is:
4
/ \
2 -5
/ / / \
-1 3 -2 6 */
'''
print(maxAbsDiffLevelSum(root))
# This code is contributed by SURENDRA_GANGWARC#
// C# program to find the maximum
// absolute difference of level
// sum in Binary Tree
using System;
using System.Collections.Generic;
// Class to represent Tree node
public class Node
{
public int data;
public Node left, right;
public Node(int item)
{
data = item;
left = null;
right = null;
}
}
class BinaryTree{
Node root;
// Function to find the maximum
// absolute difference of level
// sum in binary tree
// using level order traversal
public int maxAbsDiffLevelSum()
{
// Initialize value of maximum
// and minimum level sum
int maxsum = Int32.MinValue;
int minsum = Int32.MaxValue;
Queue qu = new Queue();
qu.Enqueue(root);
// Do Level order traversal
// keeping track of number
// of nodes at every level.
while (qu.Count != 0)
{
// Get the size of queue when
// the level order traversal
// for one level finishes
int sz = qu.Count;
// Iterate for all the nodes in
// the queue currently
int sum = 0;
for(int i = 0; i < sz; i++)
{
// Dequeue an node from queue
Node t = qu.Dequeue();
// Add this node's value to
// the current sum.
sum += t.data;
// Enqueue left and
// right children of
// dequeued node
if (t.left != null)
qu.Enqueue(t.left);
if (t.right != null)
qu.Enqueue(t.right);
}
// Update the maximum
// level sum value
maxsum = Math.Max(maxsum, sum);
// Update the minimum
// level sum value
minsum = Math.Min(minsum, sum);
}
// Return the maximum absolute
// difference of level sum
return Math.Abs(maxsum - minsum);
}
// Driver code
static public void Main ()
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(4);
tree.root.left = new Node(2);
tree.root.right = new Node(-5);
tree.root.left.left = new Node(-1);
tree.root.left.right = new Node(3);
tree.root.right.left = new Node(-2);
tree.root.right.right = new Node(6);
/* Constructed Binary tree is:
4
/ \
2 -5
/ \ / \
-1 3 -2 6 */
Console.WriteLine(tree.maxAbsDiffLevelSum());
}
}
// This code is contributed by offbeat 输出：
9
时间复杂度： O(N)
辅助空间： O(N)
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live