1. 问题描述
给定两个非空链表，它们分别表示两个非负整数。链表中的每个节点包含一个数字位，并且数字位是前向存储的（即最高位在链表头部）。目标是将这两个数字相加，并以链表形式返回它们的和。例如，链表 2 -> 4 -> 3 表示数字 243，链表 5 -> 6 -> 4 表示数字 564。它们的和应为 8 -> 0 -> 7，表示 807。
链表节点的定义如下：
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; }
}2. 原始方法分析与常见陷阱
在解决这类问题时，初学者常会尝试直接使用递归或迭代从链表头部开始处理。然而，由于数字是前向存储的，这意味着链表的头部是最高位，尾部是最低位。数字相加的进位是从低位（个位）向高位（十位、百位等）传播的。这与链表的自然遍历方向（从头到尾）是冲突的，导致直接的头部开始相加变得复杂。
考虑以下原始的递归尝试：
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode head = new ListNode(0); // 初始头节点
// 尝试从 l1.next, l2.next 开始递归，并传递 head.next 作为结果链表的起始
// 这里的 l1.next 和 l2.next 可能会导致跳过第一个数字
head.val = generateSumList(l1.next, l2.next, head.next); // 错误：返回值是进位，而不是节点值
return head; // 错误：head.val 可能被赋予一个进位，且 head.next 仍为 null
}
public int generateSumList(ListNode l1, ListNode l2, ListNode res) {
int rest, sum;
// 处理链表长度不一致的情况，但逻辑上未能正确对齐
if (l1.next == null && l2.next != null) {
return generateSumList(l1, l2.next, res.next); // 错误：res.next 可能是 null
}
if (l1.next != null && l2.next == null) {
return generateSumList(l1.next, l2, res.next); // 错误：res.next 可能是 null
}
// 递归基：当两个链表都到达末尾时
if (l1.next == null && l2.next == null) {
sum = l1.val + l2.val;
if (sum > 9) {
ListNode n = new ListNode(sum % 10, null);
res = n; // 错误：res 是参数的局部拷贝，无法修改外部链表结构
return 1;
} else {
ListNode n = new ListNode(sum, null);
res = n; // 错误：同上
return 0;
}
}
// 递归调用
rest = generateSumList(l1.next, l2.next, res.next); // 错误：res.next 可能是 null
sum = l1.val + l2.val + rest;
if (sum > 9) {
res.val = sum % 10; // 错误：res 可能是 null
return 1;
} else {
res.val = sum; // 错误：res 可能是 null
return 0;
}
}
}2.1 NullPointerException 的原因
上述代码在运行时会抛出 java.lang.NullPointerException: Cannot read field "next" because "
具体分析：
- 在 addTwoNumbers 方法中，ListNode head = new ListNode(0); 创建了一个节点，其 next 成员默认为 null。
- 接着调用 generateSumList(l1.next, l2.next, head.next);。这里的 head.next 是 null，所以 generateSumList 方法中的 res 参数在第一次调用时就是 null。
- 在 generateSumList 内部，如果 l1.next 和 l2.next 都不为 null，代码会执行 rest = generateSumList(l1.next, l2.next, res.next);。此时，由于 res 是 null，访问 res.next 就会导致 NullPointerException。
2.2 逻辑上的根本缺陷
即使解决了 NullPointerException，这种递归方法也存在根本性的逻辑错误：
- 链表对齐问题：当两个输入链表长度不一致时，例如 l1 = [1,2,3] 和 l2 = [4,5]，直接从头部开始递归，l1.val 和 l2.val 对应的是 1 和 4（百位），但实际上它们应该分别与 4（十位）和 5（个位）对齐。数字相加需要从最低位开始，而前向存储的链表最低位在尾部。
- 进位传播方向：进位是从低位向高位传播的。对于前向存储的链表，这意味着进位从链表尾部向头部传播。直接从头部开始的递归或迭代难以在正确的时间点获取到前一位的进位。
- 局部变量与链表结构修改：在递归基中，res = n; 这样的赋值操作只会改变局部变量 res 的指向，而不会影响到上层调用中 res.next 所指向的实际链表结构。因此，无法通过这种方式构建出完整的链表。
3. 正确解法策略
解决前向存储链表数字相加问题的核心在于如何处理进位方向与链表遍历方向的冲突。主要有两种策略：
3.1 策略一：反转链表，相加，再反转结果 (推荐)
这是最直观且易于实现的方法，它将“前向存储”问题转化为“反向存储”问题，后者有标准的解法。
步骤：
-
反转两个输入链表：将 l1 和 l2 分别反转，使得它们的头部变为最低位（个位）。
- 例如：2 -> 4 -> 3 变为 3 -> 4 -> 2。
- 按位对反转后的链表进行相加：这现在是一个标准的“两数相加，数字反向存储”问题。从头开始遍历两个反转后的链表，逐位相加，处理进位，并构建一个新的结果链表。这个结果链表也将是反向存储的（最低位在头部）。
- 反转结果链表：将步骤2中得到的和链表再次反转，使其恢复到前向存储的顺序，即最高位在头部。
优点：逻辑清晰，易于理解和实现。 缺点：需要三次链表遍历操作（两次反转输入，一次相加，一次反转结果），空间复杂度为 O(N+M) 用于存储反转后的链表和结果链表，时间复杂度为 O(N+M)，其中 N 和 M 是两个链表的长度。
3.2 策略二：使用栈辅助
此方法通过栈的LIFO（后进先出）特性来“反转”链表的遍历顺序，从而在逻辑上从低位开始处理。
步骤：
- 将链表数字压入栈：遍历 l1 和 l2，将每个节点的 val 依次压入两个独立的栈中。这样，栈顶元素就代表了数字的最低位。
- 从栈中弹出数字进行相加：同时从两个栈中弹出数字进行相加，并处理进位。
- 构建结果链表：每次相加得到一个位和进位后，创建一个新的节点，将其值设置为位和，并将其插入到结果链表的头部（或作为当前结果链表的 next）。由于我们是从低位到高位处理的，每次新创建的节点都应该成为当前结果链表的头部，这样才能保证最终链表是前向存储的。
优点：避免了实际修改原始链表结构。 缺点：需要额外的 O(N+M) 空间用于栈存储。时间复杂度为 O(N+M)。
3.3 策略三：递归与填充（进阶）
这种方法无需反转链表或使用额外栈，但实现起来更为复杂。它通常涉及以下步骤：
- 计算链表长度：确定两个链表的长度。
- 对齐链表：通过在较短链表的头部“填充”零（逻辑上或通过创建虚拟节点）来使两个链表等长。
- 递归求和：编写一个递归函数，从链表头部开始，递归地处理子链表，并返回一个包含当前位和进位的结构（例如一个数组或自定义对象）。当递归调用返回时，将进位传递给上层（高位）计算。
- 处理最终进位：如果最高位还有进位，需要创建一个新的头节点。
这种方法代码量较大，且递归返回进位并构建链表头部需要巧妙设计，对于初学者来说难度较高，本文不再提供详细代码示例。
4. 示例代码：反转链表法
这里我们采用策略一，提供详细的 Java 代码实现。
// 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 {
/**
* 辅助函数：反转一个链表
* @param head 链表头节点
* @return 反转后的链表头节点
*/
private ListNode reverseList(ListNode head) {
ListNode prev = null; // 指向前一个节点
ListNode curr = head; // 指向当前节点
while (curr != null) {
ListNode nextTemp = curr.next; // 暂存下一个节点
curr.next = prev; // 当前节点的next指向前一个节点，完成反转
prev = curr; // prev向前移动到当前节点
curr = nextTemp; // curr向前移动到下一个节点
}
return prev; // prev最终指向原链表的尾部，即反转后的头部
}
/**
* 辅助函数：相加两个数字反向存储的链表
* （即最低位在头部，最高位在尾部）
* @param l1 第一个链表
* @param l2 第二个链表
* @return 和链表，也是反向存储的
*/
private ListNode addTwoNumbersReversed(ListNode l1, ListNode l2) {
ListNode dummyHead = new ListNode(0); // 哨兵头节点，方便处理结果链表
ListNode current = dummyHead; // 用于构建结果链表的当前指针
int carry = 0; // 进位
// 当两个链表都遍历完且没有进位时，循环结束
while (l1 != null || l2 != null || carry != 0) {
int x = (l1 != null) ? l1.val : 0; // 获取l1当前节点值，若为null则为0
int y = (l2 != null) ? l2.val : 0; // 获取l2当前节点值，若为null则为0
int sum = x + y + carry; // 计算当前位的和
carry = sum / 10; // 计算新的进位
current.next = new ListNode(sum % 10); // 创建新节点，值为当前位的数字
current = current.next; // 移动current指针
if (l1 != null) l1 = l1.next; // 移动l1指针
if (l2 != null) l2 = l2.next; // 移动l2指针
}
return dummyHead.next; // 返回实际结果链表的头部
}
/**
* 主函数：相加两个数字前向存储的链表
* @param l1 第一个链表
* @param l2 第二个链表
* @return 和链表，前向存储
*/
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
// 步骤1: 反转两个输入链表
ListNode reversedL1 = reverseList(l1);
ListNode reversedL2 = reverseList(l2);
// 步骤2: 相加反转后的链表（现在是最低位在头部）
ListNode sumReversed = addTwoNumbersReversed(reversedL1, reversedL2);
// 步骤3: 反转和链表，使其恢复到前向存储的顺序
return reverseList(sumReversed);
}
}5. 注意事项与优化
- 空链表处理：虽然题目说明输入链表非空，但在实际应用中，需要考虑输入链表可能为空的情况。reverseList 和 addTwoNumbersReversed 函数能够很好地处理空链表（返回 null 或 dummyHead.next 为 null）。
- 进位处理：carry 变量是关键。在 addTwoNumbersReversed 中，while (l1 != null || l2 != null || carry != 0) 循环条件确保即使所有数字位都处理完毕，如果还有最终进位（例如 [5] + [5] = [1,0]），也能正确创建新节点。
- 空间复杂度：反转链表法需要额外的空间来
