题目描述：

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

代码：

一、方法一：非递归解法

思路分析：

①首先不处理进位。

创建一个新的链表，存储“和”。定义一个头结点head(用于处理进位时的遍历)和一个临时变量temp(用于求和时遍历链表l1,l2)，把两个链表的对应结点值相加后存入temp.val，temp.next即temp移动分为以下四种情况。

1.1 如果l1的下一个节点 和 l2的下一个节点 都为空，说明两个数字是等长的，同时两个链表都达到末尾，跳出循环。

1.2 如果l1的下一个节点 为空，说明l2的长度大于l1，此时让temp.next指向l2剩下的链，跳出循环。

1.3 如果l2的下一个节点 为空，说明l1的长度大于l2，此时让temp.next指向l1剩下的链，跳出循环。

1.4 如果l1和l2的下一个节点 都不为空，则将l1 = l1.next,l2 = l2.next，此时让temp.next 指向新创建的结点(用于存储下一次求和的值)，并移动temp = temp.next。

②接着处理进位的情况。

2.1 让temp指向头结点

2.2 从头结点开始遍历，当temp=null时跳出循环

2.2.1 判断temp.val是否大于9

=> 如果大于9，则将temp.val%10取余，进位情况处理如下：

=> 如果temp.next不为空，将temp.next.val+1。(主要是数字是0~9，两数相加最大为18，加上进位最大为19，不会超过20，所以进位就是加1)

=> 如果temp.next为空，要创建新的结点存放进位1。

2.2.2 

temp = temp.next
/**
* 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 head = new ListNode();//建立“和”链表的头结点
ListNode temp = head;//定义一个临时变量
//完成两条链表的相加
while(true){
temp.val = l1.val + l2.val;
if(l1.next == null && l2.next == null){
break;//如果两个链表都空了，就退出循环
}else if(l1.next == null){
temp.next = l2.next;//如果链表l1空了，就指向l2剩下的链
break;
}else if(l2.next == null){
temp.next = l1.next;//如果链表l2空了，就指向l1剩下的链
break;
}else{//都非空，移动l1,l2链表，建立新结点
l1 = l1.next;
l2 = l2.next;
temp.next = new ListNode();
temp = temp.next;
}
}
temp = head;//在让临时变量回到“和”链表的头结点
//完成链表每个节点只能存储一位数字的调整,对于大于等于10的结点进行进位处理
while(temp != null){//遍历“和”链表
if(temp.val > 9){
temp.val = temp.val % 10;
if(temp.next != null){//表明当前结点不是最后一个结点
temp.next.val += 1;
}else{//表明当前结点是最后一个结点，需要添加结点存储进位
temp.next = new ListNode(1);
break;
}
}
temp = temp.next;
}
return head;
}
}

二、方法二：递归解法

思路分析：

①对链表l1和l2不等长的需要进行预处理。也就是因为要递归调用，所以很可能递归到某次一个链表已经遍历结束了，另一个链表还有剩余元素。所以要对遍历结束的链表新建“值为0，next为null"的结点来继续两结点相加运算。

②此处进位的处理是让链表的下个元素值直接+1。所以要先处理l1和l2都没有下一个结点的情况。如果两结点相加后值>9，则需要对值进行进位处理。

③ 对于②的其他情况就是：l1或者l2有一条链表不止有一个结点。如果两结点相加后值>9，则进行进位处理，如果l1有下一个结点，则让l1.next.val+1，否则让l2.next+1。处理进位后新建结点存储“和”以及next指向递归函数addTwoNumbers(l1.next,l2.next)。

总结：主要是对进位的处理。直接让下一个结点的值+1。但前提是要确保有下一个结点。同时面对不等长的情况，要记得补空。

/**
* 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) {
//预处理，即将l1和l2链表的长度补齐
if(l1 == null){
l1 = new ListNode(0);
}
if(l2 == null){
l2 = new ListNode(0);
}
if(l1.next == null && l2.next == null){//先分析两个链表只有1个结点的情况
int val = l1.val + l2.val;
if(val > 9){
ListNode node = new ListNode(val%10);
node.next = new ListNode(1);//进位
return node;
}else{
return new ListNode(val);
}
}else{
int val = l1.val + l2.val;
if(val > 9){//对进位进行处理
val = val % 10;
if(l1.next != null){//如果l1的下一个节点非空则让它的值+1进位
l1.next.val += 1;
}else if(l2.next != null){//如果l2的下一个节点非空则让它的值+1进位
l2.next.val += 1;
}
}
ListNode node = new ListNode(val);
node.next = addTwoNumbers(l1.next,l2.next);
return node;
}
}
}

标签：java,temp,val,相加,next,l2,LeetCode02,l1,ListNode