剑指offer：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

题目分析
方法一 递归
首先比较两个头节点大小，小的做新链表的头节点。之后进行递归，如下图所示

下面是JAVA算法实现：

public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1 == null){
            return list2;
        }
        if(list2 == null){
            return list1;
        }
        
        ListNode res = null;
        if(list1.val < list2.val){
            res = list1;
            res.next = Merge(list1.next , list2);
        }else{
            res = list2;
            res.next = Merge(list1,list2.next);
        }
        return res;
    }

方法二 非递归

利用

public ListNode Merge(ListNode list1,ListNode list2) {
		//判断边界
        if(list1 == null &&list2 == null){
            return null;
        }
        if(list1 == null &&list2 !=null){
            return list2;
        }
        if(list1 != null &&list2 ==null){
            return list1;
        }
        
        //result存储合成后的链表
        ListNode result = null;
        //pHead存储合成后链表头部
        ListNode pHead = null;
        
        while(list1!=null&&list2!=null){
            if(list1.val <=list2.val){
                if(pHead == null){
                //存储头节点，顺便将第一次判断的结果放入result
                    pHead = result = list1;
                }else{
                //每次循环注意直接用当前节点指针向前指。
                    result.next = list1;
                    result = result.next;
                }
                list1 = list1.next;
            }else{
                if(pHead == null){
                //存储头节点，顺便将第一次判断的结果放入result
                    pHead = result = list2;
                }else{
                    result.next = list2;
                    result = result.next;
                }
                list2 = list2.next;
            }
            
        }
        //如果list1比list2短，则后续直接连接上list2；反之亦然。
        if(list1 == null){
            result.next = list2;
        }else{
            result.next = list1;
        }
        //返回链表头节点。
        return pHead;
    }