leetcode最火100题详解笔记——第 2 题（两数相加）（不断更新补充中）

---

1. 题目

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

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

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

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

---

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

---

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
`

---

提示：

• 每个链表中的节点数在范围 [1, 100] 内
• 0 <= Node.val <= 9
• 题目数据保证列表表示的数字不含前导零

---

2. 解题思路及算法

• 由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。
• 我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2n1,n2，进位值为 carry，则它们的和为 n1 + n2 + carry
• 其中，答案链表处相应位置的数字为 (n1 + n2 + carry) mod10
• 而新的进位值为$\lfloor \frac{n1+n2+\text{ carry }}{10}\rfloor$

如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。

此外，如果链表遍历结束后，有 carry > 0，还需要在答案链表的后面附加一个节点，节点的值为 carry。

该部分代码为解决该题的核心代码

---

参考代码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) {
    ListNode dummy = new ListNode();
    ListNode curr = dummy;
    int carry = 0;
    while (l1 != null || l2 != null) {
    如果其中有一个到达结尾了，那么这个链表这一位的的数字就为0。
        int x = l1 == null ? 0 : l1.val;
        int y = l2 == null ? 0 : l2.val;
        int total = x + y + carry;
        curr.next = new ListNode(total % 10);
        curr = curr.next;
        //大于10进位
        carry = total / 10;

        if (l1 != null) l1 = l1.next;
        if (l2 != null) l2 = l2.next;
    }
    //如果最后还有进位的话，增加一个节点
    if (carry != 0) curr.next = new ListNode(carry);
    return dummy.next;
    }
}

---

参考代码2：

public class AddTwoNumbers {
	
	//对两个链表进行加和
	public static ListNode addTwoNumbers(ListNode l1, ListNode l2){
		if (l1 == null && l2 == null) return null;
			ListNode dummy = new ListNode(0);
			ListNode cur = dummy;
			
			//定义一个dummy虚节点，用来存放新的链表的头节点
			//定义一个cur指针，用来表示当前正在计算的节点位置
			//定义一个进位变量用来计算需要进位的情况
			int carry = 0;
			while (l1 != null || l2 !=null || carry !=0){
				//当两个链表都到尾处的时候有可能有进位的情况，故需要考虑是否有进位
				int val1 = l1 == null ? 0 : l1.val;
				int val2 = l2 == null ? 0 : l2.val;
				int sum = val1 + val2 + carry;
				cur.next = new ListNode(sum % 10);
				carry = sum / 10;
				//一个节点的计算完成，需要移动cur指针和参与计算的链表的节点位置，进行下一轮计算
				cur = cur.next;
				if (l1 != null) l1 = l1.next;
				if (l2 != null) l2 = l2.next;
			}
			return dummy.next;    // 返回虚拟头节点的后继节点
	}

---

3. 测试代码

public class AddTwoNumbers {
	
	//对两个链表进行加和
	public static ListNode addTwoNumbers(ListNode l1, ListNode l2){
		if (l1 == null && l2 == null) return null;
			ListNode dummy = new ListNode(0);
			ListNode cur = dummy;
			
			//定义一个dummy虚节点，用来存放新的链表的头节点
			//定义一个cur指针，用来表示当前正在计算的节点位置
			//定义一个进位变量用来计算需要进位的情况
			int carry = 0;
			while (l1 != null || l2 !=null || carry !=0){
				//当两个链表都到尾处的时候有可能有进位的情况，故需要考虑是否有进位
				int val1 = l1 == null ? 0 : l1.val;
				int val2 = l2 == null ? 0 : l2.val;
				int sum = val1 + val2 + carry;
				cur.next = new ListNode(sum % 10);
				carry = sum / 10;
				//一个节点的计算完成，需要移动cur指针和参与计算的链表的节点位置，进行下一轮计算
				cur = cur.next;
				if (l1 != null) l1 = l1.next;
				if (l2 != null) l2 = l2.next;
			}
			return dummy.next;    // 返回虚拟头节点的后继节点
	}
		
	
	//定义链表节点
	public static class ListNode{
		int val;
		ListNode next;
		public ListNode(int val){
			this.val = val;
			}	
		public static String print(ListNode l){
			StringBuilder sb = new StringBuilder();
			while (l != null){
				sb.append(l.val);
				l = l.next;
			}
			return sb.toString();
		}
	}
	
	
	
	//对所写算法进行测试，程序执行入口   输入46 +67   输出113  逆序输出311
	
	public static void main(String[] args){
		ListNode l1 = new ListNode(6);
		l1.next = new ListNode(4);
		ListNode l2 = new ListNode(7);	
		l2.next = new ListNode(6);
		System.out.println(ListNode.print(addTwoNumbers(l1,l2)));
	
	}
}

---

输出结果：

311