Hard 23题 Merge k Sorted Lists

Question:

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

Solution:

priority queue

/**
 * 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) {
        
        if(lists==null||lists.length==0)    return null;
        
        PriorityQueue pq=new PriorityQueue<ListNode>(lists.length,new Comparator<ListNode>(){
            public int compare(ListNode a, ListNode b)
            {
                return a.val-b.val;
            }
        }); 
        for(ListNode tmp: lists)
        {
            if(tmp!=null)
            pq.add(tmp);
        }
        ListNode ans=new ListNode(0);
        ListNode tail=ans;
        while(!pq.isEmpty()){
            tail.next=(ListNode)pq.poll();
            tail=tail.next; //遍历这个list的第二个数
            if(tail.next!=null)
                pq.add(tail.next);
        }
        return ans.next;
        
    }
}

归并排序 边界条件很重要，参考http://m.blog.csdn.net/article/details?id=51582176 对于K个有序表，假设共有N个元素，且这些有序表初始状态都不为空，每个有序表平均拥有N/K个元素。最常用的方法是采用“二分”的思想进行两两合并：第一轮循环，有序表lists[0]与lists[(K+1)/2]，lists[1]与lists[(K+1)/2+1]，lists[2]与lists[(K+1)/2+2]....，lists[K/2-1]与lists[K-1]。这样K个有序表就被组合成了K/2个有序表；第二轮循环后将减少为K/4个有序表；直到组合成一个具有N个元素的有序表。总的时间复杂度：O(NKlogK)。

还有一种归并http://blog.csdn.net/worldwindjp/article/details/39989005

/**
 * 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) {
        if(lists==null||lists.length==0) return null;
        if(lists.length==1) return lists[0];
        int len=lists.length;
        while(len>1){
            int mid=(len+1)/2;
            for(int i=0;i<len/2;i++){
                lists[i]=mergeTwoLists(lists[i],lists[i+mid]);
            }
            len=mid;
        }
        return lists[0];
    }
     public ListNode mergeTwoLists(ListNode l1, ListNode l2) {  
        if (l1 == null) return l2; 
        if (l2 == null) return l1; 
        //we always get the small one  
        if (l1.val > l2.val)  
        { 
            ListNode tmp = l2; 
            tmp.next = mergeTwoLists(l1, l2.next); 
            return tmp; 
        }  
        else  
        { 
            ListNode tmp = l1; 
            tmp.next = mergeTwoLists(l1.next, l2); 
            return tmp; 
        } 
     }  
}