112. 路径总和

112. 路径总和

题目链接：112. 路径总和(简单)

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

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

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

解题思路

该题与257. 二叉树的所有路径 很相似，只是在该题中，如果找到对应的路径需立即返回。所以在递归方法中，递归函数的返回值不能为 void。

递归法

代码(C++)

//递归
class Solution {
public:
     bool traversal(TreeNode* node, int targetSum, int& midSum) {
        if (node->left == nullptr && node->right == nullptr) { // 叶子节点
            if (midSum == targetSum) return true;
            else return false;
        }
        //非叶子节点
        bool result1 = false;
        bool result2 = false;
        if (node->left) {
            midSum += node->left->val;
            result1 = traversal(node->left, targetSum, midSum);
            midSum -= node->left->val; //回溯
        }
        if (node->right) {
            midSum += node->right->val;
            result2 = traversal(node->right, targetSum, midSum);
            midSum -= node->right->val; //回溯
        }
        return result1 || result2;
    }
​
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr) return false;
        int midSum = root->val;
        bool result = traversal(root, targetSum, midSum);
        return result;
    }
};

代码(JavaScript)

// 递归法
// 用 count 计数 
function traversal(node, count) {
    if (!node.left && !node.right) {
        if (count === 0) return true;
        else return false;
    }
​
    if (node.left) {
        count -= node.left.val;
        if (traversal(node.left, count)) return true;
        count += node.left.val; //回溯
    }
    if (node.right) {
        count -= node.right.val;
        if (traversal(node.right, count)) return true;
        count += node.right.val; //回溯
    }
    return false;
}
​
var hasPathSum = function(root, targetSum) {
    if (root === null) return false;
    return traversal(root, targetSum - root.val);
};

迭代法

代码(C++)

//迭代(前序遍历)
class Solution1 {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        stack<TreeNode*> staNode; //用于处理节点
        stack<int> staSum; //用于处理路径和
        if (root != nullptr) {
            staNode.push(root);
            staSum.push(root->val);
        }
        while (!staNode.empty()) {
            TreeNode* node = staNode.top();
            staNode.pop();
            int midSum = staSum.top();
            staSum.pop();
            if (node->left == nullptr && node->right == nullptr && midSum == targetSum) return true;
            if (node->right) {
                staNode.push(node->right);
                staSum.push(midSum + node->right->val);
            }
            if (node->left) {
                staNode.push(node->left);
                staSum.push(midSum + node->left->val);
            }
        }
        return false;
    }
};

代码(JavaScript)

//迭代
var hasPathSum = function(root, targetSum) {
    let staNode_Sum = [];
    if (root != null) {
        staNode_Sum.push(root.val); // 值先进
        staNode_Sum.push(root); //节点后进
    }
    while (staNode_Sum.length != 0) {
        let node = staNode_Sum.pop(); //节点先出
        let sum = staNode_Sum.pop(); //值后出
        if (node.left === null && node.right === null && sum === targetSum) return true;
        if (node.right) { //右
            staNode_Sum.push(sum + node.right.val); //值先进
            staNode_Sum.push(node.right); //节点后进
        }
        if (node.left) { //左
            staNode_Sum.push(sum + node.left.val); //值先进
            staNode_Sum.push(node.left); //节点后进
        }
    }
    return false;
};