（1）最簡單的把功能實現，沒有考慮時間和空間複雜度。

空間方面：

                對於公共的連結串列節點，都是開闢新的新的節點儲存資料，完全可以通過先判斷哪個連結串列長度長，然後利用已有的連結串列節點；同是減少了重複程式碼的使用，

                if(one!=NULL)和if(two!=NULL)下的程式段是一樣的邏輯。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* sumNode=NULL; //Use struct to define the variable
    struct ListNode* head=NULL;
   
    struct ListNode* one=l1;
    struct ListNode* two=l2;
   
    if(l1==NULL && l2==NULL)
    {
        return two;
    }
    else if(l1==NULL)
    {
        return l2;
    }
    else if(l2==NULL)
    {
        return l1;
    }
    else //two lists are not NULL
    {
        int num=0;
        struct ListNode* pre=NULL;
       
        //既要考慮進位，同時需要考慮把連結串列連線起來。
        while(one!=NULL && two!=NULL )
        {
           
                sumNode=(struct ListNode*)malloc(sizeof(struct ListNode*));
               
                if(head == NULL)
                {
                    head=sumNode;
                    //pre=sumNode;
                }
                else
                {
                    pre->next=sumNode; // ->
                }
               
                int sum=one->val+two->val+num;
                num=0; // after used, the num should be set to 0 right away
                if(sum<10)
                {
                    sumNode->val=sum;
                }
                else
                {
                    int remain=sum%10;
                    num=sum/10;
                    sumNode->val=remain;
                }
               
                pre=sumNode;
                one=one->next;
                two=two->next;
               
        }
       
        if(one==NULL && two==NULL) //Use "==" to judge
        {
            if(num==0)
            {
                pre->next=NULL;//Need to set the next to NULL
            }
            else // num != 0,the num should be used
            {
                sumNode=(struct ListNode*)malloc(sizeof(struct ListNode*));
                sumNode->val=num;
                sumNode->next=NULL;
               
                pre->next=sumNode;
               
            }
           
            return head;
        }
        else if(one!=NULL)
        {
           
            pre->next=one;
            while(num!=0 && one!=NULL)
            {
                int sum=num+one->val;
                num=0; // very important
                if(sum<10)
                {
                    one->val=sum;
                }
                else
                {
                    int remain=sum%10;
                    num=sum/10;
                    one->val=remain;
                }
               
                pre=one;
                one=one->next;
            }
           
            if(num!=0 && one==NULL)
            {
                sumNode=(struct ListNode*)malloc(sizeof(struct ListNode*));
                sumNode->val=num;
                sumNode->next=NULL;
               
                pre->next=sumNode;
            }

            return head;
        }
        else if(two!=NULL)
        {
            pre->next=two;
            while(num!=0 && two!=NULL)
            {
                int sum=num+two->val;
                num=0; // very important
                if(sum<10)
                {
                    two->val=sum;
                }
                else
                {
                    int remain=sum%10;
                    num=sum/10;
                    two->val=remain;
                }
               
                pre=two;
                two=two->next;
            }
           
            if(num!=0 && two==NULL)
            {
                sumNode=(struct ListNode*)malloc(sizeof(struct ListNode*));
                sumNode->val=num;
                sumNode->next=NULL;
               
                pre->next=sumNode;
            }

            return head;
        }
       
    }
   
    return head;
}