[Leetcode] Merge k Sorted Lists

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

 

Solution 1:

PriorityQueue:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    class myComparator implements Comparator<ListNode> {

        @Override
        public int compare(ListNode o1, ListNode o2) {
            // TODO Auto-generated method stub
            if (o1.val < o2.val) {
                return -1;
            } else if (o1.val > o2.val) {
                return 1;
            }
            return 0;
        }
    }

    public ListNode mergeKLists(List<ListNode> lists) {
        if(lists==null||lists.size()==0)
            return null;
        PriorityQueue<ListNode> pq = new PriorityQueue<ListNode>(lists.size(),
                new myComparator());
        for (ListNode head : lists) {
            if (head != null) {
                pq.add(head);
            }
        }
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        while (!pq.isEmpty()) {
            ListNode temp=pq.peek();
            pq.poll();
            cur.next=temp;
            cur=cur.next;
            if(temp.next!=null){
                pq.add(temp.next);
            }
        }
        return dummy.next;
    }
}

 

Solution 2:

 MergeSort

/**
 * 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) {
        if(lists==null||lists.size()==0)
            return null;
        
        return mSort(lists,0,lists.size()-1);
    }

    private ListNode mSort(List<ListNode> lists, int start, int end) {
        // TODO Auto-generated method stub
        if(start<end){
            int mid=(start+end)/2;
            ListNode left=mSort(lists, start, mid);
            ListNode right=mSort(lists, mid+1, end);
            return merge(left,right);
        }
        return lists.get(start);
    }

    private ListNode merge(ListNode left, ListNode right) {
        // TODO Auto-generated method stub
        if(left==null)
            return right;
        if(right==null)
            return left;
        ListNode dummy=new ListNode(-1);
        ListNode cur=dummy;
        while(left!=null&&right!=null){
            if(left.val<right.val){
                cur.next=left;
                left=left.next;
                cur=cur.next;
            }else{
                cur.next=right;
                right=right.next;
                cur=cur.next;
            }
        }
        if(left!=null){
            cur.next=left;
        }
        if(right!=null){
            cur.next=right;
        }
        return dummy.next;
    }
}