2021-5-2 第二天第二题

两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

输入：l1 = [0], l2 = [0]
输出：[0]

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

Version1 官方答案

public static ListNode addTwoNumbers(ListNode l1, ListNode l2){
        //head为头指针，指向头结点。tail为尾指针，指向最后一个节点。
        ListNode head=null,tail=null;
        //carry表示进位，不进位表示0，进位表示1。
        int carry=0;
        //采用了化同的思想，将不同的情况归结为一种情况————如果一个链表为空，则后续的数值都变为0，这个是该算法最巧妙地地方
        while(l1!=null||l2!=null){
            int a=l1!=null?l1.val:0;
            int b=l2!=null?l2.val:0;
            int sum=a+b+carry;
            //分为2种情况：第一次插入，则给头指针和为指针赋值；非第一次插入，给尾指针赋值即可。
            if(head==null){
                head=new ListNode(sum%10);
                tail=head;
            }else {
                tail.next=new ListNode(sum%10);
                tail=tail.next;
            }
            carry=sum/10;
            //注意：在指向下一个节点时，判断是否为空
            if(l1!=null){
                l1=l1.next;
            }
            //注意：在指向下一个节点时，判断是否为空
            if(l2!=null){
                l2=l2.next;
            }
        }
        //这是最后一位进行求和运算后，通过carry判断是否产生进位。如果产生进位，需要重新新建节点，插入为节点后面；如果没有产生进位，则不作其他处理。
        if(carry>0){
            tail.next=new ListNode(carry);
        }
        return head;
    }

执行用时：2 ms, 在所有 Java 提交中击败了100.00% 的用户

内存消耗：38.9 MB, 在所有 Java 提交中击败了47.67% 的用户

version2

	public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //以下代码不用写，下面的逻辑已经包含了为空的情况了。
        /*if(l1==null||l2==null){
            return l1==null?l2:l1;
        }*/
        int len1=getLen(l1);
        int len2=getLen(l2);
        //比较l1和l2链表长度的大小，短链表赋值给s，长链表赋值给l。并且用长链表存储相加结果后的每位值。
        ListNode s=len1<=len2?l1:l2;
        ListNode l=s==l1?l2:l1;
        //存储长链表的头结点，用来返回头结点。
        ListNode head=l;
        //last是用来存储最后一个进位1的上一个位置。如果最高进位为1，则将last的next指向1节点。如果最高位为0，则不做处理。
        ListNode last=null;
        //carry：存储进位
        int carry=0;
        //总共分为3种情况：
        //1.两个链表的对应位都有值。
        //2.短链表加完了，只剩下长链表。
        //3.长链表也计算完了，只剩下最高进位。
        
        //1.两个链表的对应位都有值。
        while(s!=null&&l!=null){
            int sum=s.val+l.val+carry;
            l.val=sum%10;
            carry=sum/10;
            s=s.next;
            last=l;
            l=l.next;
        }
        //2.短链表加完了，只剩下长链表。
        while(l!=null){
            int sum=l.val+carry;
            l.val=sum%10;
            carry=sum/10;
            last=l;
            l=l.next;
        }
        //3.长链表也计算完了，只剩下最高进位。
        if(carry==1){
            last.next=new ListNode(1);
        }
        return head;
    }

	//getLen函数为了获取链表的长度。
    public int getLen(ListNode head){
        int size=0;
        while(head!=null){
            size++;
            head=head.next;
        }
        return size;
    }

总结

1. 如果出现一个链表为空，另一个链表不为空，可以将空的地方都设置为0，方便操作。
2. 将**（l1不为空）和（l1为空，但l2不为空）**两种情况通过或||运算符进行整合操作。
3. 注意最后最高位相加，产生进位的情况，要在创建一个节点，保存最高位。