Merge k Sorted Lists 解答

Question

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

Solution 1 -- Merge Sort

We can follow the method of merge sort. Time complexity O(nlog(n)), n is the total number of all nodes.

/**
 * 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 < 1)
            return null;
        if (lists.length == 1)
            return lists[0];
        int k = lists.length;
        return MSort(lists, 0, k - 1);
    }
    
    private ListNode MSort(ListNode[] lists, int start, int end) {
        if (start < end) {
            int mid = (end - start) / 2 + start;
            ListNode left = MSort(lists, start, mid);
            ListNode right = MSort(lists, mid + 1, end);
            return mergeTwoLists(left, right);
        }
        return lists[start];
    }
    
    private ListNode mergeTwoLists(ListNode a, ListNode b) {
        ListNode newHead = new ListNode(0);
        ListNode p = newHead, p1 = a, p2 = b;
        while (p1 != null && p2 != null) {
            if (p1.val < p2.val) {
                p.next = new ListNode(p1.val);
                p1 = p1.next;
            } else {
                p.next = new ListNode(p2.val);
                p2 = p2.next;
            }
            p = p.next;
        }
        while (p1 != null) {
            p.next = new ListNode(p1.val);
            p1 = p1.next;
            p = p.next;
        }
        while (p2 != null) {
            p.next = new ListNode(p2.val);
            p2 = p2.next;
            p = p.next;
        }
        return newHead.next;
    }
}

Solution 2 -- PriorityQueue

We can use PriorityQueue in Java. The elements of the priority queue are ordered according to their natural ordering, or by a comparator provided at the construction time.

PriorityQueue

Comparator

/**
 * 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 < 1)
            return null;
        ListNode newHead = new ListNode(0);
        PriorityQueue<ListNode> 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 p = newHead;
        while (pq.size() > 0) {
            ListNode tmp = pq.poll();
            p.next = tmp;
            if (tmp.next != null)
                pq.add(tmp.next);
            p = p.next;
        }
        return newHead.next;
    }
}