LeetCode - Add Two Numbers

LeetCode - Add Two Numbers

2013.12.1 21:03

You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8

Solution:

　　Given two number represented as single-linked list, add them up and return the sum as a list in similar form.

　　It seems easy enough, but you have to take care of different cases, mainly the following:

　　　　1. NULL list

　　　　2. the lengths of two lists are different

　　　　3. 999 + 111 = 1110, the sum list needs one more digit

　　Add up both 'numbers' one digit at a time, and record the carry for each digit. Make sure you write your code carefully, especially because this is linked list, the tricky thing.

　　Time complexity is O(max(m, n)) where m and n are lengths of both linked lists. Space complexity is O(1) with some extra variables.

Accepted code:

// 2WA, 1RE, 1AC, not so easy..
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        
        if(l1 == nullptr || l2 == nullptr){
            return nullptr;
        }
        
        ListNode *head;
        ListNode *ptr, *p1, *p2;
        bool first;
        ListNode *par1, *par2, *par;
        ListNode *r1, *r2, *rr;
        int carry;
        
        p1 = l1;
        p2 = l2;
        
        carry = 0;
        
        r1 = par1 = new ListNode(0);
        r2 = par2 = new ListNode(0);
        rr = par = new ListNode(0);
        
        par1->next = l1;
        par2->next = l2;
        par->next = nullptr;
        
        first = true;
        //while(p1 != nullptr && p2 != nullptr){
        // 1WA here, {1,8}, {0}
        while(p1 != nullptr || p2 != nullptr){
            ptr = new ListNode(0);
            if(p1 != nullptr){
                ptr->val += p1->val;
            }
            if(p2 != nullptr){
                ptr->val += p2->val;
            }
            /*
            1WA here, wrong if statement
            if(p1 != nullptr){
                ptr->val += carry;
            }
            */
            ptr->val += carry;

            par->next = ptr;
            par = par->next;
            if(p1 != nullptr){
                par1 = par1->next;
            }
            if(p2 != nullptr){
                par2 = par2->next;
            }

            if(first){
                head = ptr;
                first = false;
            }
            
            if(ptr->val >= 10){
                ptr->val -= 10;
                carry = 1;
            }else{
                carry = 0;
            }
            
            if(p1 != nullptr){
                p1 = p1->next;
            }
            if(p2 != nullptr){
                p2 = p2->next;
            }
            ptr = ptr->next;
        }
        if(carry){
            ptr = new ListNode(1);
            par->next = ptr;
        }
        
        // 1RE here, parent pointer moved, must have an extra pointer to record the parent node on the front
        delete r1;
        delete r2;
        delete rr;
        
        return head;
    }
};