Leetcode第112题：路径总和

1 问题描述

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

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

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

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

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

2 解题思路

root为空，错误；
root不为空，其左右子树为空，且sum==root->val，正确；
（以上两种情况为递归退出条件）
接下来递归解决，分别寻找其左右子树是否存在sum-root->val的路径存在，再对两个结果做或运算即可。

3 代码

3.1 C++代码

执行结果：8ms，98.19%。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        //root为空，错误
        if(root==nullptr)
            return false;
        
        //root为叶结点
        if(root->left==nullptr&&root->right==nullptr){
            //root值与sum相等，正确
            if(root->val==sum)
                return true;
            else
                return false;
        }
        
        //排除上面两种情况，递归解决
        //寻找root子树中是否存在sum-root->val的路径存在
        bool leftResult=hasPathSum(root->left,sum-root->val);
        bool rightResult=hasPathSum(root->right,sum-root->val);
        return leftResult||rightResult;
    }
};

3.2 Python代码

执行结果：64ms，93.69%。
（再次吐槽，效率好低。还有这个Python的bool变量和递归调用有点不习惯）

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

class Solution:
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        #root为空，错误
        if root==None:
            return False
        
        #root为叶结点
        if root.left==None and root.right==None:
            #root值与sum相等，正确
            if sum==root.val:
                return True
            else:
                return False
            
        #排除上面两种情况，递归解决
        #寻找root子树中是否存在sum-root->val的路径存在
        leftResult=self.hasPathSum(root.left, sum-root.val)
        rightResult=self.hasPathSum(root.right, sum-root.val)
        return leftResult or rightResult