LeetCode2. 两数相加

写在前面：

题目链接：LeetCode2两数相加
编程语言：C++
题目难度：中等

一、题目描述

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

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

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

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

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

提示：

每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

二、题目分析&解题思路&代码实现

2.1 常规老实人解法

解之前先吐槽一番，计算两个数相加的结果，给个单向链表也就算了，存的还是数字的反序，意味着本来要计算，123+23，还得
先将链表遍历一遍：

3->2->1
3->2

再反序一次得到正序 (后面才意识到不用反序)

1，2 ，3
2，3

接下来就开始进行
加法运算

要么先将 1，2 ，3 和2，3 先转换为 123、23 ，然后计算得出结果为 146，然后再逐一的进行再把每一位取出来，并且按照逆序 构建成 一个 6->4->1 单向链表再返回回去；

要么直接进行按位相加，自己设计进位，最后 组成 6，4，1 这样有一个序列然后构建链表，再返回。

各位献丑了，且看我写了半小时的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode* listResult = new ListNode();
    vector<int> vct1;
    vector<int> vct2;
    ListNode* nodeTemp = l1;
    //先将l1、l2遍历一遍
    while(nodeTemp != nullptr)
    {
        vct1.push_back(nodeTemp->val);
        nodeTemp = nodeTemp->next;
    }
    ListNode* nodeTemp1 = l2;
    while(nodeTemp1 != nullptr)
    {
        vct2.push_back(nodeTemp1->val);
        nodeTemp1 = nodeTemp1->next;
    }
    vector<int> vctResult;

    int i = 0;
    int j = 0;
    int iTemp = 0;
    bool isTen = false;//是否进位
    //开始按位相加 从 个位开始
    while(i<vct1.size() && j<vct2.size())
    {
        iTemp = vct1[i] + vct2[j];
        if(isTen)
        {
            iTemp +=1;
        }
        if(iTemp >= 10)
        {
            isTen = true;
            iTemp = iTemp -10;
        }   
        else
        {
            isTen = false;
        }      
        vctResult.push_back(iTemp);
        i++;
        j++;
    }
    //两个链表长度不相等，那么剩下的直接继续按位加即可
    while( i <vct1.size())
    {
        if(isTen)//注意上一个while 后可能还有进位 1
        {
            if(vct1[i] + 1 ==10)//继续进位
            {
                vctResult.push_back(0);
                isTen = true;
            }
            else
            {
                vctResult.push_back(vct1[i]+1);
                isTen = false;
            }
            i++;
        }
        else
        {
            //没有进位直接插入即可
            vctResult.push_back(vct1[i]);
            i++;
        }
    }
    //同理将剩下的都插入，和上面进位机制一样
    while( j< vct2.size())
    {
        if(isTen)
        {
            if(vct2[j] + 1 ==10)
            {
                vctResult.push_back(0);
                isTen = true;
            }
            else
            {
                vctResult.push_back(vct2[j]+1);
                isTen = false;
            }
            j++;
        }
        else
        {
            vctResult.push_back(vct2[j]);
            j++;
        }
    }
    if(isTen)//注意可能最后还有一次进位
    {
        vctResult.push_back(1);
    }
    //接下来构建出链表
    bool head = true;
    ListNode* nodenext = new ListNode();
    for(int k = 0; k < vctResult.size();k++)
    {
        ListNode* node = new ListNode();
        node->val = vctResult[k];
        node->next = nullptr;
        if(head)
        {
            listResult = node;//保存头，做返回值返回
            nodenext = node;
            head = false;
        }
        else
        {
            nodenext->next = node;
            nodenext = nodenext->next;
        }
    }
    return listResult;

    }
};

运行结果：
跑了几次好一点的就是下面这样了

2.1.2 优化后

写道最后，才发现不需要用两个vector 遍历，直接遍历链表即可，我们常固性思维觉得加法就是这样：

其实我们做个镜像对比：

这不就是我们刚好要的答案吗？
因此我们现在直接简化为：
遍历两个链表

3 -> 2 -> 1
3->2

将刚才的代码额外的两次遍历与两个vector 开辟 干掉：

直接做进位的加法，我们将上述的代码优化为：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode* listResult = new ListNode();
    ListNode* nodeTemp = l1;
    ListNode* nodeTemp1 = l2;
    vector<int> vctResult;
    int i = 0;
    int j = 0;
    int iTemp = 0;
    bool isTen = false;//是否进位
    //开始按位相加 从 个位开始
    while(nodeTemp!=nullptr && nodeTemp1!=nullptr)
    {
        iTemp = nodeTemp->val + nodeTemp1->val;
        if(isTen)
        {
            iTemp +=1;
        }
        if(iTemp >= 10)
        {
            isTen = true;
            iTemp = iTemp -10;
        }   
        else
        {
            isTen = false;
        }      
        vctResult.push_back(iTemp);
        nodeTemp = nodeTemp->next;
        nodeTemp1 = nodeTemp1->next;
    }
    //两个链表长度不相等，那么剩下的直接继续按位加即可
    while( nodeTemp!= nullptr)
    {
        if(isTen)//注意上一个while 后可能还有进位 1
        {
            if(nodeTemp->val + 1 ==10)//继续进位
            {
                vctResult.push_back(0);
                isTen = true;
            }
            else
            {
                vctResult.push_back(nodeTemp->val+1);
                isTen = false;
            }
            nodeTemp=nodeTemp->next;
        }
        else
        {
            //没有进位直接插入即可
            vctResult.push_back(nodeTemp->val);
            nodeTemp=nodeTemp->next;;
        }
    }
    //同理将剩下的都插入，和上面进位机制一样
    while( nodeTemp1 != nullptr)
    {
        if(isTen)
        {
            if(nodeTemp1->val + 1 ==10)
            {
                vctResult.push_back(0);
                isTen = true;
            }
            else
            {
                vctResult.push_back(nodeTemp1->val+1);
                isTen = false;
            }
            nodeTemp1 = nodeTemp1->next;
        }
        else
        {
            vctResult.push_back(nodeTemp1->val);
            nodeTemp1 = nodeTemp1->next;
        }
    }
    if(isTen)//注意可能最后还有一次进位
    {
        vctResult.push_back(1);
    }
    //接下来构建出链表
    bool head = true;
    ListNode* nodenext = new ListNode();
    for(int k = 0; k < vctResult.size();k++)
    {
        ListNode* node = new ListNode();
        node->val = vctResult[k];
        node->next = nullptr;
        if(head)
        {
            listResult = node;//保存头，做返回值返回
            nodenext = node;
            head = false;
        }
        else
        {
            nodenext->next = node;
            nodenext = nodenext->next;
        }
    }
    return listResult;

    }
};

可以看到时间和空间上都有所优化。

但是可以看到整个代码还是臭长臭长的，而且还开辟了一个新vector用于保存结果，空间复杂度也没有降低，还有没有更简介的写法呢？

2.3 写法简化&空间优化

之前还需要一个 bool 值来控制是否进位，每次还需要取余数等等，非常的繁琐

其实我们直接取两位和的个位数，为当前位的值，取 10 位上的数为进位即可
例如 5 + 9，

当前位为 14 % 10 = 4；
进位为：14 / 10 = 1;

而且之前会考虑链表长度不相等的情况，然后对余下的节点再做一次遍历，并且判断之前的进位：

换种思路，我们将空缺的部分补 上 0

这样来处理长度不一样的情况：

        int n1 = nodeTemp == nullptr ? 0: nodeTemp->val;
        int n2 = nodeTemp1 == nullptr ? 0:nodeTemp1->val;

完整代码示例：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    ListNode* head = nullptr;
    ListNode* tail = nullptr;
    ListNode* nodeTemp = l1;
    ListNode* nodeTemp1 = l2;
    int igientle = 0;//进位
    //开始按位相加 从 个位开始
    while(nodeTemp!=nullptr || nodeTemp1!=nullptr)
    {
        //链表长度不够时补 0 ，
        int n1 = nodeTemp == nullptr ? 0: nodeTemp->val;
        int n2 = nodeTemp1 == nullptr ? 0:nodeTemp1->val;
        int temp = n1+n2+igientle;//两位的和再加上进位
        if(!head)//先将头节点保存好
        {
            head = new ListNode(temp % 10);//取余数
            tail = head;
        }  
        else{
            tail->next = new ListNode(temp%10);
            tail = tail->next;
        }
        igientle=temp/10;//进位   
        if(nodeTemp)
        {
            nodeTemp = nodeTemp->next;
        }
        if(nodeTemp1)
        {
            nodeTemp1 = nodeTemp1->next;
        }
    }
    if(igientle > 0)//最后还有进位时也加上
    {
        tail->next = new ListNode(igientle);
    }
    return head;

    }
};

运行结果：