两数相加

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

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

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

 

示例 1：

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

示例 2：

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

示例 3：

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

解题思路:

1.写的时候是先比较两个链表选出长链表lengthList和短链表shortList，然后另存这个链表头的地址（不是重点，只是作为结果返回）。

2.剩下的就是处理lengthList和shortList，先遍历shortList，与lengthList对应的值进行判断（计算长链表，短链表，进位数三个值相加取余后的值作为长链表的值，第一次相加进位数默认为0，然后判断相加后是否大于等于10设置进位数）。

3.然后再遍历lengthList，方法与遍历shortList类似（只是少加了短链表的值），最后将result返回。

 

解:

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode temp1 = l1;
        ListNode temp2 = l2;
        ListNode lengthList = new ListNode();
        ListNode shortList = new ListNode();
        ListNode result = new ListNode();
        while (temp1.next != null && temp2.next != null) {
            temp1 = temp1.next;
            temp2 = temp2.next;
        }
        if (temp1.next==null) {
            lengthList = l2;
            shortList =l1;
        } else {
            lengthList = l1;
            shortList = l2;
        }
        /**
         * 判断哪个链表长 并且将长链表赋值给result
         */
        result = lengthList;

        /**
         * 判断进位
         */
        int num = 0;

        while (shortList!= null) {
            int lengthListTemp = lengthList.val;
            int shortListTemp = shortList.val;
            lengthList.val = (lengthList.val+shortList.val+num)%10;
            if (lengthListTemp+shortListTemp+num>=10){
                num = 1;
            }else {
                num = 0;
            }
            if (lengthList.next==null && num==1) {
                lengthList.next = new ListNode(1);
                return result;
            }
            lengthList = lengthList.next;
            shortList = shortList.next;
        }

        if (lengthList!=null){
            while (lengthList!= null) {
                int lengthListVal3 = lengthList.val;
                lengthList.val = (lengthList.val+num)%10;
                if (lengthListVal3+num>=10){
                    num = 1;
                }else {
                    num = 0;
                }
                if (lengthList.next==null && num==1) {
                    lengthList.next = new ListNode(1);
                    break;
                }
                lengthList= lengthList.next;
            }
        }

        return result;
    }

官方解:

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    　　ListNode head = null, tail = null;
    　　int carry = 0;
    　　while (l1 != null || l2 != null) {
    　　　　int n1 = l1 != null ? l1.val : 0;
    　　　　int n2 = l2 != null ? l2.val : 0;
    　　　　int sum = n1 + n2 + carry;
    　　　　if (head == null) {
    　　　　　　head = tail = new ListNode(sum % 10);
    　　　　} 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;
    　　　　}
    　　}
    　　if (carry > 0) {
    　　　　tail.next = new ListNode(carry);
    　　}
    　　return head;
}　

 

1.对比官方算法，解题思路的不足：对比完第一印象是觉得自己的算法用的变量实在太多了，例如区分长链表和短链表（光这一步用到的变量就跟官方算法差不多了），其实解题思路的描述还是有问题，因为我刚开始写的时候没有考虑到链表长度相同的情况，在一次次的调试中才意识到了这个问题，所以加了一点小判断。最后就是思路上的问题（差距太大!）。

 

2.官方算法的理解：考虑到了相加的特殊性，将短链表相比长链表缺少的值全部补0，这样只需要处理一次就可以将数据处理干净，这个思路我认为是可以借鉴并且可能在以后能够用的。