LeetCode43|最大层内元素和

示例：
输入：[1,7,0,7,-8,null,null]
输出：2
解释：
第 1 层各元素之和为 1，
第 2 层各元素之和为 7 + 0 = 7，
第 3 层各元素之和为 7 + -8 = -1，
所以我们返回第 2 层的层号，它的层内元素之和最大。
 

提示：
树中的节点数介于 1 和 10^4 之间
-10^5 <= node.val <= 10^5

package com.wpw.niuketest;

import java.util.*;

public class MaxLevelSumTest {
    public static void main(String[] args) {
        TreeNode t1 = new TreeNode(1);
        TreeNode t2 = new TreeNode(7);
        TreeNode t3 = new TreeNode(0);
        TreeNode t4 = new TreeNode(7);
        TreeNode t5 = new TreeNode(-8);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t3.right = t5;
        int maxLevelSum = maxLevelSum3(t1);
        System.out.println("maxLevelSum = " + maxLevelSum);
    }

    public static int maxLevelSum(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> listList = new ArrayList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                list.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            listList.add(list);
        }
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        int level = 1;
        for (List<Integer> list : listList
        ) {
            Optional<Integer> reduce = list.stream().filter(Objects::nonNull).reduce(Integer::sum);
            Integer integer = reduce.get();
            hashMap.put(level, integer);
            level++;

        }
        Integer maxValue = hashMap.values().stream().min(Comparator.reverseOrder()).get();
        return hashMap.entrySet().stream().filter(x -> x.getValue().equals(maxValue)).map(Map.Entry::getKey).findFirst().orElse(0);

    }

    public static int maxLevelSum2(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        queue.add(root);
        int level = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            int currentLevelSum = 0;
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                currentLevelSum += node.val;
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            hashMap.put(level, currentLevelSum);
            level++;
        }
        Integer maxValue = hashMap.values().stream().max(Comparator.naturalOrder()).get();
        return hashMap.entrySet().stream().filter(x -> x.getValue().equals(maxValue)).map(Map.Entry::getKey).findFirst().orElse(0);


    }

    public static int maxLevelSum3(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int level = 0;
        int maxLevel = 0;
        int maxSum = Integer.MIN_VALUE;
        while (!queue.isEmpty()) {

            maxLevel++;
            int size = queue.size();
            int currentLevelSum = 0;
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                currentLevelSum += node.val;
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            if (currentLevelSum > maxSum) {
                level = maxLevel;
                maxSum = currentLevelSum;
            }
        }
        return level;


    }

}