无法在 Java 中分配 LinkedList 头节点以供将来参考

Question

我在尝试一个标准的面试题，就是以链表的形式添加两位数字，并返回添加的答案。问题来了：

给你两个链表，代表两个非负数。 数字以相反的顺序存储，它们的每个节点都包含 一个数字。将两个数字相加并作为链表返回。

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8

342 + 465 = 807 Make sure there are no trailing zeros in the output list So, 7 -> 0 -> 8 -> 0 is not a valid response even though

值仍然是 807。

现在，我正在编写的代码采用ListNode 数据类型形式的两个参数，这是LinkedLists 的起始节点。我不明白的是

1. 如何维护列表的头节点以供以后参考？

2. 按值调用和按引用调用在 Java 中如何工作？我已经在 C++ 中处理了指针和引用调用，但我现在一直在尝试 Java 中的东西，它非常不同。

   class ListNode {
       public int val;
       public ListNode next;
       ListNode(int x) {
           val = x;
           next = null;
       }
   }
   
   
   public class Solution {
   
       public ListNode reverse(ListNode head) {
           ListNode curr = head;
           ListNode next = null;
           ListNode prev = null;
           while (curr != null) {
               next = curr.next;
               curr.next = prev;
               prev = curr;
               curr = next;
           }
           head = prev;
           return head;
       }
   
   
       public ListNode addTwoNumbers(ListNode a, ListNode b) {
           ListNode node = null;
           ListNode head = null;
           boolean carry = false;
           while (a != null || b != null) {
               int f = 0, s = 0;
               if (carry) {
                   f++;
               }
               carry = false;
               if (a != null) {
                   f += a.val;
                   a = a.next;
               }
               if (b != null) {
                   s = b.val;
                   b = b.next;
               }
               if (f + s > 9) {
                   carry = true;
               }
               int curr = (f + s) % 10;
               node = new ListNode(curr);
               if (head == null) {
                   head = node;
               }
               node = node.next; //warning that 'value of node assigned is never used'
           }
           if (carry) {
               node = new ListNode(1);
           }
           printList(head);
           return node;
       }
   }
   

Answer 1

node 扮演一个模棱两可的角色。

        node = new ListNode(curr);
        node = node.next; // assigns null

将node 重命名为previous 并执行以下操作：

        int curr = (f + s) % 10;
        ListNode newNode = new ListNode(curr);
        if (head == null) { // Or `previous == null`
            head = newNode;
        } else {
            previous.next = newNode;
        }
        previous = newNode;

    ...
    return head;

处理head 的技术是使其成为容器类LinkedList 的私有字段。

在 java 中，参数传递是按值调用的：f(a) 永远不会更改变量 a：存储对象指针/值的槽。而是将对象指针/值压入堆栈。 （对象值可能会更改其字段。）

所以递归插入可能看起来像head = insert(head, ...)。

在C上可以使用别名，不仅仅用于参数传递：

ListNode* head = NULL;
ListNode** node = &head;
shile (...) {
    ...
    *node = newNode;
    node = &(newNode->next);
}

Answer 2

为什么这么复杂？

public class Solution {

    public ListNode addTwoNumbers(ListNode a, ListNode b) {
        int firstNumber = nodeToNumber(a);
        int secondNumber = nodeToNumber(b);
        return numberToNode(firstNumber + secondNumber);
    }

    public int nodeToNumber(ListNode node) {
        if (node.next != null) return node.value + 10 * nodeToNumber(node.next);
        return node.value;
    }

    public ListNode numberToNode(int number) {
        ListNode result = new ListNode(number % 10);
        if (number > 10) result.next = numberToNode(number / 10);
        return result;
    }
}