113. 路径总和II

深度优先搜索

class Solution {

    List<List<Integer>> list = new LinkedList<>();

    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {

        dfs(root, new LinkedList<Integer>(), targetSum);
        return list;
    }

    public void dfs(TreeNode root, List<Integer> li, int targetSum){

        /**
         * 如果节点为空，不操作
         */
        if (root == null){
            return;
        }

        targetSum -= root.val;
        li.add(root.val);

        /**
         * 如果是叶子节点，且数值满足目标，就将小列表添加进总列表返回
         * 注意小列表需要复制一份独立的出来，否则传递的是引用
         */
        if (root.left == null && root.right == null && targetSum == 0){

            list.add(new LinkedList<>(li));
            return;
        }

        /**
         * 否则，递归遍历左右孩子，获得所有的路径可能
         * 注意复制新的列表
         */
        dfs(root.left, new LinkedList<>(li), targetSum);
        dfs(root.right, new LinkedList<>(li), targetSum);
    }
}

/**
 * 时间复杂度 O(n^2)
 * 空间复杂度 O(logn)
 */

回溯

class Solution {

    List<List<Integer>> list = new LinkedList<>();

    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {

        dfs(root, new LinkedList<Integer>(), targetSum);

        return list;
    }

    public void dfs(TreeNode root, List<Integer> li, int targetSum){

        /**
         * 如果节点为空，不操作
         */
        if (root == null){
            return;
        }

        targetSum -= root.val;
        li.add(root.val);

        /**
         * 如果是叶子节点，且数值满足目标，就将小列表添加进总列表返回
         * 注意小列表需要复制一份独立的出来，否则传递的是引用
         */
        if (root.left == null && root.right == null && targetSum == 0){
            list.add(new LinkedList<>(li));
        }

        /**
         * 递归遍历左右孩子，获得所有的路径可能
         * 如果参数传递的引用而不是新列表，那要推出最后一个加入的元素，便于进行下一轮寻找（回溯）
         */
        dfs(root.left, li, targetSum);
        dfs(root.right, li, targetSum);
        li.remove(li.size() - 1);
    }
}

/**
 * 时间复杂度 O(n^2)
 * 空间复杂度 O(logn)
 */

递归

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {

        List<List<Integer>> list = new LinkedList<>();

        /**
         * 如果节点为空，返回空列表
         */
        if (root == null){
            return list;
        }

        /**
         * 如果是叶子节点，且数值满足目标，就放在一个子列表，然后添加进总的列表
         */
        if (root.left == null && root.right == null){

            if (root.val == targetSum){

                List<Integer> temp = new LinkedList<>();
                temp.add(0, root.val);
                list.add(temp);
            }
        }

        /**
         * 否则，递归遍历左右孩子，获得所有的路径可能，最后将根节点加上
         */
        List<List<Integer>> left = pathSum(root.left, targetSum - root.val);
        List<List<Integer>> right= pathSum(root.right, targetSum - root.val);

        for (int i = 0; i < left.size(); i++) {

            left.get(i).add(0, root.val);
            list.add(left.get(i));
        }

        for (int i = 0; i < right.size(); i++) {

            right.get(i).add(0, root.val);
            list.add(right.get(i));
        }

        return list;
    }
}

/**
 * 时间复杂度 O(n^2)
 * 空间复杂度 O(logn)
 */

https://leetcode-cn.com/problems/path-sum-ii/