【力扣Top100系列】 —— 两数相加问题

概述： 以为和朋友研究了许久，略显疲惫，对于本篇博客的内容并不是很细致，参考价值不大。

第一版：【和朋友一起研究的答案】

/**
 * 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 pre1=null;
        ListNode pre2=null;
        ListNode p1=l1;
        ListNode p2=l2;
        int flag=0;
        int sum=0;
        if(l1==null || l2==null){
            return l1==null?l2:l1;
        }
        while(p1!=null && p2!=null){
            sum=0;
            if(flag==1){
                p1.val+=1;
                flag=0;
            }
            sum=p1.val+p2.val;
            p1.val+=p2.val;
            if(sum>=10){
                flag=1;
                p1.val-=10;
            }
            pre1=p1;
            pre2=p2;
            p1=p1.next;
            p2=p2.next;
        }
        ListNode p=p1==null?p2:p1;
        if(p==p2){
            pre1.next=p2;
        }
        pre1.val=sum;
        if(pre1.val>=10){
            pre1.val-=10;
            if(pre1.next==null){
                pre1.next=new ListNode();
            }
            ListNode q=pre1.next;
            ListNode preq=q;
            while(q != null && q.val==9){
                q.val=0;
                preq=q;
                q=q.next;
            }
            if(q== null){
                preq.next=new ListNode();
                preq.next.val=1;
            }
            else{
                q.val+=1;
            }
        }
        return l1;


    }
}

• 尽管实现了功能，但是对于其他人来说，这段代码的可读性低，看起来很乱
• 因为始终对于这个题考虑的不够周全，大多都是遇到问题再解决问题
• 下面我来浅述一下这段代码的思路：

对于两数加和，我们把这个结果存储到了sum中，然后继续判断sum是否大于10，如果大于10就将sum减去10，赋值给l1的val。

• 考虑了一种特殊情况，就是当某一个链表为空时，直接返回另一个链表
• 对于第一部分的代码主要是针对两个链表是等长的前提下而言的
• 后面曾多次申请新的空间与指针，看起来很乱，有点累，此处就不继续往下写了

第二版

class Solution {
    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)设置了两个指针，一个头指针 head，一个尾指针 tail。
(2)利用一个while循环就解决了问题。后面添加的判断是对最后一个结点是否进位来判断，如果最后产生了进位，那么再创建一个虚拟节点来保存进位产生的1.
(3)对于链表节点数值加和分成了三部分，两个结点的数值与前面数据产生的进位。
对于这里值的获取真的是很巧妙，通过三目运算符来获取具体的val数值。循环继续执行的条件为这两个链表有一个不为空，对于我们写的代码要求是两个链表都不为空。
现在看来，我们的想法是不合理的，当一个链表已经结束后，对于前面产生的进位，依然会对后面未参与运算的结点的值产生影响。
(4)将数值和保存到sum中，对于是否产生进位以及进位处理之后，原来位置的数值用什么方法赋值。我认为第二版代码中，sum % 10 与 sum / 10 更具有说明问题的意义。
(5)不难看出，对于head指针，只是指向了加和后的链表的头结点。在这段代码中，并没有利用原来的两个链表来保存加和后产生的新链表，而是用两个指针来代替，这样同时也解决了很多不必要的问题。

• 利用 .next 不断生成新的结点
• 对于Java中创建新节点的方式 ：new 链表结构体名(数值)