剑指offer面试题17：合并两个排序的链表

题目：输入两个递增排序的链表，合并这两个链表并使新链表中的节点人是按照递增排序的。
解题思路：两个链表分别都已经是有序的了，遍历链表的时候只要比较两个链表当前位置大小，取出最小的添加到新链表中。

可以有递归、循环两种方式来解决。

 package Solution;

 public class No17MergeSortedLists {

     public static class ListNode {
         int data;
         ListNode next;

         public ListNode() {

         }

         public ListNode(int value, ListNode next) {
             this.data = value;
             this.next = next;
         }
     }

     public static void print(ListNode head) {
         if (head == null)
             System.out.println("当前链表为空");
         while (head != null) {
             System.out.print(head.data + ",");
             head = head.next;
         }
         System.out.println();
     }
 　　　//递归方式合并两个排序的链表
     public static ListNode merge(ListNode head1, ListNode head2) {
         if (head1 == null)
             return head2;
         if (head2 == null)
             return head1;
         ListNode mergedHead = null;
         if (head1.data < head2.data) {
             mergedHead = head1;
             mergedHead.next = merge(head1.next, head2);
         } else {
             // 如果两个节点的值相同，返回第二个
             mergedHead = head2;
             mergedHead.next = merge(head1, head2.next);
         }
         return mergedHead;
     }
     //依次比较两个链表的当前结点，添加到新链表中
     public static ListNode mergeSortedList(ListNode head1, ListNode head2) {
         if (head1 == null)
             return head2;
         if (head2 == null) {
             return head1;
         }
         ListNode newHead = null;
         ListNode newNode = null;
         ListNode list1 = head1;
         ListNode list2 = head2;
         // 找到新的头结点
         if (list1.data < list2.data) {
             newHead = list1;
             list1 = list1.next;
         } else {
             newHead = list2;
             list2 = list2.next;
         }
         newNode = newHead;
         // 合并其他节点
         while (list1 != null && list2 != null) {
             if (list1.data < list2.data) {
                 newNode.next = list1;
                 list1 = list1.next;
             } else {
                 newNode.next = list2;
                 list2 = list2.next;
             }
             newNode = newNode.next;
         }
         // 有一条链表合并完，则把剩下的另一条链表直接合并到新链条末尾
         if (list1 == null) {
             newNode.next = list2;
         } else {
             newNode.next = list1;
         }
         return newHead;
     }

     public static void main(String[] args) {
         ListNode node1 = new ListNode(7, null);
         ListNode node2 = new ListNode(4, node1);
         ListNode node3 = new ListNode(3, node2);
         ListNode head1 = new ListNode(1, node3);

         ListNode node5 = new ListNode(8, null);
         ListNode node6 = new ListNode(6, node5);
         ListNode node7 = new ListNode(4, node6);
         ListNode head2 = new ListNode(2, node7);
         // 测试含有相同值得两个对各节点的链表的合并，合并后head1和merged1都指向合并后的新链表的头结点
         // ListNode merged1 = merge(head1, head2);
         // print(merged1);
         // // 测试含有一个null头指针的链表的合并，由于head2指向上一步合并后的新链表的第二个节点，所以输出的节点个数为总个数-1
         // print(merge(head2, null));
         // // 测试两个链表中只有一个节点
         // print(merge(null, new ListNode(10, null)));
         ListNode merged1 = mergeSortedList(head1, head2);
         print(merged1);
         // 测试含有一个null头指针的链表的合并，由于head2指向上一步合并后的新链表的第二个节点，所以输出的节点个数为总个数-1
         print(mergeSortedList(head2, null));
         // 测试两个链表中只有一个节点
         print(mergeSortedList(null, new ListNode(10, null)));
     }

 }