第五章 - 高频考题(中等)
1906. 查询差绝对值的最小值
0445. 两数相加 II

题目地址(445. 两数相加 II)

题目描述

1
给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
2
3
你可以假设除了数字 0 之外,这两个数字都不会以零开头。
4
5
6
7
进阶:
8
9
如果输入链表不能修改该如何处理?换句话说,你不能对列表中的节点进行翻转。
10
11
12
13
示例:
14
15
输入:(7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
16
输出:7 -> 8 -> 0 -> 7
Copied!

前置知识

  • 链表

公司

  • 腾讯
  • 百度
  • 字节

思路

由于需要从低位开始加,然后进位。 因此可以采用栈来简化操作。 依次将两个链表的值分别入栈 stack1 和 stack2,然后相加入栈 stack,进位操作用一个变量 carried 记录即可。
最后根据 stack 生成最终的链表即可。
也可以先将两个链表逆置,然后相加,最后将结果再次逆置。

关键点解析

  • 栈的基本操作
  • carried 变量记录进位
  • 循环的终止条件设置成stack.length > 0 可以简化操作
  • 注意特殊情况, 比如 1 + 99 = 100

代码

  • 语言支持:JS,C++, Python3
JavaScript Code:
1
/*
2
* @lc app=leetcode id=445 lang=javascript
3
*
4
* [445] Add Two Numbers II
5
*/
6
/**
7
* Definition for singly-linked list.
8
* function ListNode(val) {
9
* this.val = val;
10
* this.next = null;
11
* }
12
*/
13
/**
14
* @param {ListNode} l1
15
* @param {ListNode} l2
16
* @return {ListNode}
17
*/
18
var addTwoNumbers = function (l1, l2) {
19
const stack1 = [];
20
const stack2 = [];
21
const stack = [];
22
23
let cur1 = l1;
24
let cur2 = l2;
25
let curried = 0;
26
27
while (cur1) {
28
stack1.push(cur1.val);
29
cur1 = cur1.next;
30
}
31
32
while (cur2) {
33
stack2.push(cur2.val);
34
cur2 = cur2.next;
35
}
36
37
let a = null;
38
let b = null;
39
40
while (stack1.length > 0 || stack2.length > 0) {
41
a = Number(stack1.pop()) || 0;
42
b = Number(stack2.pop()) || 0;
43
44
stack.push((a + b + curried) % 10);
45
46
if (a + b + curried >= 10) {
47
curried = 1;
48
} else {
49
curried = 0;
50
}
51
}
52
53
if (curried === 1) {
54
stack.push(1);
55
}
56
57
const dummy = {};
58
59
let current = dummy;
60
61
while (stack.length > 0) {
62
current.next = {
63
val: stack.pop(),
64
next: null,
65
};
66
67
current = current.next;
68
}
69
70
return dummy.next;
71
};
Copied!
C++ Code:
1
/**
2
* Definition for singly-linked list.
3
* struct ListNode {
4
* int val;
5
* ListNode *next;
6
* ListNode(int x) : val(x), next(NULL) {}
7
* };
8
*/
9
class Solution {
10
public:
11
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
12
auto carry = 0;
13
auto ret = (ListNode*)nullptr;
14
auto s1 = vector<int>();
15
toStack(l1, s1);
16
auto s2 = vector<int>();
17
toStack(l2, s2);
18
while (!s1.empty() || !s2.empty() || carry != 0) {
19
auto v1 = 0;
20
auto v2 = 0;
21
if (!s1.empty()) {
22
v1 = s1.back();
23
s1.pop_back();
24
}
25
if (!s2.empty()) {
26
v2 = s2.back();
27
s2.pop_back();
28
}
29
auto v = v1 + v2 + carry;
30
carry = v / 10;
31
auto tmp = new ListNode(v % 10);
32
tmp->next = ret;
33
ret = tmp;
34
}
35
return ret;
36
}
37
private:
38
// 此处若返回而非传入vector,跑完所有测试用例多花8ms
39
void toStack(const ListNode* l, vector<int>& ret) {
40
while (l != nullptr) {
41
ret.push_back(l->val);
42
l = l->next;
43
}
44
}
45
};
46
47
// 逆置,相加,再逆置。跑完所有测试用例比第一种解法少花4ms
48
class Solution {
49
public:
50
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
51
auto rl1 = reverseList(l1);
52
auto rl2 = reverseList(l2);
53
auto ret = add(rl1, rl2);
54
return reverseList(ret);
55
}
56
private:
57
ListNode* reverseList(ListNode* head) {
58
ListNode* prev = NULL;
59
ListNode* cur = head;
60
ListNode* next = NULL;
61
while (cur != NULL) {
62
next = cur->next;
63
cur->next = prev;
64
prev = cur;
65
cur = next;
66
}
67
return prev;
68
}
69
70
ListNode* add(ListNode* l1, ListNode* l2) {
71
ListNode* ret = nullptr;
72
ListNode* cur = nullptr;
73
int carry = 0;
74
while (l1 != nullptr || l2 != nullptr || carry != 0) {
75
carry += (l1 == nullptr ? 0 : l1->val) + (l2 == nullptr ? 0 : l2->val);
76
auto temp = new ListNode(carry % 10);
77
carry /= 10;
78
if (ret == nullptr) {
79
ret = temp;
80
cur = ret;
81
}
82
else {
83
cur->next = temp;
84
cur = cur->next;
85
}
86
l1 = l1 == nullptr ? nullptr : l1->next;
87
l2 = l2 == nullptr ? nullptr : l2->next;
88
}
89
return ret;
90
}
91
};
Copied!
Python Code:
1
# Definition for singly-linked list.
2
# class ListNode:
3
# def __init__(self, x):
4
# self.val = x
5
# self.next = None
6
7
class Solution:
8
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
9
def listToStack(l: ListNode) -> list:
10
stack, c = [], l
11
while c:
12
stack.append(c.val)
13
c = c.next
14
return stack
15
16
# transfer l1 and l2 into stacks
17
stack1, stack2 = listToStack(l1), listToStack(l2)
18
19
# add stack1 and stack2
20
diff = abs(len(stack1) - len(stack2))
21
stack1 = ([0]*diff + stack1 if len(stack1) < len(stack2) else stack1)
22
stack2 = ([0]*diff + stack2 if len(stack2) < len(stack1) else stack2)
23
stack3 = [x + y for x, y in zip(stack1, stack2)]
24
25
# calculate carry for each item in stack3 and add one to the item before it
26
carry = 0
27
for i, val in enumerate(stack3[::-1]):
28
index = len(stack3) - i - 1
29
carry, stack3[index] = divmod(val + carry, 10)
30
if carry and index == 0:
31
stack3 = [1] + stack3
32
elif carry:
33
stack3[index - 1] += 1
34
35
# transfer stack3 to a linkedList
36
result = ListNode(0)
37
c = result
38
for item in stack3:
39
c.next = ListNode(item)
40
c = c.next
41
42
return result.next
Copied!
复杂度分析
其中 M 和 N 分别为两个链表的长度。
  • 时间复杂度:$O(M + N)$
  • 空间复杂度:$O(M + N)$
大家对此有何看法,欢迎给我留言,我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库:https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。