Merge k Sorted Lists

Solution and Precautions:

Very similar to the classical merger sort for two sorted arrays, since the k linked list are already sorted, we just find the smallest number among the heads list[i][0] (i=0,…k-1), of course, if some list already reached to the end, that is list[i][0] is NULL, we just ignore this list, the smallest number is obviously the smallest one in the combined or merged final list, we repeat this process and push the smallest number found into the tail of the final merger list until there is no elements leaft. To fast find the smallest number among the k head elements, we could adopt the heap data structure, thus each found and delete of the minHeap, it cost O(log k), and it is possible to perform n such operations where n is the total number of elements of the k list, thus the time complexity is bounded by O(n * log k).

Note, the bound could be even tighter since the size of the heap could be smaller when some list is consumed up. So for the delete min operations later on it might cost less than log k. (The exact bound is not easy to figure out for me)

Min Heap Method

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
 /* Min heap*/
public class Solution {
    public ListNode mergeKLists(ArrayList<ListNode> lists) {
       if(lists == null || lists.size() == 0) return null;
       
       Comparator<ListNode> comparator = new Comparator<ListNode>(){
           public int compare(ListNode m, ListNode n){
               if(m.val == n. val) return 0;
               else if(m.val > n .val) return 1;
               else return -1;
           }
       };
       
       
       PriorityQueue<ListNode> p = new PriorityQueue<ListNode>(lists.size(), comparator);
       
       for( int i = 0; i < lists.size(); i++){
           if(lists.get(i) != null)
            p.add(lists.get(i));
       }
       
       ListNode head = null, c =null;
       
       while(!p.isEmpty()){
           if(head == null) {
               head = p.poll();
               c = head;
           } else{
               c.next = p.poll();
               c = c.next;
           }
           
           if(c.next != null) p.add(c.next);
       }
       return head;
    }
    
}

ref:http://blog.csdn.net/zyfo2/article/details/8682727

Use Merge Two sorted List Method

 /* Merge Two lists method*/
public class Solution {
    public ListNode mergeKLists(ArrayList<ListNode> lists) {
        ListNode head = null;
        int len = lists.size();
        
        if(len == 0) 
            return null;
        else if(len ==1) 
            return lists.get(0);
        
        head = merge2List(lists.get(0), lists.get(1));
        for(int i =2; i< len; i++){
            head = merge2List(lists.get(i), head);
        }
        return head;
        
    }
    
    public ListNode merge2List(ListNode node1, ListNode node2){
        ListNode head = new ListNode(Integer.MIN_VALUE);
        ListNode tmp = head;
        while(node1 != null && node2 != null){
            if(node1.val <= node2.val){
                ListNode node = new ListNode(node1.val);
                tmp.next = node;
                tmp = tmp.next;
                node1 = node1.next;
            }else{
                 ListNode node = new ListNode(node2.val);
                tmp.next = node;
                tmp = tmp.next;
                node2 = node2.next;
            }
        }
        
        if(node1 != null){
            tmp.next = node1;
        }
        
        if(node2 != null){
            tmp.next = node2;
        }
        
        return head.next;
    }
    
}