题解 | #链表相加(二)#

1、反转俩个链表

2、判断俩个链表分别为null的情况

3、计算俩个链表正常存在的情况

4、用flag记录进位的数字，由于是加法，所以最多也是进位1；

5、x.next = temp;把算出来的当前位数链接到链表上

6、x = x.next;每个循环最后进行进位

7、循环完后，如果还有最后的进位越需要链接上

8、反转链表，即可得到结果

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head1 ListNode类
     * @param head2 ListNode类
     * @return ListNode类
     */
    public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
        ListNode p = reverse(head1);
        ListNode q = reverse(head2);
        ListNode result = new ListNode(-1);
        ListNode x = result;
        // 是否进位多出
        int flag = 0;
        while (p != null || q != null) {
            if (p == null) {
                ListNode temp = null;
                if (q.val + flag >= 10) {
                    temp = new ListNode((q.val + flag) % 10);
                    flag = 1;
                } else {
                    temp = new ListNode(q.val + flag);
                    flag = 0;
                }
                x.next = temp;
            } else if (q == null) {
                ListNode temp = null;
                if (p.val + flag >= 10) {
                    temp = new ListNode((p.val + flag) % 10);
                    flag = 1;
                } else {
                    temp = new ListNode(p.val + flag);
                    flag = 0;
                }
                x.next = temp;
            } else if (q != null && p != null) {
                ListNode temp = null;
                if (p.val + q.val + flag >= 10) {
                    temp = new ListNode((p.val + q.val + flag) % 10);
                    flag = 1;
                } else {
                    temp = new ListNode(p.val + q.val + flag);
                    flag = 0;
                }
                x.next = temp;
            }

            if (p != null) {
                p = p.next;
            }
            if (q != null) {
                q = q.next;
            }
            // 下一位
            x = x.next;
        }
        // 把最后进位多出的给接上
        if (flag == 1) {
            ListNode t = new ListNode(1);
            x.next = t;
        }
        // 反转链表，得到结果
        return reverse(result.next);
    }

  	// 反转链表 （基础）
    public ListNode reverse(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}