基于递归求二叉树路径总和

题目

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

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

解决思路

• 采用递归思想解决。
• 本题中递归函数表示的意义：判断是否存在一条从根节点到某个叶子节点的路径，使得该路径上所有节点的值的总和等于给定的数值targetSum。
• 具体步骤：
  • 第一步：判断根节点是否有左右节点，如果既没有左节点也没有右节点，判断根节点的值是否等于给定的值。
  • 第二步：如果根节点有左节点，则递归判断从根节点开始到左子树的某个叶子节点的路径总和是否等于给定的值。
  • 第三步：如果根节点有右节点，递归判断从根节点开始到右子树的某个叶子节点的路径总和是否等于给定的值。

代码

• C++代码

# include <stdio.h>

using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(): val(0), left(nullptr), right(nullptr) {}
    TreeNode(int _val): val(_val), left(nullptr), right(nullptr) {}
    TreeNode(int _val, TreeNode* _left, TreeNode* _right): val(_val), left(_left), right(_right) {}
};


class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (nullptr == root) {  // 空树返回false。
            return false;
        }

        // 第一步：如果根节点没有左右节点，判断根节点的值是否等于给定的值。
        if (nullptr == root->left && nullptr == root->right) {
            return root->val == targetSum;
        }

        // 第二步：如果根节点存在左节点，递归判断从根节点开始到左子树的某个叶子节点的路径和是否等于给定的值。
        if (root->left && hasPathSum(root->left, targetSum - root->val)) {
            return true;
        }
        // 第三步：如果根节点存在右节点，递归判断从根节点开始到右子树的某个叶子节点的路径和是否等于给定的值。
        if (root->right && hasPathSum(root->right, targetSum - root->val)) {
            return true;
        }
        return false;
    }
};

int main() {
    TreeNode* n1 = new TreeNode(5);
    TreeNode* n2 = new TreeNode(4);
    TreeNode* n3 = new TreeNode(8);
    TreeNode* n4 = new TreeNode(11);
    TreeNode* n5 = new TreeNode(13);
    TreeNode* n6 = new TreeNode(4);
    TreeNode* n7 = new TreeNode(7);
    TreeNode* n8 = new TreeNode(2);
    TreeNode* n9 = new TreeNode(1);

    n1->left = n2;
    n1->right = n3;
    n2->left = n4;
    n2->right = nullptr;
    n3->left = n5;
    n3->right = n6;
    n4->left = n7;
    n4->right = n8;
    n5->left = nullptr;
    n5->right = nullptr;
    n6->left = nullptr;
    n6->right = n9;
    n7->left = nullptr;
    n7->right = nullptr;
    n8->left = nullptr;
    n8->right = nullptr;
    n9->left = nullptr;
    n9->right = nullptr;

    Solution* solution = new Solution();
    int targetSum = 22;
    bool ret = solution->hasPathSum(n1, targetSum);
    printf("%d\n", ret);

    return 0;
}

• Python代码

# -*- coding: utf-8 -*-

from typing import Optional


class TreeNode:
    def __init__(self, _val=0, _left=None, _right=None):
        self.val = _val
        self.left = _left
        self.right = _right


class Solution:
    def __init__(self):
        pass

    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:  # 空树返回false。
            return False

        # 第一步：如果根节点没有左右节点，判断根节点的值是否等于给定的值。
        if not root.left and not root.right:
            return root.val == targetSum

        # 第二步：如果根节点存在左节点，递归判断从根节点开始到左子树的某个叶子节点的路径和是否等于给定的值。
        if root.left and self.hasPathSum(root.left, targetSum - root.val):
            return True
        # 第三步：如果根节点存在右节点，递归判断从根节点开始到右子树的某个叶子节点的路径和是否等于给定的值。
        if root.right and self.hasPathSum(root.right, targetSum - root.val):
            return True

        return False


def main():
    n1 = TreeNode(5)
    n2 = TreeNode(4)
    n3 = TreeNode(8)
    n4 = TreeNode(11)
    n5 = TreeNode(13)
    n6 = TreeNode(4)
    n7 = TreeNode(7)
    n8 = TreeNode(2)
    n9 = TreeNode(1)

    n1.left = n2
    n1.right = n3
    n2.left = n4
    n2.right = None
    n3.left = n5
    n3.right = n6
    n4.left = n7
    n4.right = n8
    n5.left, n5.right = None, None
    n6.left = None
    n6.right = n9
    n7.left, n7.right = None, None
    n8.left, n8.right = None, None
    n9.left, n9.right = None, None

    solution = Solution()
    targetSum: int = 22
    print(solution.hasPathSum(n1, targetSum))


if __name__ == "__main__":
    main()

说明

• 对应LeetCode第112题。
• LeetCode：https://leetcode-cn.com/problems/path-sum/