力扣每日一题【两数相加】

测试用例：

解题思路：
1、遍历两个链表，将两个的链表的值分别存放进v1、v2容器中
2、加法计算，将v1、v2容器中的值相加存放回tmp容器中
3、最后一步只需要将tmp容器的值取出来开辟一个新的结点，以尾插的方式串起来。

/**
 * 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) {
        vector<int> v1;
        vector<int> v2;
        vector<int> tmp;
        /*  遍历链表将两个链表中的值存放进v1、v2容器中*/
        int t = 0;
        while(l1 || l2)
        {
            if(l1)
            {
                v1.push_back(l1->val);
                l1 = l1->next;
            }
            if(l2)
            {
                v2.push_back(l2->val);
                l2 = l2->next;
            }
        }
        //加法进位，将v1、v2容器中的值取出来相加将计算结果存放进tmp数组
        for(int i = 0; i < v1.size() || i < v2.size(); i++)
        {
            if(i < v1.size()) t += v1[i];
            if(i < v2.size()) t += v2[i];
            tmp.push_back(t % 10); 
            t /= 10;
        }
        if(t) tmp.push_back(1);  //判断是否需要进位


		/* 将tmp容器中的值用链表串起来，以尾插的方式*/
        ListNode *head = nullptr;
        ListNode* tail = head;
        for(auto &ref : tmp)
        {
            ListNode* Node = new ListNode(ref);
            if(!head)
            {
                head = Node;
                tail = head;
            } 
            else 
            {
                tail->next = Node;
                tail = tail->next;
            }
            
        }
        return head;  //返回链表头
    }
};

时间复杂度：O（N）
空间复杂度：O（N）

思路二：

/**
 * 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 *cur1 = l1;
        ListNode *cur2 = l2;
        while(cur1)
        {
            if(cur2) 
            {
                //将低位结点的val值相加
                cur1->val += cur2->val;
                cur2 = cur2->next;
            }
            //如果cur1比cur2要短，那么需要将两个链表链接起来
            if(cur1->next == nullptr && cur2 != nullptr)
            {
                cur1->next = cur2;
                break;
            } 
            cur1 = cur1->next;
        }



        ListNode* head = l1;
        while(head)
        {
            if(head->val >= 10)
            {
                head->val %= 10;   //节点值val等于商值
                //防止高位缺少结点
                if(head->next == nullptr)head->next = new ListNode(0);
                head->next->val += 1;  //加法进位
            }
            head = head->next;
        }
        return l1;
    }
};

时间复杂度：O(max(m, n))
空间复杂度：O(1)