前言：今天在解决一个问题时，程序总是不能输出正确值，分析逻辑思路没问题后，发现原来是由于函数传递导致了这个情况。

LeetCode 113

问题：给你二叉树的根节点root和一个整数目标和targetSum，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

示例

 

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

我的代码如下

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

该题的思路是采用递归，traversal函数内root是当前树的根节点，count是目标值，res是存储结果，path是路径。该代码对于示例的输入输出为

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5],[5]]

经过排查最终问题在于代码中的add方法

原代码部分内容为

if (root.left == null && root.right == null) {
    if (count - root.val == 0) {
        res.add(path);
    }
    return;
}

该部分内容需要改为

if (root.left == null && root.right == null) {
    if (count - root.val == 0) {
        res.add(new ArrayList(path));
    }
    return;
}

此时所有代码对于示例的输入输出为

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

---

在java中，存在8大基本数据类型，且均有对应的包装类

数据类型	占用位数	默认值	包装类
byte(字节型)	8	0	Byte
short(短整型)	16	0	Short
int(整型)	32	0	Integer
long(长整型)	64	0.0l	Long
float(浮点型)	32	0.0f	Float
double(双精度浮点型)	64	0.0d	Double
char(字符型)	16	'/u0000'	Character
boolean(布尔型)	1	false	Boolean

在java中，函数传递只有值传递，是指在调用函数时，将实际参数复制一份传递给函数，这样在函数中修改参数(形参)时，不会影响到实际参数。

基本数据类型的值传递

测试类

public class TestClass {
    public static void test(int value) {
        value = 2;
        System.out.println("形参value的值：" + value);
    }
?
    public static void main(String[] args) {
        int value = 1;
        System.out.println("调用函数前value的值：" + value);
        test(value);
        System.out.println("调用函数后value的值：" + value);
    }
}

结果为

调用函数前value的值：1
形参value的值：2
调用函数后value的值：1

结论：可以看到，int类型的value初始为1，调用函数后，value仍然为1，基本数据类型在函数中修改参数(形参)时不会影响到实参的值。

引用数据类型的值传递

类TreeNode

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;
    }
}

测试类1

public class TestClass {
    public static void test(TreeNode node) {
        node.val = 2;
        System.out.println("形参node的val值：" + node.val);
    }
?
    public static void main(String[] args) {
        TreeNode node = new TreeNode(1);
        System.out.println("调用函数前node的val值：" + node.val);
        test(node);
        System.out.println("调用函数后node的val值：" + node.val);
    }
}

结果为

调用函数前node的val值：1
形参node的val值：2
调用函数后node的val值：2

结论：可以看到，TreeNode类型的node对象的val值初始为1，调用函数后