Question

我正在编写一个函数，它将帮助我计算树状数据结构的最长子路径。到目前为止，我所写的内容使用递归方法“挖掘”到每个子分支中-基本上是深度优先搜索。我对tree的控制并不多，它只是一个Map，其中每个键是一个节点，每个键的值是该键指向的节点列表。

例如tree地图可以具有：

"start" => ["1"]
"1" => ["2"]
"2" => ["3", "4"]
"3" => ["5"]
"4" => ["end"]
"5" => ["end"]

我相信我下面编写的代码通过用树中所有子路径的长度填充subLengths列表解决了我的问题。接下来，我要做的就是减少subLengths的长度。

private void calculateAllSubPathLengths(String start, Map<String, List<String>> tree, int pathLength, List<Integer> subLengths){
    pathLength++;
    for(String connectedNode: tree.get(start)) {
        if(connectedNode.equals("end")) {
            subLengths.add(pathLength);
            return;
        }

        calculateAllSubPathLengths(connectedNode, tree, pathLength, subLengths);
    }
}

我将此函数称为：

int pathLength = 0;
List<Integer> subLengths = new ArrayList<>();
calculateAllSubPathLengths("start", tree, pathLength, subLengths);
// Get max from the subLengths list and move on with the rest of my logic

我对tree映射中的数据没有太多控制，并且它没有像二进制树那样的任何传统树，如属性。树中的节点可以有很多分支，并且可以嵌套很多层。但是，考虑到我的问题领域，这极不可能。但是，我想确保我的代码将来可以处理更复杂的树。

我发布此问题是因为我的直觉是我没有正确执行此操作。我的问题是：

有什么办法可以避免使用subLengths列表？
是否有一种方法可以将此递归函数转换为交互式函数？如果没有，我可能会添加某种条件，一旦达到某个“深度”，该条件就会停止该功能。
我是否违反了其他递归“最佳实践”？

Answer 1

您的代码具有一些未定义的变量：links应该是tree，而subPathLengths应该是subLengths。

除了这些问题外，该代码似乎适用于这种情况（最长路径为5），因此我将解决您的问题并指出您的代码失败的情况。在整个过程中，我假设您的树实际上是一棵树（即非循环的）。

这似乎是可以接受的方法。您的函数名称为calculateAllSubPathLengths，因此该列表似乎适合存储所有路径。如果只想要最长的时间（似乎是这种情况），请为您的函数添加一个返回值，并将运行最佳的时间作为参数而不是subLengths传递。您也可以使用单元素int[] best传递“按引用”，这避免了一些比较，但会引起语义问题。

当然，您可以使用显式堆栈进行迭代操作，该堆栈包含您通常传递给递归函数的参数。这是一种方法：

class Pair<K, V> {
    K first;
    V second;

    public Pair(K first, V second) {
        this.first = first;
        this.second = second;
    }
}

private static int longestPath(HashMap<String, List<String>> tree) {
    Stack<Pair<String, Integer>> stack = new Stack<>();
    stack.push(new Pair<String, Integer>("start", 0));
    int best = 0;

    while (!stack.isEmpty()) {
        Pair<String, Integer> current = stack.pop();

        if (current.first.equals("end")) {
            best = Math.max(current.second, best);
        }
        else {
            for (String child : tree.get(current.first)) {
                stack.push(
                    new Pair<String, Integer>(child, current.second + 1)
                );
            }
        }
    }

    return best;
}

Try it!

以下是递归函数的一些“最佳实践”建议：
- 您的实现迫使调用者对本质上是递归函数本地的多个变量负责。编写一个帮助程序方法来封装这些变量，以为调用方提供一个干净的calculateAllSubPathLengths(tree);选项。
- 在函数顶部增加pathLength并测试connectedNode.equals("end")似乎与将每个节点或状态视为单个实体是违反直觉的。您的函数会问：“当前节点的这个邻居是终点吗？”和“增加路径，然后分析当前节点”时，似乎更语义地询问“此节点是终点吗？”和“分析当前节点，然后在我们移动到邻居时增加路径”。这也具有逻辑意义。例如，如果起始节点是终止节点，则您的代码将失败。
将这些项目放在一起，可以进行以下重构：
```
private static int longestPath(Map<String, List<String>> tree) {
    return longestPath("start", tree, 0, 0);
}

private static int longestPath(
    String current, Map<String, List<String>> tree, 
    int pathLength, int best
) {
    if (current.equals("end")) {
        return Math.max(pathLength, best);
    }

    for (String child : tree.get(current)) {
        best = Math.max(
            best, longestPath(child, tree, pathLength + 1, best)
        );
    }

    return best;
}
```
Try it!

即使在这里，也有很多需要改进和推广的领域。例如，硬编码"start"和"end"状态会破坏可重用性。

获取树状结构的最长子路径

1 个答案: