【Leetcode】Path Sum II

最新推荐文章于 2025-08-17 23:50:11 发布

yyz20002008

最新推荐文章于 2025-08-17 23:50:11 发布

阅读量104

点赞数

文章标签： leetcode java arraylist TreeNode List

本文介绍了一种算法，用于在给定的二叉树中找到所有从根到叶节点的路径，使得路径上的节点值之和等于指定的数值。包括Java代码实现及多种解题思路。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.

For example:
Given the below binary tree and

sum
 = 22

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

return

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

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

Java:

我照搬的，数据类型改了下：

public class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> res= new ArrayList<List<Integer>>();
        if(root==null) return res;
        ArrayList<Integer> item= new ArrayList<Integer>();
        item.add(root.val);
        help(root, sum-root.val, item, res);
        return res;
        
    }
    private void help(TreeNode root,int sum, ArrayList<Integer> item, List<List<Integer>> res)
    {
        if(root==null) return;
        if(root.left==null&&root.right==null&& sum==0) 
        res.add(new ArrayList<Integer>(item));
        
        if(root.left!=null)
        {
            item.add(root.left.val);
            help(root.left, sum-root.left.val, item, res);
            item.remove(item.size()-1);
        }
        if(root.right!=null)
        {
            item.add(root.right.val);
            help(root.right, sum-root.right.val, item, res);
            item.remove(item.size()-1);
        }
    }
}

这次水哥的有点复杂看不懂，没用

1. CodeGanker 递归：http://blog.youkuaiyun.com/linhuanmars/article/details/23655413

public ArrayList<ArrayList<Integer>> pathSum(TreeNode root, int sum) {  
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();  
    if(root==null)  
        return res;  
    ArrayList<Integer> item = new ArrayList<Integer>();  
    item.add(root.val);  
    helper(root,sum-root.val,item,res);  
    return res;  
}  
private void helper(TreeNode root, int sum, ArrayList<Integer> item, ArrayList<ArrayList<Integer>> res)  
{  
    if(root == null)  
        return;  
    if(root.left==null && root.right==null && sum==0)  
    {  
        res.add(new ArrayList<Integer>(item));  
        return;  
    }  
    if(root.left!=null)  
    {  
        item.add(root.left.val);  
        helper(root.left,sum-root.left.val,item,res);  
        item.remove(item.size()-1);  
    }  
    if(root.right!=null)  
    {  
        item.add(root.right.val);  
        helper(root.right,sum-root.right.val,item,res);  
        item.remove(item.size()-1);  
    }          
}

2.http://blog.youkuaiyun.com/fightforyourdream/article/details/12865895

public class Solution {  
    public List<List<Integer>> pathSum(TreeNode root, int sum) {  
        List<List<Integer>> ret = new ArrayList<List<Integer>>();  
        List<Integer> list = new ArrayList<Integer>();  
        rec(ret, list, root, sum);  
        return ret;  
    }  
      
    public void rec(List<List<Integer>> ret, List<Integer> list, TreeNode root, int sum) {  
        if(root == null) {  
            return;  
        }  
        if(root.left==null && root.right==null && sum == root.val){  
            list.add(root.val);  
            ret.add(new ArrayList<Integer>(list));  
            list.remove(list.size()-1);  
            return;  
        }  
          
        list.add(root.val);  
        rec(ret, list, root.left, sum-root.val);  
        rec(ret, list, root.right, sum-root.val);  
        list.remove(list.size()-1);  
    }  
}

它的另一个经典递归：

public static ArrayList<ArrayList<Integer>> pathSum(TreeNode root, int sum) {  
        ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();  
        ArrayList<Integer> l =new ArrayList<Integer>();  
        dfs(root, sum, list, l);  
        return list;  
    }  
      
    // 经典递归回溯  
    private static void dfs(TreeNode root, int sum, ArrayList<ArrayList<Integer>> list, ArrayList<Integer> l){  
        if(root == null){  
            return;  
        }  
      
        // 找到最后一个合适的叶子节点  
        if(root.val==sum && root.left==null && root.right==null){  
            l.add(root.val);  
              
            // 注意！在把结果加入结果集时，必须深拷贝一份！  
            // 否则被加进去的集合之后可能会变动  
            ArrayList<Integer> clone = new ArrayList<Integer>(l);  
            list.add(clone);  
              
            l.remove(l.size()-1);       // 恢复全局变量//回溯部分  
            return;  
        }  
      
        l.add(root.val);  
        dfs(root.left, sum-root.val, list, l);  
        dfs(root.right, sum-root.val, list, l);  
        l.remove(l.size()-1);       // 恢复全局变量//回溯部分  
    }