感谢我使用以下解决方案所做的每一个人：

public List<Integer> levelOrder(Node node){
    List<Integer> result = new ArrayList<>();
    Queue<Node> queue = new LinkedList<Node>();
    queue.add(node);
    while(!queue.isEmpty()) {
        int size = queue.size();
        List<Integer> currentLevel = new ArrayList<Integer>();
        for(int i=0;i<size;i++) {
            Node current = queue.remove();
                currentLevel.add(current.val);
                for(Integer inte:currentLevel) {
                    System.out.println(inte);
                }

        if(current.children !=null) {
            for(Node node1:current.children)
            queue.add(node1);
        }
        }
      result.add(Collections.max(currentLevel));  
    }
return result;
}

我们可以通过水平顺序遍历/广度优先搜索得到水平最大值。我们的想法是在一个级别上有一个节点列表/队列。对于此列表中的所有节点，算法执行两个操作：
它计算此级别上的最大值。
它遍历列表/队列的所有节点，获取这些节点的所有子节点，并将它们放入一个新的列表/队列中，然后在下一次迭代中进行处理。
该算法从包含（子树）根的列表/队列开始，在列表/队列为空时结束。
这可以用 Stream 操作：

public static List<Integer> getMaxValuePerLevel(Node node) {
    final ArrayList<Integer> maxPerLevel = new ArrayList();
    maxPerLevel.add(node.getValue());
    List<Node> children = node.getChildren();
    while (!children.isEmpty()) {
        maxPerLevel.add(children.stream()
                .mapToInt(Node::getValue)
                .max()
                .getAsInt());
        children = children.stream()
                .map(Node::getChildren)
                .flatMap(List::stream)
                .collect(Collectors.toList());
    }
    return maxPerLevel;
}

ideone演示
这个实现有两个很好的特性：
它是迭代的，而不是递归的，即算法不受 StackOverflowError 它具有线性时间和内存复杂性
通过一点努力，我们甚至可以使算法与泛型一起工作 Node<T extends Comparable<T>> :

public static <T extends Comparable<T>> List<T> getMaxValuePerLevel(Node<T> node) {
    final ArrayList<T> maxPerLevel = new ArrayList<>();
    maxPerLevel.add(node.getValue());
    List<Node<T>> children = node.getChildren();
    while (!children.isEmpty()) {
        final Node<T> defaultNode = children.get(0);
        maxPerLevel.add(children.stream()
                .map(Node::getValue)
                .max(Comparator.naturalOrder())
                .orElseGet(defaultNode::getValue));
        children = children.stream()
                .map(Node::getChildren)
                .flatMap(List::stream)
                .collect(Collectors.toList());
    }
    return maxPerLevel;
}

ideone演示

根节点将是其级别的最高节点。对于后续级别，请调用 Collections.sort() （或将对列表进行排序的任何其他比较）并取最后一个元素（或根据所用排序方法具有最高值的元素）。然后遍历刚刚排序的子节点列表，对于每个节点，对其子节点列表应用相同的处理方法。

递归解决方案非常简单。首先创建一个列表来保存结果。然后遍历所有节点：在每个节点上，将节点的值与同一级别的列表中的值进行比较。如果节点的值更大，则替换列表中的值。

class Node {
    public int val;
    public List<Node> children;

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }

    public List<Integer> getMaxPerLevel() {
        List<Integer> levels = new ArrayList<>();
        getMaxPerLevel(0, levels);
        return levels;
    }

    private void getMaxPerLevel(int level, List<Integer> levels) {
        if (level >= levels.size()) {
            levels.add(level, val);
        } else {
            levels.set(level, Math.max(val, levels.get(level)));
        }
        for (Node child : children) {
            child.getMaxPerLevel(level + 1, levels);
        }
    }
}