力扣题（1）：两数相加

原题:
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

该题考查的是对链表的知识，难点是链表对数字的添加是和我们正常的习惯相反的，还有就是考虑进位的事情，下面我将用两种方法来解题：

1. 官方给出的解法，充分利用链表的思想解出来（太妙了，我反正想不出来，只能死记硬背了）：我将官方给出的代码每一步都写了我自己理解的注解

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //定义头部节点，尾部节点
        ListNode head=null,tail=null;
        //定义进位数字
        int carry=0;
        while(l1!=null||l2!=null){
            //如果l1 != null,就取l1的节点数据赋值给n1,如果l1为空节点，直接将0赋值给n1
            int n1 = l1 != null ? l1.val : 0;
            //n2类似，我们要判断的是节点数据的取值问题
            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;
            }
            //取两个节点数字相加的和（应该是一个小于20的整数）的十位数,将其赋值给carry
            carry = sum / 10;
            //如果链表l1有值，那么遍历l1的下一个值
            if(l1!=null){
                l1 = l1.next;
            }
            //与l1相似，比如西安判断头节点肯定是个位数，个位数判断完就是next指向的十位数
            if(l2!=null){
                l2 = l2.next;
            }
        }
        //两数相加大于10
        if(carry > 0){
            //向后一位进一
            tail.next = new ListNode(carry);
        }
        return head;
    }
}

2. 将链表中的每一位数字拼接成整数，再将两个拼接好的整数相加，再将整数拼回成一个新的链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    //将链表数转换为整数
    public static long listToLong(ListNode l){
        //定义最终转换的整数
        long sum = 0;
        //定义倍数
        long power = 1;
        while(l!=null){
            //从个位开始加
            sum += l.val * power;
            l = l.next;
            power *= 10;
        }
        return sum;
    }
    //将整数转换为链表
    public static ListNode longToList(long num){
        //排除没有的数字的情况
        if(num==0){
            return new ListNode(0);
        }
        //初始化链表的头尾指针
        ListNode head = null, tail = null;
        while(num>0){
            int digit = (int)(num % 10);
            //判断是否是头指针
            if(head==null){
                head = tail = new ListNode(digit);
            }else{
                tail.next = new ListNode(digit);
                tail = tail.next;
            }
            num /= 10;
        }
        return head;
    }
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        long n1 = listToLong(l1);
        long n2 = listToLong(l2);
        long n = n1+n2;
        return longToList(n);
    }
}

总结：

• 该题本身并不复杂，无非就是两个数的相加，难就难在要结合链表的只是对已经拼进链表的数字，呈现倒序的单个数字进行相加，但是只要深入了解了数据结构中链表的基础知识，那么解决它也没有那么困难，当然，我只是学会了之后才这么说（有点小羞耻）。
• 当然，方法2并不完美，虽然long类型的数字可以占8个字节但是，如果输入的数据n有以下情况：
• n<（-2^63）
  |
  n>(2^63)
  那么也会报错，如下
  
  所以，归根结底，还是要熟练理解第一种方法，该题本质就是让熟悉链表。