https://leetcode.com/problems/add-two-numbers/

1. Build a new List:

  1. //32 ms    70.3 MB
  3. /**
  4.  * Definition for singly-linked list.
  5.  * struct ListNode {
  6.  *     int val;
  7.  *     ListNode *next;
  8.  *     ListNode() : val(0), next(nullptr) {}
  9.  *     ListNode(int x) : val(x), next(nullptr) {}
  10.  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
  11.  * };
  12.  */
  13. class Solution {
  14. public:
  15.     ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
  17.         ListNode* dummy = new ListNode(-1);
  18.         ListNode* curr = dummy;
  20.         int carry = 0;
  21.         while(l1 || l2){
  22.             int a = l1 ? l1->val : 0;
  23.             int b = l2 ? l2->val : 0;
  25.             curr->next = new ListNode((a + b + carry) % 10);
  26.             carry = (a + b + carry) / 10;
  28.             l1 = l1 ? l1->next : NULL;
  29.             l2 = l2 ? l2->next : NULL;
  30.             curr = curr->next;
  31.         }
  33.         if(carry!=0)
  34.             curr->next = new ListNode(1);
  36.         return dummy->next;
  37.     }
  38. };
  1. # Definition for singly-linked list.
  2. # class ListNode(object):
  3. #     def __init__(self, val=0, next=None):
  4. #         self.val = val
  5. #         self.next = next
  6. class Solution(object):
  7.     def addTwoNumbers(self, l1, l2):
  8.         """
  9.         :type l1: ListNode
  10.         :type l2: ListNode
  11.         :rtype: ListNode
  12.         """
  14.         dummy = curr = ListNode(-1)
  15.         carry = 0
  17.         while l1 or l2 or carry:
  18.             v1 = v2 = 0
  19.             if l1:
  20.                 v1 = l1.val
  21.                 l1 = l1.next
  22.             if l2:
  23.                 v2 = l2.val
  24.                 l2 = l2.next
  26.             nval = v1 + v2 + carry
  27.             if nval >= 10:
  28.                 carry = 1
  29.             else:
  30.                 carry = 0
  32.             curr.next = ListNode(nval % 10)
  33.             curr = curr.next
  35.         return dummy.next
  1. /**
  2.  * Definition for singly-linked list.
  3.  * type ListNode struct {
  4.  *     Val int
  5.  *     Next *ListNode
  6.  * }
  7.  */
  8. func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
  10.     dummy := &ListNode{}
  11.     curr := dummy
  12.     carry := 0
  14.     for ;(l1 != nil || l2 != nil || carry > 0); curr = curr.Next{
  15.         if l1 != nil{
  16.             carry += l1.Val
  17.             l1 = l1.Next
  18.         }
  19.         if l2 != nil{
  20.             carry += l2.Val
  21.             l2 = l2.Next
  22.         }
  24.         curr.Next = &ListNode{carry % 10, nil}
  25.         /*
  26.         if carry >= 10 {
  27.             carry = 1
  28.         } else {
  29.             carry = 0
  30.         }
  31.         */
  33.         carry /= 10
  35.     }
  37.     return dummy.Next
  38. }