合并两个排序的链表

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

首先分析合并两个链表的过程。

链表1的头结点的值小于链表2的头结点的值，因此链表1的头结点将是合并后链表的头结点。

我们继续合并两个链表中剩余的结点。此时链表2的头结点的值小于链表1的头结点的值，因此链表2的头结点的值将是合并剩余结点得到的链表的头结点。我们把这个结点和前

面合并链表时得到的链表的尾节点链接起来，如图所示。

当我们得到两个链表中值较小的头结点并把它链接到已经合并的链表之后，两个链表剩余的结点依然是排序的，因此合并的步骤和之前的步骤是一样的。

这就是典型的递归的过程。

首先定义一个节点

//单链表进行考虑
public class ListNode {
    int val;   //自身值
    ListNode next = null;    //指向下一个节点
    ListNode(int val) {
        this.val = val;
    }
}

public class Solution {
     public ListNode Merge(ListNode pHead1,ListNode pHead2){
             if(pHead1 == null){
                    return pHead2;
             }else if(pHead2 == null){
                    return pHead1;
             }
             ListNode node = null;
             if(pHead1.val < pHead2.val){
                    node = pHead1;
                    node.next = Merge(pHead1.next, pHead2);
             }else{
                   node = pHead2;
                   node.next = Merge(pHead1, pHead2.next);
            }
            return node;

     }
     public static void main(String[] args) {
           ListNode node1 = new ListNode(1);
           ListNode node2 = new ListNode(3);
           ListNode node3 = new ListNode(5);
           ListNode node4 = new ListNode(7);
           node1.next = node2;
           node2.next = node3;
           node3.next = node4;
           node4.next = null;

           ListNode node11 = new ListNode(2);
           ListNode node12 = new ListNode(4);
           ListNode node13 = new ListNode(6);
           ListNode node14 = new ListNode(8);
           node11.next = node12;
           node12.next = node13;
           node13.next = node14;
           node14.next = null;

           Solution s = new Solution();
           ListNode node = s.Merge(node1, node11);
           while(node != null){
                 System.out.print(node.val + " ");
                 node = node.next;
           }
    }
}

结果为：

1 2 3 4 5 6 7 8