2.两数相加

 

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) {
        if(l1==NULL) return l2; // 初始化判定，l1是空，无论l2是否空都返回l2
        if(l2==NULL) return l1; // 同上　l2为空，　返回l1
        ListNode* p = l1; // 定义两个节点　p, q
        ListNode* q = l2;
        int l1_length = 0;  
        int l2_length = 0;
        while(p){         //计算l1的长度
            l1_length++;
            p = p->next;
        }
        while(q){　　　　　//计算l2的长度
            l2_length++;
            q = q->next;
        }
        
        if(l1_length>l2_length){　//长的指向p, 短的指向q
            p = l1;
            q = l2;
        }else{
            p = l2;
            q = l1;
        }
        int carry = 0;
        while(q){　//遍历短的
            int Sum = p->val + q->val + carry;　//计算当前位置总和
            p->val = Sum % 10;　　//计算当前位置值，　并赋予长链表
            carry = (Sum-(Sum%10)) / 10;　//计算越位值
            if(p->next == NULL && carry > 0)　//防止　p,q长度相等，　越位值最后大于０，　没有链表位置赋值
                p->next = new ListNode(0);//所以这里加个判断条件，符合的话就新建一个节点，用来存储最后一个越位值
            p = p->next;
            q = q->next;
        }

        while(p){　//遍历长端，下面同上，只是计算当前位置和的时候，只考虑越位值，不再有第二个链表值。
            int Sum = p->val + carry;
            p->val = Sum % 10;
            carry = (Sum - p->val) / 10;
            if(p->next == NULL && carry > 0)//依然要考虑最后一位越位值
                p->next = new ListNode(0);
            p = p->next;
        }
        
        return l1_length>l2_length? l1:l2;//返回长链表
    }
};

Python3答案：

# 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:
        re = ListNode(0)
        r=re
        carry=0
        while(l1 or l2):
            x= l1.val if l1 else 0
            y= l2.val if l2 else 0
            s=carry+x+y
            carry=s//10
            r.next=ListNode(s%10)
            r=r.next
            if(l1!=None):l1=l1.next
            if(l2!=None):l2=l2.next
        if(carry>0):
            r.next=ListNode(1)
        return re.next