前言
这道题将整数加法转换为在单链表上做加法运算,涉及到知识点:
- 单链表的遍历
- 单链表插入新节点
题目描述
给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。
示例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
-
题目数据保证列表表示的数字不含前导零
题目分析
单链表遍历只能 单向单步:给定一个节点的指针,那么它只能访问下一个节点的内容。单链表的遍历时间复杂度唯一: O ( n ) \mathcal{O}(n) O(n) 。
注意到:由于每个节点只能存储一位数字,那么两个对应位相加的最大值为
9
+
9
=
18
9 + 9 = 18
9+9=18 ,因此我们的十进制 进位
最大只会为 1 。
暴力算法
就像普通的十进制数加法一样,每一位相加后对 10 10 10 取余作为当前位的答案,而对 10 10 10 取商作为进位。遍历完后还需要判断是否进位不为 0 0 0 ,如果不为 0 0 0 ,就还需要增加数字为 1 1 1 的节点。
假设
A
A
A 代表
L
1
L_1
L1 链表,
B
B
B 代表
L
2
L_2
L2 链表,
C
C
C 代表
L
1
L_1
L1 与
L
2
L_2
L2 的和 :
C
=
A
+
B
C = A + B \\
C=A+B
因此给出数学公式:
{
C
i
=
A
i
+
B
i
+
t
(
进位
)
,
0
≤
i
≤
m
a
x
(
A
.
l
e
n
g
t
h
,
B
.
l
e
n
g
t
h
)
C
i
=
1
,
t
=
1
,
i
=
m
a
x
(
A
.
l
e
n
g
t
h
,
B
.
l
e
n
g
t
h
)
+
1
\begin{equation} \begin{aligned} \begin{cases} C_i &= A_i + B_i + t(\text{进位}),\qquad &0\leq i\leq max(A.length , B.length)\\ \\ \\ C_i &= 1, & t = 1 ,\quad i = max(A.length , B.length) + 1 \end{cases} \end{aligned} \end{equation}
⎩
⎨
⎧CiCi=Ai+Bi+t(进位),=1,0≤i≤max(A.length,B.length)t=1,i=max(A.length,B.length)+1
解题代码
/**
* 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:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* head = new ListNode();
ListNode* cur = head;
int t = 0;
while ( l1 || l2) {
if ( l1) {
t += l1->val;
l1 = l1->next;
}
if ( l2) {
t += l2->val;
l2 = l2->next;
}
ListNode* nnew = new ListNode(t % 10);
cur->next = nnew;
t /= 10;
cur = cur->next; // 准备下一次的增加新节点
}
if ( t ) {
ListNode* nnew = new ListNode(1);
cur->next = nnew;
}
return head->next;
}
};
复杂度分析
O
(
C
o
m
p
l
e
x
)
=
O
(
单个节点处理:申请节点,插入节点
)
+
O
(
遍历
)
=
O
(
k
×
n
)
+
O
(
n
+
1
)
\begin{equation}\begin{aligned} \mathcal{O}(Complex) &= \mathcal{O}(\text{单个节点处理:申请节点,插入节点})\\ &+\mathcal{O}(遍历) \\ &= \mathcal{O}(k\times n) + \mathcal{O}(n + 1)\\ \end{aligned}\end{equation}
O(Complex)=O(单个节点处理:申请节点,插入节点)+O(遍历)=O(k×n)+O(n+1)
最终我们的时间复杂度为
O
(
n
)
\mathcal{O}(n)
O(n) 。
我们在刚开始刷题的时候,可以先试着自己写出暴力算法,然后分析一下时间复杂度,再尝试其他解题方法。