LeetCode解题学习心得（二）：两数相加

0. 题目

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers

1. 解题思路

这道题我觉得需要考虑的地方在于进位和两个整数的位数不一致。主要分成以下几种情况：

1.1 基本情况

输入：(2 -> 1 -> 3)+(4 -> 2 -> 1)
输出：6 -> 3 -> 4
原因：312 + 124 = 436

这种情况其实很简单，每一位对上就好了，然后相加得出结论即可。

1.2 基本进位

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

这里接涉及到进位的问题，4+6=10，所以在十位上应该是0，并且百位进1，我让第一整数342的百位，+1，变成4。然后再进行基本的加和。

1.3 复杂进位

输入：(5) + (5)
输出：0 -> 1
原因：5 + 5 = 10

这里当两个涉及到将进位之后都没有下一位的时候，那么我们重新开辟空间，增加下一位。

1.4 长度不一致

输入：(2 -> 3) + (5 -> 6 -> 4)
输出：7 -> 9 -> 4
原因：32 + 465 = 497

这里要分成第一个整数长还是第二个整数长的情况，结果自然就是剩余长的部分直接落位。

1.5长度不一致且进位

输入：(1) + (9 -> 9)
输出：0 -> 0 -> 1
原因：1 + 99 = 100

这里当两个长度不同的数需要进位的时候，我们就对长的那个数进行改动。

2. C语言

2.1 代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
    struct ListNode* q=(struct ListNode*)malloc(sizeof(struct ListNode));
    q->next=NULL;
    struct ListNode* head=q;
    int val;

    //可能存在长度不一样的情况
    while(l1||l2){
        struct ListNode* temp=(struct ListNode*)malloc(sizeof(struct ListNode));
        temp->next=NULL;

        if(l1&&l2){    //长度相同的地方
            val=l1->val+l2->val;
            if(val>=10){
                val=val-10;
                if(l1->next&&l2->next){         //两个都有下一位
                    l1->next->val++;
                }else if(l1->next&&!l2->next){  //只有l1有下一位
                    l1->next->val++;
                }else if(!l1->next&&l2->next){  //有l2有下一位
                    l2->next->val++;
                }else if(!l1->next&&!l2->next){ //都没有下一位
                    struct ListNode* add=(struct ListNode*)malloc(sizeof(struct ListNode));
                    add->next=NULL;
                    add->val=1;
                    l1->next=add;
                }
            }
            l1=l1->next;
            l2=l2->next;
        }else if(l1&&!l2){  //l1长的地方
            val=l1->val;
            if(val>=10){
                val=val-10;
                if(l1->next){   //l1有下一位
                    l1->next->val++;
            }else{              //l1没有下一位
                    struct ListNode* add=(struct ListNode*)malloc(sizeof(struct ListNode));
                    add->next=NULL;
                    add->val=1;
                    l1->next=add;
                }
            }
            l1=l1->next;
        }else if(!l1&&l2){  //l2长的地方
            val=l2->val;
            if(val>=10){
                val=val-10;
                if(l2->next){   //l2有下一位
                    l2->next->val++;
                }else{          //l2没有下一位
                    struct ListNode* add=(struct ListNode*)malloc(sizeof(struct ListNode));
                    add->next=NULL;
                    add->val=1;
                    l2->next=add;
                }
            }
            l2=l2->next;
        }
        
        temp->val=val;
        
        q->next=temp;
        q=q->next;

    }
    return head->next;
}

2.2 执行结果

执行用时 :
28 ms, 在所有 C 提交中击败了17.22%的用户
内存消耗 :
8.9 MB, 在所有 C 提交中击败了68.19%的用户

2.3 总结

这个算法情况分的比较多，但是时间复杂度为：$T(n)=O(n)$

3. Python

3.1 代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode)-> ListNode:
        q=ListNode(0)
        result=q

        # 可能存在长度不一样的情况
        while l1 or l2:
            if l1 and l2:    # 长度相同的地方
                val=l1.val+l2.val
                if val>=10:
                    val=val-10
                    if l1.next and l2.next:              # 两个都有下一位
                        l1.next.val+=1
                    elif l1.next and not l2.next:        # 只有l1有下一位
                        l1.next.val+=1
                    elif not l1.next and l2.next:        # 只有l2有下一位
                        l2.next.val+=1
                    elif not l1.next and not l2.next:    # 都没有下一位
                        temp=ListNode(val)
                        q.next=temp
                        q=q.next
                        add=ListNode(1)
                        q.next=add
                        return result.next
                l1=l1.next
                l2=l2.next
            elif l1 and not l2:  # l1长的地方
                val=l1.val
                if val>=10:
                    val=val-10
                    if l1.next:        # l1有下一位
                        l1.next.val+=1
                    else:                 # l1没有下一位
                        add=ListNode(1)
                        l1.next=add
                l1=l1.next
            elif not l1 and l2:  # l2长的地方
                val=l2.val
                if val>=10:
                    val=val-10
                    if l2.next:   # l2有下一位
                        l2.next.val+=1
                    else:         # l2没有下一位
                        add=ListNode(1)
                        l2.next=add
                l2=l2.next
                
            temp=ListNode(val)
            q.next=temp
            q=q.next
            
        return result.next

3.2 执行结果

执行用时 :
60 ms, 在所有 Python3 提交中击败了97.77%的用户
内存消耗 :
13.2 MB, 在所有 Python3 提交中击败了47.69%的用户

3.3 总结

较C语言来讲，这个算法改进不大，主要改在了当两个整数都没有下一位了，但是需要进位的情况，在这里我将他改成了直接return，而不是在进行一次判断。同样，时间复杂度仍未：$T(n)=O(n)$

4. 结语

如果大家发现我有什么地方写错的，或者更好的建议，希望大家可以提出来！谢谢！