leetcode-链表相加

题目

给定两个用链表表示的整数，每个节点包含一个数位。
这些数位是反向存放的，也就是个位排在链表首部。
编写函数对这两个整数求和，并用链表形式返回结果。

示例：

输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
输出：2 -> 1 -> 9，即912

思路

采用原地算法，比较两个链表长度，如果长度一致，那么链表相加到任一链表，计算最后一位相加进位情况，如果是1，则在两个链表任选一多分配一个长度，并赋值为1。
如果一个链表长度大于另一个链表，思路一致，只不过要确认短的链表何时终止。

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


struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
    int carry=0;
    struct ListNode* p1=l1;
    struct ListNode* p2=l2;
    struct ListNode* prev=NULL;
    int len1=0,len2=0;
    while(p1){
        len1++;
        p1=p1->next;
    }
    p1=l1;
    while(p2){
        len2++;
        p2=p2->next;
    }
    p2=l2;
    //printf("%d %d\n",len1,len2);
    if(len1==len2){
        while(p1&&p2){
            if(p1->val+p2->val+carry>=10){
                p1->val=(p1->val+p2->val+carry)%10;
                carry=1;
            }
            else{
                p1->val=(p1->val+p2->val+carry)%10;
                carry=0;
            }
            if(p1->next==NULL){
                prev=p1;
            }
            p1=p1->next;
            p2=p2->next;
        }
        if(carry==0){
            return l1;
        }
        else{
            prev->next=(struct ListNode*) malloc(sizeof(struct ListNode));
            prev->next->val=1;
            prev->next->next=NULL;
            return l1;
        }
    }
    else if(len1<len2){
        while(p1&&p2){
            if(p1->val+p2->val+carry>=10){
                p2->val=(p1->val+p2->val+carry)%10;
                carry=1;
            }
            else{
                p2->val=(p1->val+p2->val+carry)%10;
                carry=0;
            }
            p1=p1->next;
            p2=p2->next;
        }
        if(carry==0){
            return l2;
        }
        while(p2){
            if((p2->val+carry)>=10){
                p2->val=(p2->val+carry)%10;
                carry=1;
            }
            else{
                p2->val=(p2->val+carry)%10;
                carry=0;
            }
            if(p2->next==NULL){
                prev=p2;
            }
            p2=p2->next;
        }
        if(carry==0)
            return l2;
        else{
            prev->next=(struct ListNode*) malloc(sizeof(struct ListNode));
            prev->next->val=1;
            prev->next->next=NULL;
            return l2;
        }
    }
    else{
        while(p1&&p2){
            if(p1->val+p2->val+carry>=10){
                p1->val=(p1->val+p2->val+carry)%10;
                carry=1;
            }
            else{
                p1->val=(p1->val+p2->val+carry)%10;
                carry=0;
            }
            p1=p1->next;
            p2=p2->next;
        }
        while(p1){
            if(carry==0){
                return l1;
            }
            else{
                if((p1->val+carry)>=10){
                    p1->val=(p1->val+carry)%10;
                    carry=1;
                }
                else{
                    p1->val=(p1->val+carry)%10;
                    carry=0;
                }
            }
            if(p1->next==NULL){
                prev=p1;
            }
            p1=p1->next;
        }
        if(carry==0){
            return l1;
        }
        else{
            prev->next=(struct ListNode*) malloc(sizeof(struct ListNode));
            prev->next->val=1;
            prev->next->next=NULL;
            return l1;
        }
    }
    return l1;
}

执行用时 :24 ms, 在所有 C 提交中击败了32.52% 的用户
内存消耗 :6.9 MB, 在所有 C 提交中击败了100.00%的用户