【剑指offer】链表的二路归并+链表的K路归并

🔥题目

输入两个递增排序的链表，将它们合并为一个新的递增排序的链表。

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

 

☘️解析

非常经典的二路归并。另外，链表的二路归并比数组的二路归并还要简单，因为后半部分不需要额外的while循环。
 

🧊代码

class Solution {
    public ListNode mergeTwoLists(ListNode node1, ListNode node12) {
        ListNode dummy = new ListNode(-1);
        ListNode p = dummy;
        while (node1 != null && node2 != null) {
            if (node1.val < node2.val) {
                p.next = node1;
                node1 = node1.next;
            } else {
                p.next = node2;
                node2 = node2.next;
            }
            p = p.next;
        }
        p.next = (node1 == null ? node2 : node1);
        return dummy.next;
    }
}

 

🌸补充

不妨想一想，如果不止两个递增链表，而是K个递增链表，如何进行归并呢？

 
 
 
 
 

🔥题目

输入K个递增排序的链表，将它们合并为一个新的递增排序的链表。

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]

 

☘️解析

思路一：二路归并的代码很好写，是否可以在二路归并的基础上进行K路归并呢？是可以的。

• 我们可以遍历一次，并将遍历到的第i个链表，二路归并到之前得到的链表中（$O(kn\ast k)$）。
• 更好的方案是，就像链表的归并排序那样，使用二分的方式进行递归（$O(kn\ast logk)$）。

思路二：看成多个有序链表挂在一个链表上，并用堆（小根堆）进行维护。这是个朴素且常用的思想。

 

🧊代码

思路一：在二路归并的基础上，使用二分的方式进行递归

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        return merge(lists, 0, lists.length);
    }

    private ListNode merge(ListNode[] lists, int left, int right) {
        // 0个节点
        if (left == right) {
            return null;
        }
        // 1个节点
        if (left + 1 == right) {
            return lists[left];
        }
        // 至少2个节点
        int mid = left + (right - left) / 2;
        return mergeTwo(merge(lists, left, mid), merge(lists, mid, right));
    }

	// 二路归并
    private ListNode mergeTwo(ListNode node1, ListNode node2) {
        ListNode dummy = new ListNode(-1);
        ListNode p = dummy;
        while (node1 != null && node2 != null) {
            if (node1.val < node2.val) {
                p.next = node1;
                node1 = node1.next;
            } else {
                p.next = node2;
                node2 = node2.next;
            }
            p = p.next;
        }
        p.next = (node1 == null ? node2 : node1);
        return dummy.next;
    }
}

思路二：看成多个有序链表挂在一个链表上，并用堆（小根堆）进行维护

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<ListNode> pq = new PriorityQueue<>(Comparator.comparingInt(o -> o.val));
        for (ListNode listNode : lists) {
            if (listNode != null) {
                pq.offer(listNode);
            }
        }
        ListNode dummy = new ListNode(-1);
        ListNode p = dummy;
        while (!pq.isEmpty()) {
            ListNode node = pq.poll();
            if (node.next != null) {
                pq.offer(node.next);
            }
            p.next = node;
            p = p.next;
        }
        return dummy.next;
    }
}

 

🌸补充

两种思路的时间复杂度都是 O(nk * logk)，其中k为需要归并的链表个数，n为每个链表的平均长度。可以这么理解：

1）思路一：联想归并排序，归并排序归并的是一个个数字，复杂度为klogk；而这里归并的是一个个有序链表，所以再*n。

2）思路二：一共有nk个数字，每个数字都要进堆和出堆一次；堆(优先队列)长度为k，进堆和出堆的开销都是logk，二者相乘。