【剑指Offer】个人学习笔记_34_二叉树中和为某一值的路径

刷题日期：19:5414 星期一2021年4月12日

个人刷题记录，代码收集，来源皆为leetcode

经过多方讨论和请教，现在打算往Java方向发力

主要答题语言为Java

题目：

剑指 Offer 34. 二叉树中和为某一值的路径

难度中等165

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

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

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

返回:

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

提示：

1. 节点总数 <= 10000

题目分析

题目很开放，要解决问题要么得遍历所有的路径之和，然后返回满足要求的。

树的结构也比之前简单的二叉树复杂了

前序遍历先访问根节点

初始解答：

完全没有思路，学习他人解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    LinkedList<List<Integer>> res = new LinkedList<>(); //结果链表
    LinkedList<Integer> path = new LinkedList<>();  //路径
    public List<List<Integer>> pathSum(TreeNode root, int target) {
        recur(root, target); //直接进入子程序
        return res; //全局变量所以不用管
    }
    void recur(TreeNode root, int tar) {
        if (root == null) return;
        path.add(root.val); //先把当前根节点考虑进去
        tar -= root.val; //剩下的值也相应减少
        if(tar == 0 && root.left == null && root.right == null) {
            res.add(new LinkedList(path)); //满足的情况，路径增加
        }
        recur(root.left, tar); //先序遍历，先查左子树
        recur(root.right, tar);
        path.removeLast(); //从路径中删除最后进入的元素
        //java.util.LinkedList类的removeLast()方法将删除并返回此列表的最后一个元素。
    }
}

执行结果：通过

显示详情

执行用时：2 ms, 在所有 Java 提交中击败了27.92%的用户

内存消耗：39.2 MB, 在所有 Java 提交中击败了7.88%的用户

学习他人：

方法一:

Java回溯

class Solution {

    private List<List<Integer>> res;

    // 二叉树中和为某一值的路径
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        res = new ArrayList<>();
        backtrack(root, sum, new ArrayList<>());
        return res;
    }

    private void backtrack(TreeNode node, int target, List<Integer> collector) {
        if (node == null) {
            return;
        }
        collector.add(node.val);
        target -= node.val;
        if (target == 0 && node.left == null && node.right == null) {
            res.add(new ArrayList<>(collector));
        } else {
            backtrack(node.left, target, collector);
            backtrack(node.right, target, collector);
        }
        collector.remove(collector.size() - 1);
    }
}

方法二：

come听风吹雨

2021-02-25

java速度打败100%，但是有点耗内存

/**
 * 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) {
        List<List<Integer>> ans = new ArrayList<>();
        List<Integer> temp = new ArrayList<>();
        dfs(root, ans, temp, sum);
        return ans;
    }

     public void dfs(TreeNode root, List<List<Integer>> ans, List<Integer> temp, int sum) {
         if(root==null)
            return;
        //先把本节点加入
        temp.add(root.val);
         if(root.left==null && root.right==null){
             if(root.val==sum){
                 ans.add(new ArrayList(temp));
             }
             //遍历到叶子节点，是必须释放的
             temp.remove(temp.size()-1);
             return;
         }
        if(root.left!=null)
            dfs(root.left, ans, temp, sum-root.val);
         if(root.right!=null)
            dfs(root.right, ans, temp, sum-root.val);
        //左右子节点遍历结束后释放自身
         temp.remove(temp.size()-1);
     }


}

方法三：

K神 解题思路：
本问题是典型的二叉树方案搜索问题，使用回溯法解决，其包含 先序遍历 + 路径记录 两部分。

先序遍历： 按照 “根、左、右” 的顺序，遍历树的所有节点。

路径记录： 在先序遍历中，记录从根节点到当前节点的路径。当路径为 ① 根节点到叶节点形成的路径 且 ② 各节点值的和等于目标值 sum 时，将此路径加入结果列表。

作者：jyd
链接：https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/solution/mian-shi-ti-34-er-cha-shu-zhong-he-wei-mou-yi-zh-5/
来源：力扣（LeetCode）

值得注意的是，记录路径时若直接执行 res.append(path) ，则是将 path 对象加入了 res ；后续 path 改变时， res 中的 path 对象也会随之改变。

正确做法：res.append(list(path)) ，相当于复制了一个 path 并加入到 res 。

class Solution {
    LinkedList<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>(); 
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        recur(root, sum);
        return res;
    }
    void recur(TreeNode root, int tar) {
        if(root == null) return;
        path.add(root.val);
        tar -= root.val;
        if(tar == 0 && root.left == null && root.right == null)
            res.add(new LinkedList(path));
        recur(root.left, tar);
        recur(root.right, tar);
        path.removeLast();
    }
}

总结

以上就是本题的内容和学习过程了，这两天感冒，脑子不在线，提不起精神，这道就先过了，对我来说是有点难。

欢迎讨论，共同进步。