有没有更好的方法来退出递归？

如何解决有没有更好的方法来退出递归？

我有这个功能：

class Solution:
def __init__(self):
        self.flag = False


def hasPathSum(self,root: TreeNode,targetSum: int) -> bool:
    curr_sum = 0            

    
    def dfs(root,curr_sum,target_sum=targetSum):
        if self.flag == True:
            return True
        if root == None:
            return 0
        print(root.val)
        curr_sum += root.val
        print(curr_sum)
        if curr_sum == target_sum:
            self.flag = True
        dfs(root.left,curr_sum)
        dfs(root.right,curr_sum)
    dfs(root,targetSum)
    if self.flag == True:
        return True
    return False

当树具有总和等于 target_sum 的根到叶路径时，我想结束递归并获得 True。我设法通过添加 dunder 方法 init 并将 there 标志设置为 False 来做到这一点，我在满足要求时切换该标志。 但在我看来，它感觉有点不干净也不漂亮。 我应该如何以更干净的方式进行操作？

解决方法

无论是否达到当前总和，您都可以让 dfs 函数返回。这是我正在谈论的一些示例代码：

def hasPathSum(self,root: TreeNode,targetSum: int) -> bool:
    curr_sum = 0            

    
    def dfs(root,curr_sum,target_sum=targetSum):
        if root == None:
            return 0
        print(root.val)
        curr_sum += root.val
        print(curr_sum)
        if curr_sum == target_sum:
            return = True
        return dfs(root.left,curr_sum) or dfs(root.right,curr_sum)
    return dfs(root,targetSum)

,

如何使用方法参数来跟踪当前总和。

class TreeNode:
    def __init__(self,right,left,value):
        self.right = right
        self.left = left
        self.value = value


def solution(root: TreeNode,target_sum: int) -> bool:
    def _solution(node: TreeNode,running_sum: int) -> bool:
        if node is None:
            return False

        running_sum += root.value

        if target_sum == running_sum:
            return True
        return _solution(root.left,running_sum) or _solution(root.right,running_sum)
    
    return _solution(root,0)

,

您根本不需要 Solution 类（强制一切都成为类是您在 Python 代码中不需要的 Java 主义），并且您的函数应该 return值而不是将其粘贴在外部变量中。

递归函数的一般模式是：

• 检查基本情况，如果满足立即返回解决方案
• 否则，使用修改后的参数返回再次调用该函数的结果，使您更接近基本情况。

def has_path_sum(self,target_sum: int) -> bool:
    """Returns whether any path through the tree 
    has values that sum to *exactly* target_sum."""
    def dfs(node: TreeNode,curr_sum: int) -> bool:
        """DFS helper that tracks sum of all nodes traversed."""
        # Base case: return False if we run out of nodes.
        if node is None:
            return False
        curr_sum += node.val
        return (
            # Base case: return True if we hit the target sum.
            curr_sum == target_sum
            # Otherwise,recurse into left and right subtrees.
            or dfs(node.left,curr_sum)
            or dfs(node.right,curr_sum)
        )

    return dfs(root,0)

注意在 DFS 帮助器的最后一部分中使用了 or——一旦 or 的任何一个子句为 True（按顺序），它就会立即返回，因此：

        return (
            # Base case: return True if we hit the target sum.
            curr_sum == target_sum
            # Otherwise,curr_sum)
        )

只是一种更好/更短的说法：

        # Base case: return True if we hit the target sum.
        if curr_sum == target_sum:
            return  True
        # Otherwise,recurse into left and right subtrees.
        elif dfs(node.left,curr_sum):
            return True
        elif dfs(node.right,curr_sum):
            return True
        else:
            return False