LeetCode 23. Merge k Sorted Lists

Merge k sorted
linked lists and return it as one sorted list. Analyze and describe its complexity.

一开始按照Merge 2 Sorted Lists 的思路，然后就超时了。不过把代码贴在这儿，便于后面比较，称为方法1.

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode mergeKLists(ListNode[] lists) {
ListNode[] listsChange = lists;
ListNode head = null;
int minIndex = -1;
for(int i=0; i< listsChange.length; i++){
if(listsChange[i]==null) continue;
if(minIndex == -1) minIndex = i;
if(listsChange[i].val < listsChange[minIndex].val){
minIndex = i;
}
}

if(minIndex == -1){
return head;
}

head = listsChange[minIndex];
listsChange[minIndex] = listsChange[minIndex].next;
ListNode nextHead = mergeKLists(listsChange);
head.next= nextHead;
return head;
}
}

看到论坛上到处Merge， 就想到应该用MergeSort来实现。代码2， 通过。

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode merge(ListNode l1, ListNode l2){
if(l1 == null) return l2;
if(l2 == null) return l1;
if(l1.val > l2.val){
l2.next = merge(l1, l2.next);
return l2;
}else{
l1.next = merge(l1.next, l2);
return l1;
}
}

public ListNode partion(ListNode[] lists, int s , int e){
if(s == e) return lists[s];
if(s>e) return null;
int q=s+(e-s)/2;
ListNode l1 = partion(lists, s, q);
ListNode l2 = partion(lists, q+1, e);

return merge(l1, l2);
}

public ListNode mergeKLists(ListNode[] lists) {
return partion(lists, 0, lists.length-1);
}
}

另外，在论坛上还有看到用堆或者优先级队列的点击打开链接。代码如下。

public class Solution {
public ListNode mergeKLists(List<ListNode> lists) {
if (lists==null||lists.size()==0) return null;

PriorityQueue<ListNode> queue= new PriorityQueue<ListNode>(lists.size(),new Comparator<ListNode>(){
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val)
return -1;
else if (o1.val==o2.val)
return 0;
else
return 1;
}
});

ListNode dummy = new ListNode(0);
ListNode tail=dummy;

for (ListNode node:lists)
if (node!=null)
queue.add(node);

while (!queue.isEmpty()){
tail.next=queue.poll();
tail=tail.next;

if (tail.next!=null)
queue.add(tail.next);
}
return dummy.next;
}
}

算法分析：

先假设几个条件。假设每个List长度相同均为m， 共用k个List， 那么一共有n = k*m 个节点。

对于方法一，每一次选一个最大的元素需要O(k)的时间复杂度， 而每个节点都需要进行一次排序，所以总的时间复杂度为O(k*(k*m)) = O(mk^2) = O(n*k)。 

对于方法二，每两个m长度的Lists 合并成一个2m长度的List 需要 O(2m)的时间复杂度，共用k/2对m长度的list， 那么全部融化成2m长度的lists需要O(2m*k/2) = O(m*k)时间复杂出。同理所有的2m长度的lists融合成4m的需要时间复杂度为O(m*k)
， 那么根据merge sort 的性质可以知道，总的时间复杂度为O(m*k *logk) =O(n*logk) ，其中logk表示由m长度到km长度所需要的步骤。

对于方法三，每个元素入堆的复杂度为O(logk)， 共用 k*m =n 个元素，那么总时间复杂度为O(m*k*logk) = O(n*logk)。

最后在看一下空间复杂度，第一种方法和第二种方法没有创建额外的空间，所以空间复杂均为O(1), 第三种方法需要维持一个最大为k的堆，所以空间复杂度为O(k)。