【leetcode hot 100】【2】2. 两数相加 【c++ rust go】

题目

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

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

你可以假设除了数字 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
• 题目数据保证列表表示的数字不含前导零

解题思路

这道题要求我们对两个链表进行求和操作，这里假设这两个链表分别是 l1 和 l2。由于题目中给定的是数字的倒序存储方式，因此我们需要从头开始遍历这两个链表，同时维护一个 carry 变量表示进位信息。对于每一位上的数值，我们将 l1 和 l2 上的数值相加，再加上前一位的进位信息，得到当前位上的总和，同时更新进位信息。将当前位上的数值加入到结果链表中，并将结果链表的指针指向下一个节点。如果遍历结束后还有进位，需要将它加入到结果链表的最后一位上。

代码

c++

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int carry = 0;  // 进位信息
        ListNode *result = new ListNode(0);  // 结果链表
        ListNode *current = result;  // 指向结果链表的当前节点
        while (l1 || l2) {  // 遍历 l1 和 l2，直到两个链表均为空
            int val1 = l1 ? l1->val : 0;  // 获取 l1 当前节点上的数值
            int val2 = l2 ? l2->val : 0;  // 获取 l2 当前节点上的数值
            int total = val1 + val2 + carry;  // 计算当前位上的总和
            carry = (total > 9) ? 1 : 0;  // 更新进位信息
            current->next = new ListNode(total % 10);  // 将当前位上的数值加入到结果链表中
            current = current->next;  // 将结果链表的指针指向下一个节点
            if (l1) l1 = l1->next;  // 移动 l1 指针到下一个节点
            if (l2) l2 = l2->next;  // 移动 l2 指针到下一个节点
        }
        if (carry) {  // 如果还有进位，将它加入到结果链表的最后一位上
            current->next = new ListNode(1);
        }
        return result->next;  // 返回结果链表的头节点
    }
};

Go

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    carry := 0  // 进位信息
    result := &ListNode{}  // 结果链表
    current := result  // 指向结果链表的当前节点
    for l1 != nil || l2 != nil {  // 遍历 l1 和 l2，直到两个链表均为空
        val1 := 0 
        if l1 != nil {
            val1 = l1.Val  // 获取 l1 当前节点上的数值
            l1 = l1.Next  // 移动 l1 指针到下一个节点
        }
        val2 := 0
        if l2 != nil {
            val2 = l2.Val  // 获取 l2 当前节点上的数值
            l2 = l2.Next  // 移动 l2 指针到下一个节点
        }
        total := val1 + val2 + carry  // 计算当前位上的总和
        carry = 0
        if total >= 10 {
            carry = 1  // 更新进位信息
            total -= 10  // 将总和变为个位数
        }
        current.Next = &ListNode{Val: total}  // 将当前位上的数值加入到结果链表中
        current = current.Next  // 将结果链表的指针指向下一个节点
    }
    if carry == 1 {  // 如果还有进位，将它加入到结果链表的最后一位上
        current.Next = &ListNode{Val: 1}
    }
    return result.Next  // 返回结果链表的头节点
}

Rust

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     val: i32,
 *     next: Option<Box<ListNode>>
 * }
 */
impl Solution {
    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        let (mut p1, mut p2) = (&l1, &l2);  // 定义指向 l1 和 l2 的指针
        let mut carry = 0;  // 进位信息
        let mut result = Box::new(ListNode::new(0));  // 结果链表
        let mut current = &mut result;  // 指向结果链表的当前节点
        while p1.is_some() || p2.is_some() {  // 遍历 l1 和 l2，直到两个链表均为空
            let val1 = p1.as_ref().map_or(0, |node| node.val);  // 获取 l1 当前节点上的数值
            let val2 = p2.as_ref().map_or(0, |node| node.val);  // 获取 l2 当前节点上的数值
            let total = val1 + val2 + carry;  // 计算当前位上的总和
            carry = if total > 9 { 1 } else { 0 };  // 更新进位信息
            current.next = Some(Box::new(ListNode::new(total % 10)));  // 将当前位上的数值加入到结果链表中
            current = current.next.as_mut().unwrap();  // 将结果链表的指针指向下一个节点
            if let Some(node) = p1 {
                p1 = node.next.as_ref();  // 移动 l1 指针到下一个节点
            }
            if let Some(node) = p2 {
                p2 = node.next.as_ref();  // 移动 l2 指针到下一个节点
            }
        }
        if carry == 1 {  // 如果还有进位，将它加入到结果链表的最后一位上
            current.next = Some(Box::new(ListNode::new(1)));
        }
        result.next  // 返回结果链表的头节点
    }
}

总结

这道题是一道比较简单的链表题目，我们只需要将两个链表按位相加即可。需要注意的是，在相加的过程中，可能会有进位的情况出现，需要将进位信息保存下来，以便下一次相加时使用。

在实现上，我们可以通过定义指向链表的指针来遍历链表，并同时维护一个结果链表。每次相加时，我们从两个链表上取出当前位上的数值，然后将它们加起来，再加上进位信息，就得到了当前位上的总和。然后，我们将总和的个位数加入到结果链表中，并更新进位信息。最后，我们将指针指向下一个节点，继续进行下一次相加，直到两个链表均为空为止。

代码实现上，我们可以使用 while 循环来遍历链表，并使用 if 语句来判断是否还有进位。同时，我们还需要定义一个临时变量来保存结果链表的当前节点。具体实现细节请见上面的代码注释。