数据结构在N元树的每个级别上获得最大值

问题描述

让我们说我有一棵n元树，如下所示，我需要在每个级别上找到最大值并返回： [8,7,32]。

                        8
             4          3          7
         1   4 3    3  5 6 7    12 32 3 1

我的节点如下所示： 公共类Node {

public int val;
public List<Node> children;


public Node() {
    
}

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

我尝试通过递归在每个级别上获取元素并找到最大值，但无法这样做。

解决方法

我们可以通过level order traversal / Breadth-first search获得最高水平。这个想法是我们在一个级别上有一个节点列表/队列。对于此列表中的所有节点，该算法都执行以下两项操作：

1. 它在此级别上计算最大值。
2. 迭代列表/队列的所有节点，获取这些节点的所有子节点，然后将它们放入新的列表/队列，然后可以在下一次迭代中进行处理。

该算法从包含（子）树根的列表/队列开始，到列表/队列为空时结束。

使用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 demo

此实现具有两个不错的属性：

• 它是迭代的，而不是递归的，即算法不受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 demo

,

根节点将是其最高级别。对于后续级别，请在子节点列表上调用c <- 1.5 d <- abs(cleandata$tempdiff[2:nrow(cleandata)] - cleandata$tempdiff[1:(nrow(cleandata)-1)]) d <- which(d > c) cleandata$tempdiff[d] <- NA d <- d + 1 cleandata$tempdiff[d] <- NA > cleandata TIMESTAMP sensor tempdiff 1 2020-07-16 11:02:00 TempDiffs.1. 10.45 2 2020-07-16 11:03:00 TempDiffs.1. 11.50 3 2020-07-16 11:04:00 TempDiffs.1. 10.52 4 2020-07-16 11:05:00 TempDiffs.1. 10.48 5 2020-07-16 11:06:00 TempDiffs.1. NA 6 2020-07-07 09:08:00 TempDiffs.2. NA 7 2020-07-07 09:09:00 TempDiffs.2. 12.48 8 2020-07-07 09:10:00 TempDiffs.2. 12.49 9 2020-07-07 09:11:00 TempDiffs.2. 12.50 10 2020-07-07 09:12:00 TempDiffs.2. 12.52 11 2020-07-07 09:13:00 TempDiffs.2. 12.52 （或将对列表进行排序的任何其他比较），并获取最后一个元素（或根据您使用的排序方法，取最大值的那个）。然后遍历刚刚排序的子节点列表，并对每个节点对其子列表进行相同的处理。

,

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

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);
        }
    }
}

,

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

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;
}