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)。