【LeetCode编程学习（C语言）】2.Add Two Numbers

英文题目：You are given two linked lists representing two non-negative numbers. 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.

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8

题目：给定两个链表，代表两个非负整数。整数上的数字逆序存储，每一个节点包括一个数字，使这两个整数相加，然后用链表返回。

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)

输出：7 -> 0 -> 8

原文链接：Add Two Numbers

解题思路：其实这就是一个用链表实现的加法运算。如上例就是实现342+465=807的操作。因为逆序存储（如果正序存储就完全不同了），正好实现从低位往高位相加，所以计算时只需要考虑进位即可。在编程时需要考虑以下几个方面：

1.如果链表有一个为空；返回另一个链表。

2.如果链接l1和l2均不为空；此时需要两个链表中的值与进位相加。如果一个处理完另一个还有数据，加上另外一个链表中的值和进位相加即可。

3.结束时，有可能还有进位，如果有还要再开辟一个节点存储进位。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* l3 = NULL; 
    struct ListNode* q,*tmp_l1,*tmp_l2;
    tmp_l1 = l1;    //tmp_l1用来遍历链表l1
    tmp_l2 = l2;    //遍历链表l2
    int up = 0;
    int r,add;
    
    //如果有一个是空链表
    if(l1 == NULL || l2 == NULL)
    {
        return (l1 == NULL ? l2 :l1);
    }
    
    //如果链表均不为空
    while(tmp_l1 != NULL && tmp_l2 != NULL)
    {
        struct ListNode* pnode = (struct ListNode*)malloc(sizeof(struct ListNode));
        add = tmp_l1->val + tmp_l2->val + up;
        up = add/10;
        r = add%10;
        pnode->val = r;
        if(l3 == NULL)       //如果处理的是第一个节点
        {
            l3 = q = pnode;
        }
        else
        {
            q->next = pnode;
            q = q->next;
        }
        tmp_l1 = tmp_l1->next;
        tmp_l2 = tmp_l2->next;
    }
    
    //如果链表l1还有没处理完的数据
    while(tmp_l1!=NULL)
    {
        struct ListNode* pnode = (struct ListNode*)malloc(sizeof(struct ListNode));
  add = tmp_l1->val + up;
        up = add/10;
        r = add%10;
        pnode->val = r;
        q->next = pnode;
        q = q->next;
        tmp_l1 = tmp_l1->next;
    }
    
     //如果链表l2还有没处理完的数据
    while(tmp_l2!=NULL)
    {
        struct ListNode* pnode = (struct ListNode*)malloc(sizeof(struct ListNode));
        add = tmp_l2->val + up;
        up = add/10;
        r = add%10;
        pnode->val = r;
        q->next = pnode;
        q = q->next;
        tmp_l2 = tmp_l2->next;
    }
    
    //处理最后的进位问题
    if(up > 0)
    {
        struct ListNode* pnode = (struct ListNode*)malloc(sizeof(struct ListNode));
        pnode->val = up;
        q->next = pnode;
        q = q->next;
    }
    q->next = NULL;    //结束指针
    return l3;
    
}

LeetCode运行时间：20 ms

虽然实现了功能，但代码较为繁琐，在看别人的代码时发现判断条件完全可以写在一个while循环里面，链接：点击打开链接，代码如下：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
//        ListNode *pResult = NULL;
//        ListNode **pCur = &pResult;

        ListNode rootNode(0);
        ListNode *pCurNode = &rootNode;
        int a = 0;
        while (l1 || l2)
        {
            int v1 = (l1 ? l1->val : 0);
            int v2 = (l2 ? l2->val : 0);
            int temp = v1 + v2 + a;
            a = temp / 10;
            ListNode *pNode = new ListNode((temp % 10));
            pCurNode->next = pNode;
            pCurNode = pNode;
            if (l1)
                l1 = l1->next;
            if (l2)
                l2 = l2->next;
        }
        if (a > 0)
        {
            ListNode *pNode = new ListNode(a);
            pCurNode->next = pNode;
        }
        return rootNode.next;
    }
};

这样写确实简洁了很多！看来还需要多加学习。