Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

题意：合并两个有序链表 

思路：首先判断l1和l2的null情况，可直接return，接着初始化他的首节点为l1和l2中较小的那个；再接着，然后l1和l2往后迭代，并将mergedList的next指向他们中间较小的节点，同时将mergedList往后移动一个，同时l1和l2中较小的那个节点也向后移动一个。如此往复，直到l1或l2有一个到达结尾。

note：

1. 取了链表l1的p结点放到了新链表的末尾，不要忘记将新链表的末尾结点的next置为NULL

2. 当两个链表中的某一个遍历完了，只需要把新链表的末尾结点指向未遍历完的链表即可，不需要再循环。

C++版（class）：

/*
    public class listNode{
        int val;
        listNode next
        listNode(int x){
             val = x;
            next = null;
        }
    }

*/

public class Solution {

    public listNode mergeTwoLists(listNode l1, listNode l2){
        if(l1 == null)  return l2;
        if(l2 == null)  return l1;
        //新建头结点---可以看作是一个新的mergedlist，用来被构建
        listNode listNode;
        if(l1.val < l2.val){
            listNode.next = l1;
            l1stNode = listNode.next;
            l1 = l1.next;
        }
        //依次比较l1和l2,将结点值较小的节点赋值给新链表 同时新链表next  较小的链表next
        //将headNode留作返回值， 将listNode不断往后迭代
        listNode headNode = listNode;   
        while(l1 != null && l2 != null){
            if(l1.val <l2.val){
                listNode.next = l1;
                l1 = l1.next
                listNode = listNode.next;
            }
            else{
                listNode.next = l2;
                l2 = l2.next;
                listNode = listNode.next;
            }
        }
        //l1或l2比较长的那个，剩下节点直接接在结果list的后面
        if(l1 = null)
            listNode = l2;
        if(l2 = null)
            listNode = l1;
         
        return headNode;
    }
}

C版（struct）：

typedef struct Node{
     int val;
    Node *next;
    Node(int x) :val(x), next(NULL) {}
} listNode;

listNode* mergeTwoList(listNode* l1, listNode* l2){
    if(l1 ==NULL)
        return l2;
    if(l2 ==NULL)
        return l1;
//为了不需要再去讨论头指针是l1的第一个结点还是l2的第一个结点，设一个假的头结点，l1和l2的结点都加在它的后面，最后返回dummy_head.next即可。
    listNode dummy_head(-1);
    
    listNode *p = &dummy_head;
    while(l1 && l2)
    {
        if(l1->val < l2->val)
            {
                p->next = l1;
                l1 = l1->next;
            }
        else{
                p->next = l2;
                l2 = l2->next;
            }
        //不要忘了这两步
        p = p->next;
        P->next = NULL;
    }
    if(l1)  //不用while
        p->next = l1;
    if(l2)
        p->next = l2;
     return dummy_head.next;
}

python版：

解答：两个指针i，j，分别指向链表1和链表2的头部，循环遍历链表，比较指针所指的值，若i指针的值小于j指针，并把指针i右移，继续和链表2对比，以此类推，可用递归实现

class Solution(object):
    def mergeTwoLists(self, l1, l2):
        if not l1 or not l2: # 如果两个链表有一个为空，直接返回另一个链表即可
            return l1 or l2
        if l1.val < l2.val: # 若链表l1的值小于l2
            l1.next = self.mergeTwoLists(l1.next, l2) # l1指针右移，继续和l2指针所指的数比较
            return l1
        else:
            l2.next = self.mergeTwoLists(l1, l2.next)
            return l2

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution(object):
    def mergeTwolists(self, l1,l2):
        if l1==None:
            return l2
        if l2==None:
            return l1
        
        dummy = ListNode(0)   # 相当于头指针，不是头节点
        tmp = dummy
        while l1 and l2:
            if l1.val <= l2.val:
                tmp.next=l1
                l1 = l1.next
                tmp = tmp.next
            else:
                tmp.next=l2
                l2 = l2.next
                tmp = tmp.next
         if l1 ==None:
            tmp.next = l2
         if l2 == None:
            tmp.next = l1
        return dummy.next

reference:

C++版：https://blog.csdn.net/Mary19920410/article/details/65935351

python版：http://www.cnblogs.com/allenhaozi/p/4985236.html