2.两数相加

题目

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

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

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

示例：

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

解法一(我的思路)

思路：

将两个链表代表的数字给表示出来，再将其求和，将将求和结果按照逆序的链表形式输出即可！

/**
 * 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) {
        // 先计算出两个链表之间所代表的之和
        int sum = 0;
        int temp_i=1;
        
        ListNode *temp = l1;
        
        do{
            sum += temp->val*temp_i;
            
            temp_i = temp_i*10;
            temp = temp->next;
        }while(temp!=NULL);
        
        temp = l2;
        temp_i = 1;  
        do{
            sum += temp->val*temp_i;
            
            temp_i = temp_i*10;
            temp = temp->next;
        }while(temp!=NULL);
        // 计算完成求和 开始创建新的链表 用来存放新的数据
        
        ListNode * p = new ListNode(0);
        ListNode * q;// 用来移动新生成的链表
        q = p;
        int num = 0;
        num = sum % 10;
        sum = sum / 10;
        p->val = num;
        do{
            ListNode *newNode = new ListNode(0); // 创建新的节点
            if(sum>0) break;
            int num = 0;
            num = sum % 10;
            sum = sum / 10;
            
            // 给临时节点赋值
            newNode->val = num;
            newNode->next = NULL;
            
            q->next = newNode; //将临时节点赋值给移动的链表(指向新的链表)
            q = newNode; // 此时移动的链表需要移动到当前节点上来
        }while(sum>0);
        return p;
    }
};

在执行代码上计算结果与预期的结果一致，但是提交代码时，老是提示错误？ 我开始绝望了。执行代码的时间4ms，但是提交结果会出现错误？
错误提示为：

Line 28: Char 29: runtime error: signed integer overflow: 1000000000 * 9 cannot be represented in type 'int' (solution.cpp)

始终没有找到错误的原因？ 但是觉得自己的思路是对的！ 所以就没有纠结这个问题，查看评论中网友给的答案？

解法二(自己的思路二)

思路：

由于对于该数据表示的单链表而言，其表示的第一个数字代表整数的个位数，其表示的第二位代表整数的十位数，以此类推。。。
同理另外一个数也是这样表示的，所以当两个数字相加时，就是个位相加，遇到大于10，进一位即可，即可以在对链表遍历的同时计算出最终的结果。

(需要考虑两个链表不一样长的问题！)

/**
 * 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 *result = new ListNode(0); //存放结果的链表
        ListNode *p1 ,*p2; //分别指向两个相加的链表
        ListNode *temp ; // 临时节点 存放临时数据
        temp = result;
        p1 = l1 , p2 = l2;
        int z = 0; // 用来表示最终相同位数求和有没有超过10的
        while(p1!=NULL || p2!=NULL){ //当两个指针都为空跳出来(思想差不多 不过后面参考了答案)  
            // 用这种方式可以避免其判断 两个链表之间的长度问题 当一个链表到头了，用0表示后面位数
            int x = (p1!=NULL) ? p1->val : 0 ;
            int y = (p2!=NULL) ? p2->val : 0 ;

            if(p1) p1 = p1->next;
            if(p2) p2 = p2->next;
            
            int sum = z + x+y;
            z = sum /10; // 用来记录大于10的位数(进一位则会记录下来)
            temp->next = new ListNode( sum % 10 ); 
            temp = temp->next;
        }
        
        // 当两者都已经为空 看最后一位有没有超过10的值
        if(z>0) temp->next = new ListNode(z);
        
        return result->next;
        
    }
};

与答案的思想相同，但好像最后有参考答案怎么写的，虽然用的是java语言，因为觉得他写的会比我自己写的更简洁一点，但是后面还是尽量少的参考答案吧！！！！

中间有发现出现错误是，时间超时，后面检查发现代码错误！！ 所以一般不会出现超时的现象！

结果： 时间 40ms 97.14%. 内存 19.2M 37.42%

解答三 (网友答案1)

使用了递归的思想，效率挺高的！

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        return addByBit(l1, l2, 0);
    }
    ListNode* addByBit(ListNode* l1, ListNode* l2, int carry) {
        if (l1 == NULL) l1 = new ListNode(0);
        if (l2 == NULL) l2 = new ListNode(0);
        ListNode *l = new ListNode((l1->val + l2->val + carry) % 10);
        carry = (l1->val + l2->val + carry) / 10;
        if(l1->next != NULL || l2->next != NULL || carry == 1) {
            l->next = addByBit(l1->next, l2->next, carry);
        }
        return l;
    }
};

时间： 40ms
内存: 19.6M

解答四 (网友答案2)

主要的套路跟我第二个套路是一样的。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *ans = new ListNode(0), *t1=l1, *t2=l2;
        ListNode *anshead=ans;
        int carry=0;

            while(t1||t2){
                if(t1){
                    carry+= t1->val;
                    t1 = t1->next;
                }
                if(t2){
                    carry+= t2->val;
                    t2 = t2->next;
                }
                ans->val = carry%10;
                carry /= 10;
                if(t1||t2||carry){
                    ans->next = new ListNode(carry);
                    ans = ans->next;
                }
            }
            return anshead;
    }
};

时间：44ms
内存： 19.2M

问题：

使用链表的操作不太熟悉，对链表的使用掌握的不够！

学习链表知识:

链表主要包括两个方面:

数据域 和 指针域

1. 单链表节点信息包括:

• 数据域 : 用于存储数据元素的值

• 指针域(链域)： 用于存放下一个节点地址或者指向后面节点的指针

struct Node{
    int val; //数据域
    Node *next; //指针域
}

具体参考链接...

参考链接:

1. https://www.cnblogs.com/byonecry/p/4458821.html