面试题34. 二叉树中和为某一值的路径（113. 路径总和 II）（Java）（树递归）

最新推荐文章于 2021-11-16 12:21:27 发布

失业边缘，疯狂挣扎

最新推荐文章于 2021-11-16 12:21:27 发布

阅读量139

点赞数

分类专栏：二叉树递归回溯

本文链接：https://blog.csdn.net/weixin_43969686/article/details/104699006

版权

二叉树同时被 3 个专栏收录

29 篇文章 0 订阅

订阅专栏

递归

28 篇文章 0 订阅

订阅专栏

回溯

15 篇文章 0 订阅

订阅专栏

1 题目

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

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

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

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

提示：

节点总数 <= 10000
注意：本题与主站 113 题相同：https://leetcode-cn.com/problems/path-sum-ii/

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2 Java

递归思路：有孩子就往下，没孩子说明到叶节点了，看路径是否满足要求，满足就计入答案，不满足就退回
切记退回时刻需要将list最后一个元素弹出

2.1 方法一（典型错误，浅拷贝导致）

思路：用成员变量ans记录最终结果；helper方法的全局变量list，记录路径，若路径符合条件，将路径计入ans

错误：由于ans仅仅是和list指向同一空间，list在向根节点一级一级返回的过程中，remove的同时导致ans也清空了，最后ans啥都没有

/**
 * 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>> ans = new LinkedList<List<Integer>>();

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<Integer> list = new LinkedList<>();
        helper(root, sum, list);
        return ans;
    }
    public void helper(TreeNode root, int sum, List<Integer> list){
        if(root == null)    return;
        
        list.add(root.val);      
        
        if(root.left != null)  helper(root.left, sum - root.val, list);
        if(root.right != null) helper(root.right, sum - root.val, list);
        if(root.left == null && root.right == null && root.val == sum) ans.add(list);	// 错误！！！
        
        list.remove(list.size() - 1);
    }
}

利用集合的构造函数深拷贝
修改后：

/**
 * 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>> ans = new LinkedList<List<Integer>>();

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<Integer> list = new LinkedList<>();
        helper(root, sum, list);
        return ans;
    }
    public void helper(TreeNode root, int sum, List<Integer> list){
        if(root == null)    return;
        
        list.add(root.val);
        
        if(root.left != null)  helper(root.left, sum - root.val, list);
        if(root.right != null) helper(root.right, sum - root.val, list);
        if(root.left == null && root.right == null && root.val == sum) ans.add(new LinkedList<Integer>(list));
        
        list.remove(list.size() - 1);
    }
}

进一步思考成员变量、方法外局域变量、方法内局域变量，三者各自与递归方法的关系：

方法内局域变量：只有作为返回值才能跨层记录结果，且仅能跨一层。记录or操作下层返回值，并在处理后作为返回值返回上层
方法外局域变量：相当于全局变量，可跨多层记录结果，但必须作为递归方法的参数才能使用
成员变量：完完全全的全局变量，可跨多层记录结果，直接用无限制

总结：
1从叶节点逐步向上扩展结果，最终到根节点时得到答案，且当答案只有一个（非集合，比如前中后序遍历），使用方法内局域变量
2从根节点逐步向下扩展结果，最终到叶节点时得到答案，且当答案有多个（集合的形式，比如面试题34. 二叉树中和为某一值的路径），使用成员变量or方法外局域变量
3方法外局域变量和成员变量对于递归函数的意义差不多，直接用成员变量就好，也省去了方法外局域变量作为参数传递的过程

/**
 * 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>> ans = new LinkedList<List<Integer>>();
    List<Integer> list = new LinkedList<>();

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        if(root == null)    return ans;
        
        list.add(root.val);
        
        if(root.left != null)  pathSum(root.left, sum - root.val);
        if(root.right != null) pathSum(root.right, sum - root.val);
        if(root.left == null && root.right == null && root.val == sum) ans.add(new LinkedList<Integer>(list));
        
        list.remove(list.size() - 1);

        return ans;
    }
}

3 三刷

3.1 方法一（代码少，不易理解）

基本也是回溯框架，if + for
只是在 if 之前，需要先操作当前节点，即将当前节点加入路径，再 if 判断路径是否为解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        // 解决特殊情况
        if(root == null)    return listList;
        
        helper(root, sum, 0);
        return listList;
    }

    List<List<Integer>> listList = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    public void helper(TreeNode root, int sum, int curSum){
        list.add(root.val);
        curSum += root.val;
        // if是否记录路径（当前路径是否为解）；注意判断条件是左右子树皆为null，不是root为null！！！
        if(curSum == sum && root.left == null && root.right == null)    listList.add(new ArrayList<>(list));

        // for多路选择（到哪个状态去）
        // 做选择
        if(root.left != null)	helper(root.left, sum, curSum);
        if(root.right != null)	helper(root.right, sum, curSum);
        // 撤销选择
        list.remove(list.size() - 1);
        // curSum -= root.val;  // 注，int类型不需要撤销选择！！！
    }

    // 错误；这样会得到重复结果，每个路径都会被记录两遍，因为每次是root为null判断，叶节点左右两个null节点都会记录一遍
    public void helper1(TreeNode root, int sum, int curSum){
        if(root == null){
            if(curSum == sum)   listList.add(new ArrayList<>(list));
            return;
        }

        list.add(root.val);
        helper(root.left, sum, curSum + root.val);
        helper(root.right, sum, curSum + root.val);
        list.remove(list.size() - 1);
    }
}

3.2 方法二（好理解，回溯框架）

这个方法是在进入下一层递归方法之前，先将该节点加入路径
递归方法开始时，直接判断当前路径是否满足条件
if 是否记录路径
for 多路选择

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        // 处理特殊情况
        if(root == null)    return listList;

        // 先将root加入路径，再进入递归
        list.add(root.val);
        helper(root, sum, root.val);

        return listList;
    }

    List<List<Integer>> listList = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    public void helper(TreeNode root, int sum, int curSum){
        // if是否记录路径（当前路径是否为解）；先判断是否到叶节点 条件：左右子树皆为null，不是root为null！！！
        if(root.left == null && root.right == null){
            // 再判断路径是否为解
            if(curSum == sum)   listList.add(new ArrayList<>(list));
            return;
        }
        
        // for多路选择（到哪个状态去）
        if(root.left != null){
            // 做选择
            list.add(root.left.val);
            helper(root.left, sum, curSum + root.left.val);
            // 撤销选择
            list.remove(list.size() - 1);
        }
        if(root.right != null){
            // 做选择
            list.add(root.right.val);
            helper(root.right, sum, curSum + root.right.val);
            // 撤销选择
            list.remove(list.size() - 1);
        }
    }
}

4 四刷

4.1 方法一（回溯递归；本层操作本层做）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        helper(root, sum, 0);
        return listList;
    }

    List<List<Integer>> listList = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    public void helper(TreeNode root, int sum, int curSum){
        // if出口
        if(root == null)    return;

        // 做选择
        curSum += root.val;
        list.add(root.val);

        // if判断，是否记录路径（当前路径是否为解）
        // 注：判断是否到叶节点的条件：左右子树皆为null，不是root为null！！！
        if(root.left == null && root.right == null){
            if(curSum == sum)   listList.add(new ArrayList<>(list));
        }
        
        // for多路选择（到哪个状态去）
        helper(root.left, sum, curSum);
        helper(root.right, sum, curSum);

        // 撤销选择
        list.remove(list.size() - 1);
    }
}

4.2 方法二（回溯递归，本层操作本层做，全部成员变量）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        helper(root, sum);
        return listList;
    }

    List<List<Integer>> listList = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    int curSum;
    public void helper(TreeNode root, int sum){
        // if出口
        if(root == null)    return;

        // 做选择
        curSum += root.val;
        list.add(root.val);

        // if判断，是否记录路径（当前路径是否为解）
        // 注：判断是否到叶节点的条件：左右子树皆为null，不是root为null！！！
        if(root.left == null && root.right == null){
            if(curSum == sum)   listList.add(new ArrayList<>(list));
        }
        
        // for多路选择（到哪个状态去）
        helper(root.left, sum);
        helper(root.right, sum);

        // 撤销选择
        curSum -= root.val;
        list.remove(list.size() - 1);
    }
}