leetcode---(2). 两数相加

题目：

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

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

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

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

/**
 * 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 *l3 = new ListNode(0);     //有头节点
        ListNode *l3_tail = l3;             //因为需要尾插
        int cy = 0;                         //进位标志

        while(l1 && l2){
            if((l1->val + l2->val + cy) > 9){
                l3_tail->next = new ListNode(l1->val + l2->val + cy - 10);
                cy = 1;
            }
            else{
                l3_tail->next = new ListNode(l1->val + l2->val + cy);
                cy = 0;
            }
            l1 = l1 -> next;
            l2 = l2 -> next;
            l3_tail = l3_tail->next;
        }

        //删除头节点
        ListNode *p = l3;
        l3 = l3 -> next;
        delete(p);      //new和delete，malloc和free最好结对使用
        p = nullptr;

        //判断哪一个还有剩余
        ListNode* lx;
        if(l1){
            lx = l1;
        } 
        else if(l2){
            lx = l2;
        }else{
            if(cy)
                l3_tail->next = new ListNode(1);
            return l3;
        }

        while(lx){
            if((lx->val + cy) > 9){
                l3_tail->next = new ListNode(lx->val  + cy -10);
                cy = 1;
            }else{
                l3_tail->next = new ListNode(lx->val  + cy);
                cy = 0;
            }
            lx = lx->next;
            l3_tail = l3_tail->next;
        }

        if(cy)
            l3_tail->next = new ListNode(1);
    
        l3_tail = nullptr;
        return l3;
    }
};

总结：调试中出现的问题：
1.之前创建新的节点的时侯没有new。结果就是作用域只在这个class里面，是临时变量，执行完这一段空间就会被释放。返回的地址也是一个未知结果。加了new之后就会在堆上分配空间，不delete（）不会删除，需要手动删除。
2.没有考虑到最后加上剩余的部分的时侯其实也是需要进位的。尤其是所有节点都加完之后还要看看进位标志，有进位前面加1。
3.new 要和delete配对。习惯free了，结果造成内存泄漏的问题，很难排查。

看了官方的代码觉得自己实现写的太罗嗦了。下面分析一下官方的解法。

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *head = nullptr, *tail = nullptr;
        int carry = 0;
        while (l1 || l2) {
            int n1 = l1 ? l1->val: 0;//这里就不用区分到底是哪一个还存在的，搞一堆判断了。
            int n2 = l2 ? l2->val: 0;
            int sum = n1 + n2 + carry;
            if (!head) {    //通过这步判断我们就不用创建头节点，再删除头节点了
                head = tail = new ListNode(sum % 10);
            } else {
                tail->next = new ListNode(sum % 10);
                tail = tail->next;
            }
            carry = sum / 10;//这里也省了判断
            if (l1) {
                l1 = l1->next;
            }
            if (l2) {
                l2 = l2->next;
            }
        }
        if (carry > 0) {
            tail->next = new ListNode(carry);
        }
        return head;
    }
};

纸上得来终觉浅 ，绝知此事要躬行。码农还是要多敲代码。