Question

我正在做以下leetcode问题：

您将获得两个非空链表，它们代表两个非负数   整数。这些数字以相反的顺序存储，每个数字   节点包含一个数字。将两个数字相加，然后将其返回为   链表。

您可以假设两个数字不包含任何前导零，除了   数字0本身。

我偶然发现了以下算法

function ListNode(val) {
      this.val = val;
      this.next = null;
 }

 //This functiomn is called
var addTwoNumbers = function(l1, l2) {    
    let remainder = 0
    let l3 = {}
    let head = l3
    while (l1 || l2 || remainder) {
        let sum = remainder
        function sumList (linkedList) {
            if (linkedList) {
                sum += linkedList.val
                return linkedList.next
            }
            return null
        }
        l1 = sumList(l1)
        l2 = sumList(l2)
        if (sum>9) {
            remainder = 1
            sum -= 10
        } else {
            remainder = 0
        }

        head.next = new ListNode(sum)
        head = head.next
    }
    return l3.next
};

在这里，我无法理解l3的观点？如果我将其删除，算法会失败吗？

问题链接：https://leetcode.com/problems/add-two-numbers/

Answer 1

l3保留所有已更改为head的值的记录。如果我这样说：

var a = {};
var b = a;

然后b不是它自己的对象。它是与a相同的对象的指针，因此，如果您更改b中的值，则也会进行更新以反映该更改。

当您深入嵌套对象时，情况仍然如此。如果我这样说：

var c = {value: 1, next:{innerValue: 1}};
var d = c;
d.value = 2;

然后，c也会更新以反映新值，正如我已经解释过的那样。但是有趣的是，如果我继续将d分配给嵌套对象并编辑嵌套对象，就像这样：

d = d.next;
d.innerValue = 2;

这仍然会更新c！因此，c保留所有这些更新的记录，而d可以自由地更深入地研究其嵌套对象。运行此代码后，c和d将如下所示：

console.log(c);//{value: 2, next:{innerValue: 2}}
console.log(d);//{innerValue: 2}

这是l3所做的。 l3朝向c朝向d，所以当算法说：

head.next = new ListNode(sum)
head = head.next

...您不必担心丢失历史记录，因为l3会保留所有记录。

将两个数字相加

1 个答案: