如何检查树中给定路径的总和是否存在

Question

我想检查从起始节点到任何路径中的值的总和

叶节点存在。

例如，假设我的 startNode 是 7，而 sumTarget 是 15，如果树是：

        a-7
  b - 1    e- 8
  c - 2    
  d -9 

那么由于 7 +8 等于 15 它会返回 true

如果我有 b 作为 startNode，12 作为 sumTotal，那么它也会返回 true，因为 1 +2 + 9 是 12，从 b 开始。

class Node {
    int value;
    Node [] children
}

我不认为这是对的，但我不确定哪里错了。

def doesSumExist(startNode, sumTarget, currentSum):
    totalSum = sumTarget
    if startNode is not Null:
        if totalSum + startNode.value == sumTarget:
            return True
        else:
            totalSum += startNode.value
    else:
        Node startNode = doesSumExist(startNode.left, sumTarget, currentSum)  
        if startNode is not Null:
            return currentSum
        startNode = doesSumExist(startNode.right, sumTarget,currentSum)
    return False

Answer 1

在这种情况下，我认为您要搜索的内容类似于以下内容：

def doesSumExist(startNode, sumTarget, currentSum):
    totalSum = currentSum
    if startNode is not Null:
        if totalSum + startNode.value == sumTarget: #If this node completes the sum
            return True
        else: #if not
            totalSum += startNode.value #increase current sum
    if doesSumExist(startNode.left, sumTarget, totalSum): #recursive starting on the left children
        return True
    elif doesSumExist(startNode.right, sumTarget, totalSum): #recursive starting on the right children
        return True           
    return False #if the sum is not present (starting in startNode).

但是，这不会检查任何连续的节点组合是否包含总和（代码会复杂得多）。

希望对你有帮助

Answer 2

假设你的节点类看起来像这样：

class Node:
    def __init__(self, value = 0, children = None):
        self.value = value
        self.children = [] if children is None else children

那么这个方法应该可以解决问题：

def doesSumExist(startNode, targetSum, currentSum):
    if startNode is None:
        return False
    currentSum += startNode.value
    if currentSum == targetSum:
        return True
    for child in startNode.children:
        if doesSumExist(child, targetSum, currentSum):
            return True
    return False

请注意，对于这个节点类设计，startNode 的无检查对于递归来说并不是真正必要的，而只是对于入口点而言。所以这可能会更好：

def doesSumExist(startNode, targetSum):
    def inner(node, targetSum, currentSum):
        currentSum += node.value
        if currentSum == targetSum:
            return True
        #for people who like to save a few lines
        #return any(inner(child, targetSum, currentSum) for child in node.children)
        for child in node.children:
            if inner(child, targetSum, currentSum):
                return True
        return False

    if startNode is None:
        return False
    return inner(startNode, targetSum, 0)

编辑： 如果您不仅想知道总和是否存在于起始节点的路径中，而且还想知道它是否存在于任何给定的子路径中，这应该可行：

def doesSumExist(startNode, targetSum):
    def inner(node, targetSum, allValues):
        allValues.append(node.value)
        currentSum = 0
        for val in reversed(allValues):
            currentSum += val
            if currentSum == targetSum:
                return True
        for child in node.children:
            if inner(child, targetSum, allValues):
                return True
        allValues.pop()
        return False

    if startNode is None:
        return False
    return inner(startNode, targetSum, [])