Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list.

Analyze and describe its complexity.

Example

Given lists:

[
  2->4->null,
  null,
  -1->null
],

return -1->2->4->null.

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param lists: a list of ListNode
     * @return: The head of one sorted list.
     */
    
    //heap sort
    public ListNode mergeKLists(List<ListNode> lists) {  
        if(lists.size() == 0) {
            return null;
        }
        Queue<ListNode> minheap = new PriorityQueue<ListNode>(lists.size(), ListNodeComparator);
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        for(int i = 0; i < lists.size(); i++) {
            ListNode node = lists.get(i);
            if(node != null) {
                minheap.add(node);
            }
        }
        while(!minheap.isEmpty()) {
            ListNode min = minheap.poll();
            tail.next = new ListNode(min.val);
            tail = tail.next;
            if(min.next != null) {
                minheap.add(min.next);
            }
        }
        return dummy.next;
     }
    
    private Comparator<ListNode> ListNodeComparator = new Comparator<ListNode>() {
        public int compare(ListNode first, ListNode second) {
            if (first == null) {
                return 1;
            } else if (second == null) {
                return -1;
            }
            return first.val - second.val;
        }
    };
}

Heap version: Suppose we have k lists and the longest list has n nodes. The space complexity is O(k), where k is the size of the min heap. The time complexity is O(nk * log k) because we need to iterate through the linked list, nk, and each time poll() or add() needs O(log k).

//merge sort
    public ListNode mergeKLists(List<ListNode> lists) {  
        if(lists.size() == 0) {
            return null;
        }
        return mergeSort(lists, 0, lists.size() - 1);
    }
    
    private ListNode mergeSort(List<ListNode> lists, int start, int end) {
        if(start == end) {
            return lists.get(start);
        }
        int mid = start + (end - start) / 2;
        ListNode left = mergeSort(lists, start, mid);
        ListNode right = mergeSort(lists, mid + 1, end);
        return sortHelper(left, right);
    }
    
    private ListNode sortHelper(ListNode right, ListNode left) {
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while(right != null && left != null) {
            if(right.val <= left.val) {
                tail.next = right;
                right = right.next;
            } else { // left < right
                tail.next = left;
                left = left.next;
            }
            tail = tail.next;
        }
        if(right != null) {
            tail.next = right;
        }
        if(left != null) {
            tail.next = left;
        }
        return dummy.next;
    }

Merge sort: time complexity: suppose we have k lists and the longest list has n nodes. T(n) = 2 T(k / 2) + O(n * k) = O(nk log k)