leecode第11天

112.路径总和

第一个：

# 给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

# 叶子节点 是指没有子节点的节点。

# Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution(object):
	#生成
    def hasPathSum(self, root, targetSum):
        """
        :type root: Optional[TreeNode]
        :type targetSum: int
        :rtype: bool
        """
        # 如果根节点为空，直接返回 False
        if not root:
            return False

        # 如果当前节点是叶子节点，检查路径和是否等于目标值
        if not root.left and not root.right:
            return root.val == targetSum

        # 递归检查左子树和右子树
        return (self.hasPathSum(root.left, targetSum - root.val) or 
                self.hasPathSum(root.right, targetSum - root.val)

第二个：

    # def hasPathSum(self, root, targetSum):
    #     """
    #     :type root: Optional[TreeNode]
    #     :type targetSum: int
    #     :rtype: bool
    #     """
    #     if not root:
    #         return False     
    #  
    #     Sum_lst=[]
    #     def pathsum(node):
    #         if not node:
    #             Sum_lst.append(node.val)
    #         if node.left:
    #             node.left.val+=node.val
    #             pathsum(node.left)
    #         if node.right:
    #             node.right.val+=node.val
    #             pathsum(node.right)

    #     pathsum(root)
    #     for i in range(len(Sum_lst)):
    #         if Sum_lst[i]==targetSum:
    #             return True
    #         else:
    #             return False
    
	#自己
    def hasPathSum(self, root, targetSum):
        """
        :type root: Optional[TreeNode]
        :type targetSum: int
        :rtype: bool
        """
        if not root:
            return False

        Sum_lst = []

        def pathsum(node, current_sum):
            if not node:
                return

            current_sum += node.val#更新当前路径之和

            # 如果当前节点是叶子节点，检查路径和是否等于目标值【终止条件】
            if not node.left and not node.right:
                Sum_lst.append(current_sum)

            # 递归检查左子树和右子树
            pathsum(node.left, current_sum)
            pathsum(node.right, current_sum)

        pathsum(root, 0)

        for path_sum in Sum_lst:
            if path_sum == targetSum:
                return True

        return False

第三个【最快】：

	#leecode
    def hasPathSum(self, root, targetSum):
        """
        :type root: Optional[TreeNode]
        :type targetSum: int
        :rtype: bool
        """
        if root is None:
            return False     
        return self.traversal(root,targetSum-root.val)
    
    def traversal(self, root, count):
        """
        检查从根节点到叶节点的路径上，是否存在节点值之和等于给定值的路径。
    
        参数:
        root: 树的根节点。
        count: 目标节点值之和。
    
        返回:
        如果存在一条路径，其节点值之和等于给定值，则返回True；否则返回False。
        """
        # 检查是否到达叶节点，并且路径上的节点值之和等于给定值
        if (root.left is None and root.right is None and count == 0):
            return True
        
        # 检查是否到达叶节点，但路径上的节点值之和不等于给定值
        if (root.left is None and root.right is None and count != 0):
            return False
        
        # 递归遍历左子树
        if root.left:
            count -= root.left.val  # 从当前节点值中减去左子节点的值
            if self.traversal(root.left, count):  # 递归检查左子树是否存在满足条件的路径
                return True
            count += root.left.val  # 回溯，恢复当前节点值
        
        # 递归遍历右子树
        if root.right:
            count -= root.right.val  # 从当前节点值中减去右子节点的值
            if self.traversal(root.right, count):  # 递归检查右子树是否存在满足条件的路径
                return True
            count += root.right.val  # 回溯，恢复当前节点值
        
        return False

flowchart TD
    A[开始] --> B{是否为叶节点？}
    B -->|是| C{路径和是否为0？}
    C -->|是| D[返回True]
    C -->|否| E[返回False]
    B -->|否| F{是否有左子树？}
    F -->|是| G[更新count并递归左子树]
    G --> H{左子树是否满足？}
    H -->|是| I[返回True]
    H -->|否| J[回溯恢复count]
    F -->|否| K{是否有右子树？}
    K -->|是| L[更新count并递归右子树]
    L --> M{右子树是否满足？}
    M -->|是| N[返回True]
    M -->|否| O[回溯恢复count]
    K -->|否| P[返回False]