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;
}