Question

我希望保存基于节点的链接列表的起点，即。链接列表使用节点而不是Java类实现，因为我向列表添加了更多元素，并且必须继续前往下一个节点。

public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int c = 0;
        ListNode n = new ListNode(0);
        ListNode l3 = n; //Node initialised to first node.
        while (l1 != null || l2 != null || c != 0)
        {
            int sum = l1.val + l2.val + c;
            c = sum/10;
            sum = sum%10;

            n = new ListNode(sum);
            n = n.next;
            l1 = l1.next;
            l2 = l2.next;
        }

        return l3;
    }
}

在上面的示例中，我使用l3来执行此操作。但是当我返回l3时，它被设置为列表中的最后一个节点。如何使用n阻止它在列表中移动。

-------- ---------- EDIT

以下是来自leetcode的问题，以便于参考：

您将获得两个非空链表，表示两个非负数   整数。数字以相反的顺序存储，每个数字都存储   节点包含一个数字。添加两个数字并将其作为a返回   链表。

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

输入：（2 - > 4 - > 3）+（5 - > 6 - > 4）输出：7 - ＆gt; 0 - ＆gt; 8

Answer 1

看看那些

        n = new ListNode(sum);
        n = n.next;

这里，n，当前节点的地址，设置为完全不同的地址。旧地址处的节点现在与新创建的节点完全无关。换句话说，每次遍历循环时，都会丢弃旧列表并启动另一个列表。当然，由于旧节点不再被任何东西引用，垃圾收集器会杀死它们。只有第一个创建的节点仍然存在，因为l3仍然指向它。

您需要操纵当前节点（而不是替换它），然后将新节点链接到它，如下所示：

        n.val = sum
        if(l1.next != null || l2.next != null){
            n.next = new ListNode(0);
            n = n.next;
        }

顺便说一句，给你的变量一些专有名称。喜欢l1 - ＆gt; list1，n - ＆gt; currentNode，c - ＆gt;携带。短暂并不好。可读性很好。

此外，当列表长度不同时，整个函数将崩溃，因为当其中一个列表为空时，您始终可以访问两者的值。你应该像

一样

        int sum = c;
        if(l1 != null){sum+=l1.val;}
        if(l2 != null){sum+=l2.val;}

在循环的开头和

        if(l1 != null){l1=l1.next;}
        if(l2 != null){l2=l2.next;}

最后。

Answer 2

我有时间回去清理一下这个。希望它有所帮助。

class Solution {
  /**
   * add two numbers in linked list form, lowest digit first form
   * ie 1->0->3->4 represents the integer number 4301
   * given 7->8->9->1 and 5->6->7->9 this method will return 2->5->7->1->1 (1987+9765=11752)
   *
   * @param lhs the left hand integer
   * @param rhs the right hand integer
   * @return the sum of the two integers
   */
  public ListNode<Integer> addTwoNumbers(final ListNode<Integer> lhs,
                                         final ListNode<Integer> rhs) {
    return addTwoNumbers(lhs, rhs, 0);
  }

  private static ListNode<Integer> addTwoNumbers(final ListNode<Integer> lhs,
                                                 final ListNode<Integer> rhs,
                                                 final int carry) {
    int sum = carry;
    sum += lhs == null ? 0 : lhs.getValue();
    sum += rhs == null ? 0 : rhs.getValue();
    if (sum == 0 && rhs == null && lhs == null) {
      return null;
    } else {
      return new ListNode<>(
        addTwoNumbers(
          lhs == null ? null : lhs.getNext(),
          rhs == null ? null : rhs.getNext(),
          sum / 10),
        sum % 10);
    }
  }

  public static void main(final String... args) {
    final ListNode<Integer> lhs = ListNode.fromVarArgs(1, 9, 8, 7);
    final ListNode<Integer> rhs = ListNode.fromVarArgs(9, 7, 6, 5);
    System.out.print(lhs);
    System.out.println("+");
    System.out.println(rhs);
    System.out.println("=");
    System.out.println(new Solution().addTwoNumbers(lhs, rhs));
  }
}

class ListNode<T> {
  static <T> ListNode<T> fromVarArgs(T... digits) {
    ListNode<T> ret = null;
    for (final T digit : digits) {
      ret = new ListNode<>(ret, digit);
    }
    return ret;
  }

  private ListNode<T> next;
  final private T value;

  ListNode(final ListNode<T> next, final T value) {
    this.next = next;
    this.value = value;
  }

  ListNode(final T value) {
    this(null, value);
  }

  ListNode<T> getNext() {
    return next;
  }

  void setNext(final ListNode<T> next) {
    this.next = next;
  }

  T getValue() {
    return value;
  }

  @Override
  public String toString() {
    if (getNext() == null) {
      return getValue().toString();
    } else {
      return String.format(
        "%s -> %s",
        getValue().toString(),
        getNext().toString());
    }
  }
}

保存基于节点的链接列表

2 个答案: