给定一个二叉树和一个值，请找出所有的根节点到叶子节点的节点值之和等于 的路径，

返回这些路径的集合。

思路：

递归遍历二叉树，从根节点到叶子节点统计节点值之和，如果等于给定值就把该路径添加到结果集合中。需要注意的是，在递归遍历过程中，需要维护一个路径 list 来记录当前的路径，每次递归到左右子节点时，需要将当前节点值加入路径 list 中，递归结束后，需要将当前节点从路径 list 中移除。

时间复杂度：O(n)，空间复杂度：O(logn)（二叉树为平衡树）。

Python 代码：

相关问题

给定一个二叉树root和一个值 sum： （1）判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径； （2）若有找出二叉树中结点值的和为sum的所有路径。

### 回答1：
这个问题需要我们构建一棵二叉树，其中根节点为root，每个节点都有一个值。回答问题分为两部分：

1. 判断是否有从根节点到叶子节点的路径值之和等于sum。我们可以采用递归的方式，遍历每个节点，如果当前节点是叶子节点且路径值之和等于sum，则返回True，否则继续遍历其左右子树。如果最终所有的叶子节点都遍历完了，仍然没有找到路径值之和等于sum的，则返回False。

2. 如果存在从根节点到叶子节点的路径值之和等于sum，则需要找出这样的路径。可以采用回溯法，在递归的过程中记录下遍历的路径，如果找到了路径值之和等于sum的路径，则输出该路径。

### 回答2：
这个问题可以用深度优先搜索（DFS）算法来解决，我们从根节点开始遍历二叉树，遍历到一个节点时，我们将该节点的值加入当前路径的节点值之和中，并在路径列表中加入该节点。如果该节点是叶子节点并且当前路径的节点值之和等于sum，那么我们就找到了一条符合条件的路径，将其加入结果列表中。

如果该节点不是叶子节点，我们就分别遍历它的左子树和右子树，直到找到一条符合条件的路径或者遍历完整棵树。每次遍历完当前节点后，我们就将该节点从路径中删除，并继续遍历它的父节点的另一个子节点。

具体实现见下面的代码：

class Solution:
    def pathSum(self, root, sum):
        res = []
        def dfs(node, path, total):
            if not node:
                return
            path.append(node.val)
            total += node.val
            if not node.left and not node.right and total == sum:
                res.append(path[:])
            dfs(node.left, path, total)
            dfs(node.right, path, total)
            path.pop()
        dfs(root, [], 0)
        return res

这段代码中，我们首先定义了一个空的结果列表 res 和一个 dfs 函数。函数 dfs 的参数包括当前节点 node，当前路径 path 和当前路径的节点值之和 total。我们首先判断当前节点是否为空，为空则直接返回。

然后将当前节点的值加入路径 path 中，并将当前节点的值加入总和 total 中。接着判断当前节点是否是叶子节点并且当前路径的节点值之和等于 sum，如果是，则将当前路径加入结果列表 res 中。

最后，我们对当前节点的左子树和右子树分别使用 dfs 函数进行遍历，并在遍历后将当前节点从路径 path 中删除。

在函数 pathSum 中，我们调用 dfs 函数，并将根节点和一个空路径以及节点值之和为 0 作为参数传入。最后返回结果列表 res。

### 回答3：
题目描述：

给定一个二叉树root和一个值 sum：

（1）判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径；

（2）若有找出二叉树中结点值的和为sum的所有路径。

解题思路：

对于第一问，我们可以采用递归的方式，对于每个节点，分别计算它的左子树和右子树是否有满足要求的路径。如果当前节点为叶子节点，且节点值等于sum，说明找到了一条满足要求的路径。

对于第二问，我们可以采用深度优先搜索（DFS）的方式，对于每个节点，先将它加入当前路径中，然后对它的左右子树进行操作。当搜索到叶子节点时，判断当前路径是否满足要求，如果满足则将当前路径加入结果集。最后将当前节点从路径中删除，返回到父节点，继续搜索。

代码实现：

（1）判断是否存在满足要求的路径

def hasPathSum(root, sum):
    if not root:
        return False
    if not root.left and not root.right:
        return root.val == sum
    else:
        return hasPathSum(root.left, sum - root.val) or hasPathSum(root.right, sum - root.val)

（2）找出所有满足要求的路径

def pathSum(root, sum):
    res = []
    path = []
    def dfs(root, sum):
        if not root:
            return
        path.append(root.val)
        sum -= root.val
        if not root.left and not root.right and sum == 0:
            res.append(path[:])
        dfs(root.left, sum)
        dfs(root.right, sum)
        path.pop() # 回溯，将当前节点从路径中删除
    dfs(root, sum)
    return res

给定一个二叉树root和一个值 sum:(1)判断是否有从根节点到叶子节点的节点值之和等于 sum的路径; 若有找出二又树中结点值的和为sum的所有路径。 用C语言写 用二叉树写

在C语言中，为了判断二叉树是否存在一条路径，其节点值之和等于给定的目标值`sum`，并找出所有这样的路径，你可以采用深度优先搜索（Depth-First Search, DFS）算法。这里给出一个基本思路：

1. 定义一个辅助函数`hasPathSumUtil(root, sum, currPath)`，它将递归地检查当前节点及其子节点是否满足条件。

2. 如果当前节点为空，则返回false，表示路径结束，无法到达目标和。

3. 更新当前路径（currPath）的和加上当前节点的值。如果这个和等于`sum`，则找到了一条路径，将路径添加到结果数组中。

4. 对左子节点和右子节点分别调用辅助函数，同时判断是否有路径。

5. 回溯结束后，如果`hasPathSumUtil(root, sum, 0)`返回true，说明存在路径，并且已经记录了所有路径。

以下是简化的C代码示例（未包含完整错误处理和路径存储）:

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int val;
    struct Node* left;
    struct Node* right;
};

// 辅助函数，查找路径
bool hasPathSumUtil(struct Node* root, int target, int sum, int path[], int pathLen) {
    if (!root)
        return false;

    // 更新当前路径
    sum += root->val;

    // 判断路径是否符合条件
    if (sum == target) {
        path[pathLen++] = root->val;
        if (pathLen == 1 || !hasPathSumUtil(root->left, target, 0, path, pathLen) ||
            !hasPathSumUtil(root->right, target, 0, path, pathLen))
            return true;
    } else {
        // 如果当前和不是目标，继续探索
        if (hasPathSumUtil(root->left, target, sum, path, pathLen) ||
            hasPathSumUtil(root->right, target, sum, path, pathLen))
            return true;
    }

    // 回溯，将节点值移除
    if (pathLen > 0)
        path[--pathLen] = 0;

    return false;
}

// 主函数，输入二叉树和目标和
void findPaths(struct Node* root, int target) {
    int path[1000];
    int pathLen = 0;

    if (hasPathSumUtil(root, target, 0, path, pathLen)) {
        printf("Path(s) with sum %d:\n", target);
        for (int i = 0; i < pathLen; i++) {
            if (path[i])
                printf("%d ", path[i]);
            else
                printf("<- NULL ");
        }
        printf("\n");
    } else {
        printf("No path found with sum %d.\n", target);
    }
}

int main() {
    // 你需要在这里创建并初始化二叉树结构
    // ...

    findPaths(root, sum);
    return 0;
}