如何解决数据结构在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获得最高水平。这个想法是我们在一个级别上有一个节点列表/队列。对于此列表中的所有节点，该算法都执行以下两项操作：
- 它在此级别上计算最大值。
- 迭代列表/队列的所有节点，获取这些节点的所有子节点，然后将它们放入新的列表/队列，然后可以在下一次迭代中进行处理。
该算法从包含（子）树根的列表/队列开始，到列表/队列为空时结束。
使用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;
}
此实现具有两个不错的属性：
- 它是迭代的，而不是递归的，即算法不受
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;
}
根节点将是其最高级别。对于后续级别，请在子节点列表上调用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;
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
