Add Two Numbers

这道题逻辑不难，但是对于指针和链表都搞不定的我感觉要死了.....

先说几件事，int *p=&i，这个意思就是p指向i了，p存的是i的地址，int *p; p=&i;这个和前面的意思一样.....

链表的操作，恩不说了随便找套路都一样，这道题用了在尾结点后插入，套路就是现定义一个头结点，然后定义一个指向头结点的指针，之后的操作用这个指针，返回的时候返回头结点相关的。

但遇到了一个不懂的问题，ListNode y(temp%10);p->next=&y就不对，但是用p->next=new ListNode(temp%10)就对，不理解.....求好心人指导.....

理解了！这样子的，如果是直接定义不new，如果脱离作用于，这个内存就被释放了，这里面每进一次while，都会被自动释放一次，所以最后没报错，但是返回空。但是如果你用new的话，就不会被释放，所以就可以存下来了。tips：new是在堆上，可以自己分配释放，直接定义是在栈上，无法自己分配，而且超了作用域，就被自动释放了。

最慢的：

/**
 * 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 Head(0);
        ListNode *p=&Head;
        int temp=0;
        int carry=0;
        while(l1!=NULL||l2!=NULL)
        {
            if(l1==NULL)
            {
               temp=l2->val+carry;
               l2=l2->next;
           }
           else if(l2==NULL)
           {
               temp=l1->val+carry;
               l1=l1->next;
           }
           else
           {
               temp=l1->val+l2->val+carry;
               l1=l1->next;
               l2=l2->next;
           }
           carry=temp/10;
           p->next=new ListNode(temp%10);
           p=p->next;
        }
        if(carry!=0)
        {
            p->next=new ListNode(carry);
            p=p->next;
        }
        return Head.next; 
        
    }
};

代码十分简洁版：

/**
 * 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 Head(0);
        ListNode *p=&Head;
        int temp=0;
        int carry=0;
        while(l1!=NULL||l2!=NULL||carry!=0)
        {
           temp=(l1?l1->val:0)+(l2?l2->val:0)+carry;
           l1=l1?l1->next:NULL;
           l2=l2?l2->next:NULL;
           carry=temp/10;
           p->next=new ListNode(temp%10);
           p=p->next;
        }
       
        return Head.next; 
        
    }
};

一个小差距速度提升很多的：

/**
 * 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 Head(0);
        ListNode *p=&Head;
        int temp=0;
        int carry=0;
        while(l1||l2||carry)
        {
           temp=(l1?l1->val:0)+(l2?l2->val:0)+carry;
           l1=l1?l1->next:NULL;
           l2=l2?l2->next:NULL;
           carry=temp/10;
           p->next=new ListNode(temp%10);
           p=p->next;
        }
       
        return Head.next; 
        
    }
};