每日一题：两个有序链表的合并

21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]

提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

C语言采用暴力解法。创造第三个链表，将第一个和第二个链表进行比较，依次插入第三个链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode *l1,*l2,*l3,*l;
    struct ListNode *list3=NULL;
    l1=list1;
    l2=list2;
    if(list1==NULL&&list2==NULL)
        return list3;
    else if(list1==NULL)
        return list2;
    else if(list2==NULL)
        return list1;
    l3=(struct ListNode*)malloc(sizeof(struct ListNode));
    if(list1->val<=list2->val){
        l3->val=list1->val;
        l3->next=NULL;
        list3=l3;
        l1=list1->next;
    }
    else if(list1->val>list2->val){
        l3->val=list2->val;
        l3->next=NULL;
        list3=l3;
        l2=list2->next;
    }
    while(l1!=NULL&&l2!=NULL){
        l=(struct ListNode*)malloc(sizeof(struct ListNode));
        if(l1->val<=l2->val){
            l->val=l1->val;
            l->next=NULL;
            l3->next=l;
            l3=l;
            l1=l1->next;
        }
        else{
            l->val=l2->val;
            l->next=NULL;
            l3->next=l;
            l3=l;
            l2=l2->next;
        }
    }
    if(l1!=NULL){
        l3->next=l1;
    }
    else if(l2!=NULL){
        l3->next=l2;
    }
    return list3;
}

不建立新的链表，采用一个头结点链接两个链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode *prev,*prevhead;
    prevhead=(struct ListNode*)malloc(sizeof(struct ListNode));
    prev=prevhead;
    while(list1&&list2){
        if(list1->val<list2->val){
            prev->next=list1;
            list1=list1->next;
        }
        else{
            prev->next=list2;
            list2=list2->next;
        }
        prev=prev->next;
    }
    if(list1!=NULL)
        prev->next=list1;
    else
        prev->next=list2;
    return prevhead->next;  
}

采用递归的解法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    if(list1==NULL)
        return list2;
    else if(list2==NULL)
        return list1;
    else if(list1->val<list2->val){
        list1->next=mergeTwoLists(list1->next,list2);
        return list1;
    } 
    else{
        list2->next=mergeTwoLists(list2->next,list1);
        return list2;
    }
}

对于递归算法，想好每一层（每一个结点）的工作和出递归的条件即可，
对于每个结点来说，就是比较两个链表的当前结点的大小，然后用值比较小的结点去连接下一个比较的小的结点即可，而下一个比较小的结点属于下一层的工作，继续调用函数即可，然后该层工作最后返回本结点即可。对于出递归的条件就是当链表1或链表2为空的时候就返回对方链表。