Leetcode-Merge k Sorted Lists

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

Have you met this question in a real interview?

 

Analysis:

record the current head of each list. Use binary insertation to arrange the head list, select the minimum one and add to the end of the return list.

 

Newest Solution (Use PriorityQueue):

/**
 * 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.length==0) return null;
        
        ListNode preHead = new ListNode(0);
        ListNode end = preHead;
        PriorityQueue<ListNode> queue = new PriorityQueue<ListNode>((a,b) -> (a.val-b.val));
        for (ListNode node : lists)
            if (node!=null){
                queue.add(node);
            }
        
        while (!queue.isEmpty()){
            ListNode nextNode = queue.poll();
            end.next = nextNode;
            if (nextNode.next!=null){
                queue.add(nextNode.next);
            }
            end = nextNode;
        }
        
        return preHead.next;
    }
}

 

 

Solution:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode mergeKLists(List<ListNode> lists) {
        //Consider the cases where the element in lists is NULL!
        for (int i=0;i<lists.size();i++)
            if (lists.get(i)==null){
                lists.remove(i);
                i--;
            }
        if (lists.size()==0) return null;
        if (lists.size()==1) return lists.get(0);

        ListNode preHead = new ListNode(0);
        ListNode end = preHead;
        List<ListNode> curList = new ArrayList<ListNode>();
        curList.add(lists.get(0));
        for (int i=1;i<lists.size();i++) binaryInsert(curList,lists.get(i));
        while (curList.size()!=0){
            if (curList.size()==1){
                end.next = curList.get(0);
                end = new ListNode(0);
                break;
            }
            ListNode target = curList.get(0);            
            curList.remove(0);
            if (target.next!=null) binaryInsert(curList,target.next);
            end.next = target;
            end = target;
        }
        end.next = null;
        return preHead.next;
        
    }

    public void binaryInsert(List<ListNode> lists, ListNode node){
        int start = 0;
        int end = lists.size()-1;
        int index = -1;
        while (start<end){
            int mid = (start+end)/2;
            if (node.val == lists.get(mid).val){
                index = mid;
                break;
            }

            if (node.val>lists.get(mid).val){
                start = mid+1;
                continue;
            }

            if (node.val<lists.get(mid).val){
                end = mid-1;
                continue;
            }
        }
        
        //NOTE: There are two ending cases, we need consider them carefully!.
        if (index==-1){
            if (start==end)
                if (node.val>lists.get(start).val) index=start+1;
                else index = start;
            else index = start;   //i.e., start>end.
        }  

        lists.add(index,node);

        return;
    }        
}