2.Add Two Numbers

最新推荐文章于 2022-04-17 20:53:09 发布

原创最新推荐文章于 2022-04-17 20:53:09 发布 · 228 阅读

0 ·

CC 4.0 BY-SA版权

leetcode(Top100) 专栏收录该内容

3 篇文章

订阅专栏

博客围绕两个非负数的加法运算展开，这两个数分别用链表倒序存储每一位。给出两种计算两数和并将结果以相同方式存入链表的方法，介绍了方法的原理、复杂度，还提及有人提出用原链表存结果，但会改变原结构，推荐方法二。

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;
    }
};