leetcode--二叉树中和为某一值的路径

 题目来自LeetCode，链接：面试题34. 二叉树中和为某一值的路径。具体描述为：输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

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

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

 返回：

[
   [5,4,11,2],
   [5,8,4,5]
]

 典型的DFS+回溯的题目，套用DFS的模板，在到达叶子节点的时候判断总和是否为目标值，是的话将当前这条路径加入结果链表，否则的话需要回溯。明显时间复杂度就是$O(n)$，因为需要遍历所有节点，空间复杂度为$O(n)$，即为二叉树退化为单链表情况下的递归栈占用空间。

 JAVA版代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<List<Integer>> result;
    LinkedList<Integer> item;

    private void visit(TreeNode node, int target) {
        if (node.left == null && node.right == null) {
            if (target == node.val) {
                item.add(node.val);
                result.add(new LinkedList<Integer>(item));
                item.removeLast();
            }
            return;
        }
        item.add(node.val);
        if (node.left != null) {
            visit(node.left, target - node.val);
        }
        if (node.right != null) {
            visit(node.right, target - node.val);
        }
        item.removeLast();
    }

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        result = new LinkedList<>();
        if (root == null) {
            return result;
        }
        item = new LinkedList<>();
        visit(root, sum);
        return result;
    }
}

 提交结果如下:

 Python版代码如下：

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

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        if root is None:
            return []
        result = []
        item = []
        def dfs(node, target):
            if node.left is None and node.right is None:
                if node.val == target:
                    item.append(node.val)
                    result.append(item[:])
                    item.pop()
                return
            item.append(node.val)
            if node.left is not None:
                dfs(node.left, target - node.val)
            if node.right is not None:
                dfs(node.right, target - node.val)
            item.pop()
        dfs(root, sum)
        return result

 提交结果如下: