2. 两数相加

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

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

你可以假设除了数字 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]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/add-two-numbers

这题很简单，因为是逆位（例如，示例1是342 + 465），只需要保证最低位相加，高位按需进一。而面对链表，每一个数字现在是一个节点的value值了，两数相加后存入的是新开辟的节点。

步骤：

1. 创建两个指针，头、尾，前者代表一条链表，后者负责加入新的值
2. 两个链表保证一个链表有值便可计算，没有值的那条链表看作之后的所有数都为0
3. 保证进位值是对应数字与上一次进位值之和除以10计算出来的
4. 如果最后进位值大于0，最后再开辟一个节点存储
5. 返回的是头指针即可

C++:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    // 也就是342 + 465 = 807而已
    // 重要思想就是构建的新链表需要有一个尾指针，填入一个节点不光需要两个链表的对应值相加，还需要加上上一次运算的进位值
    // 传入的参数也是头节点
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) 
    {
        ListNode * head = nullptr, *tail = nullptr;// 类似队列了，有头尾指针，头指针保持不动（确定链表），尾指针便于向后插入
        int carry = 0;// 进位值
        
        // 保证全部遍历两个链表，只要有一个链表有值就进行计算
        while (l1 || l2)
        {
            int num1 = l1 ? l1->val : 0;
            int num2 = l2 ? l2->val : 0;
            int sum = num1 + num2 + carry;
            if (head == nullptr)
            {
               head = tail = new ListNode(sum % 10);
            }
            else
            {
                tail->next = new ListNode(sum % 10);
                tail = tail->next;
            }
            carry = sum / 10;// 更新进位值
            if (l1 != nullptr)// 链表值增一
                l1 = l1->next;
            if (l2 != nullptr)
                l2 = l2->next;
        }
        if (carry > 0)
        {
            tail->next = new ListNode(carry);// 最后一次进位保证也是一个节点，例如9 + 8最后进位1
            tail = tail->next;// 最后还是更新了值
        }
        return head;
    }
};

SWIFT:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init() { self.val = 0; self.next = nil; }
 *     public init(_ val: Int) { self.val = val; self.next = nil; }
 *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
 * }
 */
class Solution {
    func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
        var cur1 = l1
        var cur2 = l2
        var carry = 0
        let head : ListNode = ListNode(123)// 别忘记赋初值，并且保证头节点的val不是0（防止误判）
        var tail = head// 类是引用类型，结构体和枚举是值类型，因此可以保证head和tail指向的是同一个对象
        while cur1 != nil || cur2 != nil
        {
            let num1:Int, num2:Int// 如果不指定类型，常量默认为字符串
            // 可选绑定：对于可选值的处理方法（ListNode?）
            // 如果cur1有值，就赋值给常量cur1
            if let cur1 = cur1 
            {
                num1 = cur1.val
            } else {
                num1 = 0
            }
            if let cur2 = cur2 
            {
                num2 = cur2.val
            } else {
                num2 = 0
            }

            var sum = num1 + num2 + carry

            if head.val == 123
            {
                tail.val = sum % 10
            }else
            {
                tail.next = ListNode(sum % 10)
                tail = tail.next!
            }
            carry = sum / 10
            if cur1 != nil
            {
                cur1 = cur1!.next                
            }
            if cur2 != nil
            {
                cur2 = cur2!.next                
            }
        }
        if carry > 0
        {
            tail.next = ListNode(carry)
        }
        return head
    }
}