兩數相加

You are given two non-empty linked lists representing two non-negative integers. 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.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

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

大致意思：給定兩個非空的鏈表代表兩個非負整數，數字在鏈表中以倒序存儲（意思就是好比如存儲整數342，在鏈表中是2->4->3），鏈表中的每個結點存儲一個數字。計算兩個數字的和并以鏈表的形式返回。

約定兩個數字不包含頭部0的數字，除了0他本身。

常規解法：首先依次遍歷兩個鏈表，找到最長的那個鏈表作為主鏈表，每次遍歷鏈表中的元素進行相加結果覆蓋住鏈表中的值，最后短的鏈表遍歷完后檢查進位情況看是否在主鏈表中添加新的結點。這種方法比較通俗易懂，但是時間復雜度特別高。

/**
 * 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) {
        ListNode *head=retLongList(l1,l2);
        ListNode *one=head;
        ListNode *two=NULL;
        if(one==l1)
        {
            two=l2;
        }
        else
        {
            two=l1;
        }
        int zv=0;
        while(one!=NULL && two!=NULL)
        {
            zv=(one->val+two->val)/10;
            one->val+=two->val;
            ListNode* fir=one;
            ListNode* sec=two;
            while(zv>0)
            {
                fir->val%=10;
                if(fir->next==NULL)
                {
                    fir->next=new ListNode(1);
                    fir->next->val=0;
                    fir->next->next=NULL;
                }
                fir->next->val+=zv;
                zv=fir->next->val/10;
                fir=fir->next;
            }
            one=one->next;
            two=two->next;
        }
        return head;
    }
    ListNode* retLongList(ListNode* l1, ListNode* l2)
    {
        ListNode* first=l1;
        ListNode* second=l2;
        while(1)
        {
            if(l1->next==NULL && l2->next==NULL)
            {
                return first;
            }
            else if(l1->next==NULL && l2->next!=NULL)
            {
                return second;
            }
            else if(l1->next!=NULL && l2->next==NULL)
            {
                return first;
            }
            else
            {
                l1=l1->next;
                l2=l2->next;
            }
        }
    }
};

其他解法：分別遍歷兩個鏈表，用一個變量表示是否有進位。某一個鏈表遍歷完后，再將另一個鏈表沒遍歷完的連接在結果鏈表之后，如果最后有進位需要添加一個結點。時間復雜度較低。

class Solution {  
public:  
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {  
        int carry = 0;  
        ListNode* tail = new ListNode(0);  
        ListNode* ptr = tail;  
        while(l1 != NULL || l2 != NULL){  
            int val1 = 0;  
            if(l1 != NULL){  
                val1 = l1->val;  
                l1 = l1->next;  
            }    
            int val2 = 0;  
            if(l2 != NULL){  
                val2 = l2->val;  
                l2 = l2->next;  
            }       
            int tmp = val1 + val2 + carry;  
            ptr->next = new ListNode(tmp % 10);  
            carry = tmp / 10;  
            ptr = ptr->next;  
        }  
        if(carry == 1){  
            ptr->next = new ListNode(1);  
        }  
        return tail->next;  
    }  
};