節點基於鏈表

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。

-------- ----------編輯

以下是本文給出了更容易參考的問題：

現在給你兩個非 - 空鏈表，表示兩個非負數的整數。數字以相反的順序存儲，並且它們的每個節點都包含一個數字。添加這兩個數字並將其作爲 鏈接列表返回。

你可以假設這兩個數字不包含任何前導零，除了 數0本身。

輸入：（2 - > 4 - > 3）+（5 - > 6 - > 4）輸出：7 - > 0 - > 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 - > list1，n - > currentNode，c - >帶。短不好。可讀性很好。

此外，全功能會崩潰時，列表不會具有相同的長度，因爲你始終可以訪問的值都當其中一個可能是空的。你應該去像

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