Leetcode-23: Merge k Sorted Lists

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

将k个有序的列表归并成一个有序列表。

思路：数据结构中学过的是k=2时的特例，不过实际都是每次都将所有列表中头元素最小的那个元素加入新的列表。有两种方法：
1）朴素的比较然后归并方法，对于每个新加入的元素都要做比较k次，那么复杂度将是$O(nk)$，这里的比较是重复的，即加入第一个元素的时候，$a_0$, $a_1$, …，$a_{k-1}$，做了$k$次比较，选出最小的元素，假设为$a_i$，第二次加入的时候，所有的头节点元素变成了$a_0$, $a_1$, …, $b_i$, …, $a_{k-1}$，除了$b_i$之外，其他元素都是已经做过比较的了，无需再做多余的比较，所以可以利用优先队列（最小堆）来维护这k个元素之间的顺序。建堆复杂度为$O(k)$，每次加入新元素的复杂度为$O(\lg k)$，所以总的复杂度为$O(k + (n - k)\lg k + k\lg k )=O(n\lg k + k)$。

2）由于$k>2$时会带来重复比较，那么可以将$k$转化为$k'=2$的问题，即使用分而治之的方法，将列表两两归并，最终归并成一条列表。$k=2$时，归并的复杂度为$O(n)$，两两归并的次数共$\lg k$次，所以复杂度为$O(n\lg k)$。

/**
 * 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 == 0) return null;
        if (lists.length == 1) return lists[0];
        Queue<ListNode> pq = new PriorityQueue<>(lists.length, new Comparator<ListNode>(){
            @Override
            public int compare(ListNode l1, ListNode l2) {
                if (l1.val < l2.val)
                    return -1;
                else if (l1.val > l2.val)
                    return 1;
                else
                    return 0;
            }
        });
        ListNode sential = new ListNode(0);
        for (ListNode list : lists){
            if (list != null)
                pq.add(list);
        }

        ListNode tail = sential;
        while (!pq.isEmpty()) {
            tail.next = pq.poll();
            tail = tail.next;
            if (tail.next != null)
                pq.add(tail.next);
        }
        return sential.next;
    }
}