leetCode——第二题：两数相加

题目

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

思路

依次遍历两个链表，将各位相加。不过需要注意一些问题。
1.没有头结点
2.存在进位，所以我设置了一个flag。
3.哎，不难，看代注释吧。

代码

//链表节点
package leetCode;

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        val = x;
    }
}

public class Two {
    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 结果链表 此处因为结果链表第一个节点初始化为0，所以最后返回的是r.next。不初始化的话，报空指针异常。并不知道其他方法怎么解决这个问题，反正结果出啦来。
        ListNode r = new ListNode(0); 
        // 结果链表的当前指针，因为需要添加节点
        ListNode m = r;     
        // 遍历l1的指针，感觉直接用了l1好像也没问题哈，
        ListNode p = l1;    
        // 遍历l2的指针
        ListNode q = l2;   
        // 进位标志
        boolean flag = false; 
        while (p != null && q != null) {
            //某位相加
            int sum = p.val + q.val;
            //如果前面进位的话，这位的和要+1
            if (flag) {
                sum += 1;
                //为该次进位标志初始化
                flag = false;
            }
            //如果当前位比10大，进位
            if (sum >= 10) {
                //当前位的值
                sum = sum % 10;
                //标志位置为true
                flag = true;
            }
            //new一个节点，加到结果链表上
            ListNode temp = new ListNode(sum);
            m.next = temp;
            //你懂得
            m = m.next;
            p = p.next;
            q = q.next;
        }
        //肯定两个数会存在位数不一样了
        if (p != null) {
            //如果，就比如说 325+12354，他们在第三位（从后往前看）没有进位
            if (!flag) {
                m.next = p;
            }
            //相反进了位
            if (flag) {
                while (p != null) {
                    int sum = p.val + 1;
                    //就比如说1+1999，遇到9继续进位
                    if (sum == 10) {
                        //只能一个节点一个节点的加
                        ListNode temp = new ListNode(0);
                        m.next = temp;
                        m = m.next;
                        p = p.next;
                        //继续进位
                        flag = true;
                        //如果没有进位，比如说1+1919
                    } else {
                        //现将当前节点加入
                        ListNode temp = new ListNode(sum);
                        m.next = temp;
                        m = m.next;
                        p = p.next;
                        //后面的就不用一个一个的加了，就比如说1+1919，此时p指向第二个9（从后往前看），直接把剩下的加到结果链表结尾就行了
                        m.next = p;
                        flag = false;
                        //你不退出的话，p不为空，继续循环，gg,出错
                        break;
                    }
                }
            }
        }
        //同上了
        if (q != null) {
            if (!flag) {
                m.next = q;
            }
            if (flag) {
                while (q != null) {
                    int sum = q.val + 1;
                    if (sum == 10) {
                        ListNode temp = new ListNode(0);
                        m.next = temp;
                        m = m.next;
                        q = q.next;
                        flag = true;
                    } else {
                        ListNode temp = new ListNode(sum);
                        m.next = temp;
                        m = m.next;
                        q = q.next;
                        m.next = q;
                        flag = false;
                        break;
                    }
                }

            }
        }
        //这里是这种情况，比如说1+9999=10000，一直进位，看最近的那个while，最后p或者q为空了，但是还有进位。
        if (flag) {
            ListNode temp = new ListNode(1);
            m.next = temp;
        }
        //前面说了，因为初始了第一个节点，所以...
        return r.next;
    }

    public static void main(String[] args) {
        //测试实例6781+9999=16780
        //加数链表初始化
        // l1
        ListNode l1 = new ListNode(1);
        ListNode q = l1;
        q.next = new ListNode(8);
        q = q.next;
        q.next = new ListNode(7);
        q = q.next;
        q.next = new ListNode(6);
        // l2
        ListNode l2 = new ListNode(9);
        ListNode p = l2;
        p.next = new ListNode(9);
        p = p.next;
        p.next = new ListNode(9);
        p = p.next;
        p.next = new ListNode(9);
        p = p.next;

        ListNode re = new ListNode(0);
        re = Two.addTwoNumbers(l1, l2);
        while (re != null) {
            System.out.println(re.val);
            re = re.next;
        }
    }
}

说明

小菜鸟一只，大佬走开。不知道有没有什么更好的方法。也没找。看到文章乐于分享的小伙伴，感谢评论分享更好的方法。