Problem
You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
You may assume the two numbers do not contain any leading zero, except the number 0 itself.
说明:给定两个非负数,使用两个链表分别存储,每个链表的结点存储该数的一位且倒序存储;要求计算两个数的和并将结果已相同方式存入链表,即和的每一位倒序存入链表。
[Example]
Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.
提示:大整数加法运算。
Answer
方法一:模拟加法运算。将两个数的各位按位相加,使用digit记录是否有进位。注意最后有进位的情况,应创建结点保存最高位进位。
时间复杂度:遍历两个链表O(m+n)
;空间复杂度:使用一个结果链表存储结点O(max(m,n))
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* ans=new ListNode(-1);//结果链表
ListNode* p=ans;//新结点
ListNode*pre_p=ans;//记录插入链表结点的前一个结点,便于链表插入
ListNode* q=ans;//记录结果链表
int digit=0;//记录进位
while(l1!=NULL || l2!=NULL){
//l1或l2不为空时进行相加操作
if(l1==NULL){//l1为空则将剩余的l2结点直接添加到结果链表中
ListNode* t=l2;
//考虑一种情况:l2一直有进位即99999+1的情况 digit=1
while(digit==1){
int tmp=(l2->val+1)%10;
if(l2->val+1>=10){
digit=1;
}else digit=0;
l2->val=tmp;
if(l2->next==NULL){
if(digit==1){//加到最高位
p=new ListNode(1);
p->next=NULL;
l2->next=p;
}
break;
}else l2=l2->next;
}
q->next=t;break;
}
//l2考虑的情况与l1类似
if(l2==NULL){
ListNode* t=l1;
while(digit==1){
int tmp=(l1->val+1)%10;
if(l1->val+1>=10){
digit=1;
}else digit=0;
l1->val=tmp;
if(l1->next==NULL ){
if(digit==1){
p=new ListNode(1);
p->next=NULL;
l1->next=p;
}
break;
}else l1=l1->next;
}
q->next=t;break;
}
//l1与l2都不为空,则进行相加操作
p=new ListNode(-1);
p->val=(l1->val+l2->val+digit)%10;
p->next=NULL;//创建新结点
if(l1->val+l2->val+digit>=10){
digit=1;
}else digit=0;//判断是否有进位
q->next=p;//将结点添加到结果链表中
pre_p=p;
q=q->next;
l1=l1->next;
l2=l2->next;
}
//l1与l2链表等长且最高位有进位,创建新结点最为最高位
if(l1==NULL && l2==NULL && digit==1){
p=new ListNode(1);
p->next=NULL;
pre_p->next=p;
}
return ans->next;//返回不带头结点的链表
}
};
方法二:原理和方法一相同,但代码更简洁且思路很巧妙;时间和空间复杂度与方法一相同;有人在discussion
模块中提出使用原链表来存储结果链表,即使用l1
或l2
存储,虽然空间复杂度为O(1)
,但改变了原链表结构且使得算法代码比较混乱,个人推荐方法二的写法。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* ans=new ListNode(-1);
ListNode* p;//创建新结点
ListNode* q=ans;//遍历插入时的指针
int digit=0;//进位位
int sum=0;//作为各位相加后的结果
//将进位位考虑在循环条件判断中很巧妙
while(l1 || l2 || digit){
if(l1){//判空
sum+=l1->val;
l1=l1->next;
}
if(l2){
sum+=l2->val;
l2=l2->next;
}
//创建新结点插入
p=new ListNode((sum+digit)%10);
p->next=NULL;
q->next=p;
q=q->next;
//判断进位位,并将sum清零
sum+digit>=10?digit=1:digit=0;
sum=0;
}
return ans->next;
}
};