力扣题之两数相加

2.两数相加（传送门）

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

因为相同位置的数加起来会涉及到该节点下一个节点数据的改变，
所以我选用集合ArrayList辅助解决问题（有点笨了）
但是还是那句话，自己依靠自己的思路来一遍，会提升我们的编码手感

代码：

 /**
 * 2. 两数相加
 */
public class Solution {
    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //1. 声明一个头节点，作为连接后续结果链表的头节点
        ListNode head = new ListNode();
        //2. 定义一个辅助节点，因为后面需要遍历链表
        ListNode temp = head;
        //3. 声明链表l1对应的list1集合
        //   声明链表l2对应的list2集合
        //   声明结果链表对应的result集合
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        ArrayList<Integer> result = new ArrayList<>();
        //4. 将链表l1的元素存入list1
        while (l1 != null) {
            list1.add(l1.val);
            l1 = l1.next;
        }
        //5. 将链表l2的元素存入list2
        while (l2 != null) {
            list2.add(l2.val);
            l2 = l2.next;
        }
        //6. 接着考虑到两个相应位置的元素需要相加操作，但又不能空指针异常
        //   对两集合的元素分情况进行0数字的补充
        if (list1.size() > list2.size()) {
            int num = list1.size() - list2.size();
            for (int i = 0; i < num; i++) {
                list2.add(0);
            }
        }
        if (list1.size() < list2.size()) {
            int num = list2.size() - list1.size();
            for (int i = 0; i < num; i++) {
                list1.add(0);
            }
        }
        //7. 各相应位置相加，并添加入result集合
        for (int i = 0; i < list1.size(); i++) {
            int sum = list1.get(i) + list2.get(i);
            result.add(sum);
        }
        //8. 这一步很重要如果存在进位情况，其实我们的result集合就会越界，故手动扩容1
        result.add(0);
        //9. 审核result集合的每一个位置，大于10的进位，并改变自身
        for (int i = 0; i < result.size(); i++) {
            if (result.get(i) >= 10) {
                result.set(i + 1, result.get(i + 1) + 1);
                result.set(i, result.get(i) - 10);
            }
        }
        //10. 有的最后会进位，有的却不会，所以判断最后一个元素是否为0，决定是否移除
        if (result.get(result.size() - 1) == 0) {
            result.remove(result.size() - 1);
        }
        //11. 将result集合元素，以链表形式表现
        for (Integer integer : result) {
            temp.next = new ListNode(integer);
            temp = temp.next;
        }
        //12. 返回结果链表的头节点
        return head.next;
    }

思考一下，当数据多的情况会产生数组的扩容现象，而扩容会涉及到数据的复制迁移，所以我们是否可以对上述代码进行优化？
（尽管测试之后发现并没有表面的提升，但是思想没毛病）
写到这了，就可以看看大佬们的牛逼代码了，我去学学

    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //1. 声明一个头节点，作为连接后续结果链表的头节点
        ListNode head = new ListNode();
        //2. 定义一个辅助节点，因为后面需要遍历链表
        ListNode temp = head;
        //新增优化代码：获取两个链表中数据的多少
        int size1 = 0;
        int size2 = 0;
        ListNode temp1 = l1;
        ListNode temp2 = l2;
        while (temp1 != null) {
            temp1 = temp1.next;
            size1++;
        }
        while (temp2 != null) {
            temp2 = temp2.next;
            size2++;
        }
        int size = Math.max(size1, size2);
        //3. 声明链表l1对应的指定大小的list1集合
        //   声明链表l2对应的指定大小的list2集合
        //   声明结果链表对应的指定大小的result集合
        ArrayList<Integer> list1 = new ArrayList<>(size);
        ArrayList<Integer> list2 = new ArrayList<>(size);
        ArrayList<Integer> result = new ArrayList<>(size + 1);
        //4. 将链表l1的元素存入list1
        while (l1 != null) {
            list1.add(l1.val);
            l1 = l1.next;
        }
        //5. 将链表l2的元素存入list2
        while (l2 != null) {
            list2.add(l2.val);
            l2 = l2.next;
        }
        //6. 接着考虑到两个相应位置的元素需要相加操作，但又不能空指针异常
        //   对两集合的元素分情况进行0数字的补充
        if (list1.size() > list2.size()) {
            int num = list1.size() - list2.size();
            for (int i = 0; i < num; i++) {
                list2.add(0);
            }
        }
        if (list1.size() < list2.size()) {
            int num = list2.size() - list1.size();
            for (int i = 0; i < num; i++) {
                list1.add(0);
            }
        }
        //7. 各相应位置相加，并添加入result集合
        for (int i = 0; i < list1.size(); i++) {
            int sum = list1.get(i) + list2.get(i);
            result.add(sum);
        }
        //8. 这一步很重要如果存在进位情况，其实我们的result集合就会越界，故手动扩容1
        result.add(0);
        //9. 审核result集合的每一个位置，大于10的进位，并改变自身
        for (int i = 0; i < result.size(); i++) {
            if (result.get(i) >= 10) {
                result.set(i + 1, result.get(i + 1) + 1);
                result.set(i, result.get(i) - 10);
            }
        }
        //10. 有的最后会进位，有的却不会，所以判断最后一个元素是否为0，决定是否移除
        if (result.get(result.size() - 1) == 0) {
            result.remove(result.size() - 1);
        }
        //11. 将result集合元素，以链表形式表现
        for (Integer integer : result) {
            temp.next = new ListNode(integer);
            temp = temp.next;
        }
        //12. 返回结果链表的头节点
        return head.next;
    }