【剑指Offer】34.二叉树中和为某一值的路径（JS实现）

题目描述

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

示例：

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

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

返回：

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

题目解答

区分深拷贝和浅拷贝的方式：

假设B复制了A，当修改A时，看B是否会发生变化，如果B也跟着变了，说明是浅拷贝，如果B没变，那就是深拷贝。

• 浅拷贝：

  对于引用类型，名字存在栈内存中，值存在堆内存中，但是栈内存会提供一个引用地址指向堆内存中的值。

  当b=a进行拷贝时，复制的是a的引用地址，而并非堆里面的值。

  当a[0]=1进行修改时，a和b指的同一个地址，则b的值也会改变。

• 使用扩展运算符实现深拷贝

// 当value是基本数据类型，比如String，Number，Boolean时，是可以使用拓展运算符进行深拷贝的
// 当value是引用类型的值，比如Object，Array，引用类型进行深拷贝也只是拷贝了引用地址，所以属于浅拷贝
var car = {brand: "BMW", price: "380000", length: "5米"}
var car1 = { ...car, price: "500000" }
console.log(car1); // { brand: "BMW", price: "500000", length: "5米" }
console.log(car); // { brand: "BMW", price: "380000", length: "5米" }

本来解题思路并不复杂，如果在获得路径后直接输出，则没有什么大问题。

但力扣通常要求将结果放入数组中返回。然后代码就出问题了。

之前考虑定义一个大的二维数组存放最终结果，每获得一条正确路径则push进这个数组，但事实证明，在递归解法里，这样的想法不安全。

正确解法：

var pathSum = function(root, sum) {
    var result = [];
    if(root == null){
        return result;
    }
    var sumResult = 0;
    var results = [];
    function backTracking(root,sum,sumResult,result)
    {
        sumResult+=root.val;
        // 深拷贝
        result = [...result,root.val]; //之前写法：result.push(root.val);
        if(sumResult == sum && isLeaf(root))
        {
            results.push(result);
            return;
        }
        if(root.left!=null)
        {
            backTracking(root.left,sum, sumResult, result);
        }
        if(root.right!=null)
        {
            backTracking(root.right,sum, sumResult, result);
        }
        // result.pop(); (不需要)
    };
    backTracking(root,sum,sumResult,result);
    return results;
};
// 是否是叶子节点
var isLeaf = function(root){
    if(root.left ==null && root.right ==null)
    {
        return true;
    }
    return false;
}
// var isLeaf = root.right==null&&root.left==null;

之前，在遍历节点后，直接用result.push(root.val);语句为路径添加新节点，这样做是直接修改最初定义的result。改为深拷贝方式后，建立的新数组与之前的result数组彼此独立。