LeetCode算法题：（2）两数相加（C语言实现）

问题

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

例如：输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9] 输出：[8,9,9,9,0,0,0,1]

---

实现思想

       由于链表是逆序存储的，所以对于两数相加，如果输入【1,2,3】和【4,5,6】，就相当于321+654=975，然后逆序输出为【5,7,9】。针对这个特点，我们从两个链表表头开始对两链表同时遍历，让两链表节点中存储的数相加，然后建立一个新链表存储结果，如果大于10则取除10取余存储，并使用一个变量获取进位，参与下一次相加。注意如果两链表都遍历结束后还有进位信号，则新链表还需要再创建一个节点存储该进位信号数值。

---

代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
    int flag=0,i;
    struct ListNode* p1=l1;
    struct ListNode* p2=l2;
    struct ListNode* a1;
    struct ListNode* head=(struct ListNode*)malloc(sizeof(struct ListNode));
    head->next=NULL;//创建新节点后一定要对内部指针域初始化
    a1=head;//head用于返回链表，使用新指针对新链表操作
        for(i=0;;++i){
            struct ListNode* a2=(struct ListNode*)malloc(sizeof(struct ListNode));
            a2->next=NULL;
            a1->next=a2;
            a1=a2;
            //创建新节点并连接到新链表上
            a1->val=(p1->val+p2->val+flag)%10;
            flag=(p1->val+p2->val+flag)/10;
             if(p1->next==NULL||p2->next==NULL)
            break;//循环出口，当某一个链表遍历结束后结束
            p1=p1->next;
            p2=p2->next;  
        }
        /*判断那个链表遍历结束，然后对剩下的链表继续遍历，结合进位信号相加到新链表上，实现原理同上*/
        if(p1->next!=NULL&&p2->next==NULL){
            p1=p1->next;
            for(i=0;;++i){
                struct ListNode* a2=(struct ListNode*)malloc(sizeof(struct ListNode));
                a2->next=NULL;
                a1->next=a2;
                a1=a2;
                a1->val=(p1->val+flag)%10;
                flag=(p1->val+flag)/10;
                 if(p1->next==NULL)
                 break;
                 p1=p1->next;
            }
        }
        /*判断那个链表遍历结束，然后对剩下的链表继续遍历，结合进位信号相加到新链表上（同上）*/
        if(p1->next==NULL&&p2->next!=NULL){
            p2=p2->next;
            for(i=0;;++i){
                struct ListNode* a2=(struct ListNode*)malloc(sizeof(struct ListNode));
                a2->next=NULL;
                a1->next=a2;
                a1=a2;
                a1->val=(p2->val+flag)%10;
                flag=(p2->val+flag)/10;
                 if(p2->next==NULL)
                 break;
                 p2=p2->next;
            }
        }
  /*判断两链表遍历结束后是否还有进位，如果有则创建一个节点存储*/
    if(flag==1)
   {
       struct ListNode* a2=(struct ListNode*)malloc(sizeof(struct ListNode));
       a2->next=NULL;
       a2->val=1;
       a1->next=a2;
   }
    return head->next;//链表是从头节点的下一个节点开始存储，所以返回头节点的下一个节点
}

---

总结

在写这个版本的代码之前我还写过好几个版本，但是都超时了，只有这个20ms通过了，所以还存在很多问题，还可以继续优化，作为一个新手也是第一次做算法题，没啥经验，相信以后会越来越好。