【leetCode】之 Add Two Numbers

以前就写写简单的C程序，可能提交的格式也是cpp，学过数据结构，但也没有接触过链表的程序，看过这道题后，真的感觉C++确实严谨。。。

题目：

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.

Example:

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.

思路：

1、就是相加，只不过进位是向后的，再将数据存入一个链表中，返回链表。

2、当然要注意的就是进位问题，进位值出现再两个链表中间 或者 最后的两位数相加后有进位值的处理过程。

3、还有就是若两个链表长度不同，再出现进位时的处理方法。

Runtime: 56 ms, faster than 10.96% of C++ online submissions for Add Two Numbers.

Memory Usage: 18.7 MB, less than 100.00% of C++ online submissions for Add Two Numbers.

我的程序运行后的结果如上，感觉有点时间换空间。。。

先贴C++代码：

​
/**
 * 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 *l = NULL;
        ListNode *ll = l;
        ListNode *L1 = l1,*L2 = l2;
        int k;

        //处理两个链表前面的可相加部分
        for(k=0;L1 != NULL && L2 != NULL;L1 = L1->next,L2 = L2->next){
            L1->val = L1->val + L2->val + k; //k表示进位
            k=L1->val / 10;
            L1->val = L1->val % 10;
            if(ll != NULL)
                ll->next = L1;
            else{
                l = L1;
                ll = l;
            }
            ll = L1;
        }

        //当L1链表长时（注意进位）
        while(L1 != NULL){
            L1->val = L1->val + k;
            k = L1->val / 10;
            L1->val = L1->val % 10;
            if(ll != NULL)
                ll->next = L1;
            else{
                l = L1;
                ll = l;
            }
            ll = L1;
            L1 = L1->next;
        }

        //L2链表长
        while(L2 != NULL){
            L2->val = L2->val + k;
            k = L2->val / 10;
            L2->val = L2->val % 10;
            if(ll != NULL)
                ll->next = L2;
            else{
                l = L2;
                ll = l;
            }
            ll = L2;
            L2 = L2->next;
        } 
        
        //若两链表处理结束后还有进位值，则需申请空间，并将值至于待返回链表末尾
        if(k){
            ListNode *temp=new ListNode(k);
            temp->val=k;
            ll->next=temp;
            ll=temp;
        }
        ll->next = NULL;
        return l;
    }
};

​

改进下;

Runtime: 48 ms, faster than 71.19% of C++ online submissions for Add Two Numbers.

Memory Usage: 19.2 MB, less than 51.07% of C++ online submissions for Add Two Numbers.

​
/**
 * 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 *ll1 = l1,*ll2 =l2 ;
        ListNode *l = NULL ;
        ListNode *ll = l ;
        int k=0; //存储进位信息
        
        while(ll1 != NULL || ll2 != NULL){
            ListNode *temp = new ListNode(0) ;
            if(l == NULL) l = temp ;
            
            if(ll1 == NULL){
                k = ll2->val + k ;
                temp->val = k % 10 ;
                k = k / 10 ;
            }
            
            if(ll2 == NULL){
                k = ll1->val + k ;
                temp->val = k % 10 ;
                k = k / 10 ;
            }
            
            if(ll1 != NULL && ll2 != NULL){
                k = ll1->val + ll2->val + k ;
                temp->val = k % 10 ;
                k = k / 10 ;
            }
            if(ll != NULL)
                ll->next = temp ;
            ll = temp ;
            if(ll1 != NULL)
                ll1 = ll1->next ;
            if(ll2 != NULL)
                ll2 = ll2->next ;
        }
        
        if(k != 0){
            ListNode *temp = new ListNode(k) ;
            ll->next = temp ;
            ll = ll->next ;
        }
        
        ll->next = NULL;
        return l;
    }
};

​

python3:

Runtime: 100 ms

Memory Usage: 12.5 MB

时间耗时有点长。。。

​
​
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def addTwoNumbers(self, l1: 'ListNode', l2: 'ListNode') -> 'ListNode':
        
        k=0
        res = ListNode(None)
        l = res
        
        while(l1 != None or l2 != None):
            if l1 == None:
                _sum = k + l2.val 
            
            if l2 == None:
                _sum = k + l1.val
                
            if l1 !=None and l2 != None:
                _sum = k + l1.val + l2.val
                
            ll = ListNode(_sum % 10)
            k = _sum // 10     #整除为 //，/为非整除
            
            if res.val == None:
                res.val = ll.val
            else:
                l.next = ll
                l = l.next
            
            if l1 !=None:
                l1 = l1.next
            if l2 != None:
                l2 = l2.next
                
        if k :
            ll = ListNode(k)
            l.next = ll
            l = l.next
        return res
            

​

​