给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。
请你将两个数相加,并以相同形式返回一个表示和的链表。
你可以假设除了数字 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值了,两数相加后存入的是新开辟的节点。
步骤:
- 创建两个指针,头、尾,前者代表一条链表,后者负责加入新的值
- 两个链表保证一个链表有值便可计算,没有值的那条链表看作之后的所有数都为0
- 保证进位值是对应数字与上一次进位值之和除以10计算出来的
- 如果最后进位值大于0,最后再开辟一个节点存储
- 返回的是头指针即可
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
}
}