LeetCode——路径总和

LeetCode——路径总和

题目描述：
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例:
给定如下二叉树，以及目标和 sum = 22，

          5
         / \
        4   8
       /   / \
      11  13  4
     /  \      \
    7    2      1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/path-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法一：
我们用深度优先的方法解决这个问题。该函数的目标是找到一条从根节点到叶子节点的路径，使得这条路径总和等于sum。我们可以把这个问题看成是：假定根节点到当前节点的路径长度为val，判断当前节点的下一个节点到叶子节点的总和是否等于sum - val。可以看成是遍历每个节点的时候让sum减去该节点的val值。可以发现这满足递归的条件，我们在函数中判断当前节点是否为叶子节点，如果是叶子节点则判断是否满足sum等于该节点的val值，并将节点返回。如果不是叶子节点则继续向下递归。

解法二：
我们用广度优先的方法来解决这个问题，大概的思想就是，我们定义两个队列，一个用来存储树的节点（广度优先遍历），一个用来存储每个节点对应的到根节点的总长度。我们在遍历的过程中判断该节点是否是叶子节点，如果是叶子节点则看它对应的长度是否等于val，是则返回True，不是则继续遍历。当然，我们如果用Python做这个方法还可以用字典，将节点作为键，将其到根节点的长度作为值。

这里提供两种解法的Java和Python代码。

解法一Java代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null){
            return false;
        }
        if (root.left == null && root.right == null){
            return sum == root.val;
        }
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
    }
}

LeetCode测试结果：

解法二Java代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null){
            return false;
        }
        Queue<TreeNode> Node = new LinkedList<TreeNode>();
        Queue<Integer> Value = new LinkedList<Integer>();
        Node.offer(root);
        Value.offer(root.val);
        while (!Node.isEmpty()){
            TreeNode nowNode = Node.poll();
            int nowValue = Value.poll();
            if (nowNode.left == null && nowNode.right == null){
                if (nowValue == sum){
                    return true;
                }
                continue;
            }
            if (nowNode.left != null){
                Node.offer(nowNode.left);
                Value.offer(nowValue + nowNode.left.val);
            }
            if (nowNode.right != null){
                Node.offer(nowNode.right);
                Value.offer(nowValue + nowNode.right.val);
            }
        }
        return false;
    }
}

LeetCode测试结果：

解法一Python代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        if root is None:
            return False
        if root.left is None and root.right is None:
            return sum == root.val
        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)

LeetCode测试结果：

解法二Python代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        if root is None:
            return False
        Node = [root]
        Value = [root.val]
        while Node:
            nowNode = Node[0]
            nowValue = Value[0]
            del Node[0]
            del Value[0]
            if nowNode.left is None and nowNode.right is None:
                if nowValue == sum:
                    return True
                continue
            if nowNode.left is not None:
                Node.append(nowNode.left)
                Value.append(nowNode.left.val + nowValue)
            if nowNode.right is not None:
                Node.append(nowNode.right)
                Value.append(nowNode.right.val + nowValue)
        return False

LeetCode测试结果：

标签：right,val,sum,路径,LeetCode,nowNode,root,节点,总和
来源： https://blog.csdn.net/weixin_45295612/article/details/110069323