两数相加

两数相加

这是一道来自leetcode的算法题目。

题目描述

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

算法实现

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

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        # pointer1=l1
        # pointer2=l2
        res=ListNode(-1)
        pointer3=res
        temp=0
        # test=pointer1
        while l1 or l2:
            number1=0 if l1==None else l1.val
            number2=0 if l2==None else l2.val
            s=temp+number1+number2
            pointer3.next=ListNode((s)%10)
            pointer3=pointer3.next
            temp=(s)//10
            # if pointer1 and  pointer1.next==None:
            #     test=pointer1
            if l1!=None:
                l1=l1.next
            if l2!=None:
                l2=l2.next
        if temp!=0:
            pointer3.next=ListNode(1)
        return res.next

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode AddTwoNumbers(ListNode l1, ListNode l2) {
        
    

            //定义返回值
            var result = new ListNode(-1);
            //定义循环用的对象，将形参制定到temp
            var temp = result;
            //前一轮数字和的十位数
            int Other = 0;
         while(l1!=null||l2!=null)
         {
             int num1=l1==null?0:l1.val;
             int num2=l2==null?0:l2.val;
             int sum=num1+num2+Other;
             temp.next=new ListNode(sum%10);
             temp=temp.next;
             Other=sum/10;
             if(l1!=null)l1=l1.next;
             if(l2!=null)l2=l2.next;
         }
        if(Other>0)
            temp.next=new ListNode(Other);
   
        return result.next;
}
}

实验结果

python算法实现

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

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        # pointer1=l1
        # pointer2=l2
        res=ListNode(-1)
        pointer3=res
        temp=0
        # test=pointer1
        while l1 or l2:
            number1=0 if l1==None else l1.val
            number2=0 if l2==None else l2.val
            s=temp+number1+number2
            pointer3.next=ListNode((s)%10)
            pointer3=pointer3.next
            temp=(s)//10
            # if pointer1 and  pointer1.next==None:
            #     test=pointer1
            if l1!=None:
                l1=l1.next
            if l2!=None:
                l2=l2.next
        if temp!=0:
            pointer3.next=ListNode(1)
        return res.next

# 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:
        a=l1
        b=l2
        other=0
        result=ListNode(0)
        temp=result
        while a or b:
            val=(a.val if a else 0)+( b.val if b else 0)+other
            other=int (val/10)
            temp.next=ListNode(int(val%10))
            a=a.next if a else None
            b=b.next if b else None
            temp=temp.next
        if(other>0):
            temp.next=ListNode(1)
        return result.next

就是建立一个新的链表然后从个位数一个个加进去就好了。
需要注意的一点时要考虑两个数字位数不同的情侣，即一个链表还没遍历完，一个已经遍历完了。
可以多加一个判断，如果已经遍历完了读取其val时加个判断，直接让这个数为零。

递归

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

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        def add(pointer1,pointer2,carry):
            if pointer1==None and pointer2==None:
                return ListNode(1) if carry!=0 else None
            pointer1=pointer1 if pointer1 else ListNode(0)
            pointer2=pointer2 if pointer2 else ListNode(0)
            s=pointer1.val+pointer2.val+carry
            carry=s//10
            pointer1.val=s%10
            pointer1.next=add(pointer1.next,pointer2.next,carry)
            return pointer1
        return add(l1,l2,0)

**

疑问

**

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

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        a=l1
        b=l2
        other=0
        while a or b:
            val=a.val+b.val+other
            other=int (val/10)
            a.val=int (val%10)
            a=a.next if a else None 
            b=b.next if b else None
        if(other>0 ):
            a=ListNode(1)
        return l1

解答

这个地方a是一个单纯的指针，只是 a=ListNode(1)并不能够把这个新的节点连接到了l1上去，只是让a 指向了这个ListNode（1）.