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

Posted 2020-09-30

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

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

  1 package Solution;
  2 
  3 
  4 public class No17MergeSortedLists {
  5 
  6     public static class ListNode {
  7         int data;
  8         ListNode next;
  9 
 10         public ListNode() {
 11 
 12         }
 13 
 14         public ListNode(int value, ListNode next) {
 15             this.data = value;
 16             this.next = next;
 17         }
 18     }
 19 
 20     public static void print(ListNode head) {
 21         if (head == null)
 22             System.out.println("当前链表为空");
 23         while (head != null) {
 24             System.out.print(head.data + ",");
 25             head = head.next;
 26         }
 27         System.out.println();
 28     }
 29 　　　//递归方式合并两个排序的链表
 30     public static ListNode merge(ListNode head1, ListNode head2) {
 31         if (head1 == null)
 32             return head2;
 33         if (head2 == null)
 34             return head1;
 35         ListNode mergedHead = null;
 36         if (head1.data < head2.data) {
 37             mergedHead = head1;
 38             mergedHead.next = merge(head1.next, head2);
 39         } else {
 40             // 如果两个节点的值相同，返回第二个
 41             mergedHead = head2;
 42             mergedHead.next = merge(head1, head2.next);
 43         }
 44         return mergedHead;
 45     }
 46     //依次比较两个链表的当前结点，添加到新链表中
 47     public static ListNode mergeSortedList(ListNode head1, ListNode head2) {
 48         if (head1 == null)
 49             return head2;
 50         if (head2 == null) {
 51             return head1;
 52         }
 53         ListNode newHead = null;
 54         ListNode newNode = null;
 55         ListNode list1 = head1;
 56         ListNode list2 = head2;
 57         // 找到新的头结点
 58         if (list1.data < list2.data) {
 59             newHead = list1;
 60             list1 = list1.next;
 61         } else {
 62             newHead = list2;
 63             list2 = list2.next;
 64         }
 65         newNode = newHead;
 66         // 合并其他节点
 67         while (list1 != null && list2 != null) {
 68             if (list1.data < list2.data) {
 69                 newNode.next = list1;
 70                 list1 = list1.next;
 71             } else {
 72                 newNode.next = list2;
 73                 list2 = list2.next;
 74             }
 75             newNode = newNode.next;
 76         }
 77         // 有一条链表合并完，则把剩下的另一条链表直接合并到新链条末尾
 78         if (list1 == null) {
 79             newNode.next = list2;
 80         } else {
 81             newNode.next = list1;
 82         }
 83         return newHead;
 84     }
 85 
 86     public static void main(String[] args) {
 87         ListNode node1 = new ListNode(7, null);
 88         ListNode node2 = new ListNode(4, node1);
 89         ListNode node3 = new ListNode(3, node2);
 90         ListNode head1 = new ListNode(1, node3);
 91 
 92         ListNode node5 = new ListNode(8, null);
 93         ListNode node6 = new ListNode(6, node5);
 94         ListNode node7 = new ListNode(4, node6);
 95         ListNode head2 = new ListNode(2, node7);
 96         // 测试含有相同值得两个对各节点的链表的合并，合并后head1和merged1都指向合并后的新链表的头结点
 97         // ListNode merged1 = merge(head1, head2);
 98         // print(merged1);
 99         // // 测试含有一个null头指针的链表的合并，由于head2指向上一步合并后的新链表的第二个节点，所以输出的节点个数为总个数-1
100         // print(merge(head2, null));
101         // // 测试两个链表中只有一个节点
102         // print(merge(null, new ListNode(10, null)));
103         ListNode merged1 = mergeSortedList(head1, head2);
104         print(merged1);
105         // 测试含有一个null头指针的链表的合并，由于head2指向上一步合并后的新链表的第二个节点，所以输出的节点个数为总个数-1
106         print(mergeSortedList(head2, null));
107         // 测试两个链表中只有一个节点
108         print(mergeSortedList(null, new ListNode(10, null)));
109     }
110 
111 }