LeetCode(23) － Merge k Sorted Lists

　　题目和LeetCode(21)里merge two sorted List要求差不多，现在只是从2两个list变成了k个list。

　　看到这个题，第一个反应是用一个heap（最大堆）把k个list里面的数存起来，然后一个一个poll出来生成一个新的list。遍历所有list要O(n)，再堆里面插入元素，需要O(log(n))的时间，再生成新的List需要O(n)，所以平均时间为O(nlog(n) + n)，

　　代码如下：

/**
 * 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) {
        ListNode dumpNode = new ListNode(0);
        Queue<Integer> heap = new PriorityQueue<Integer>();
        //把所有元素都放到heap里面。
        for (ListNode head : lists) {
            while (head != null) {
                heap.offer(head.val);
                head = head.next;
            }
        }
        ListNode curr = dumpNode;
        //生成新的list
        while (!heap.isEmpty()) {
            curr.next = new ListNode(heap.poll());
            curr = curr.next;
        }
        return dumpNode.next;
    }   
}

　　这样做其实非常简单，但是鉴于这道题是一道hard的题，我估计这样做并不能够得到面试官的认可。首先，它并没有利用到每个list sorted的这一个性质，第二个，时间上也可以有更快的方法。

　　怎么做呢？那就是利用了归并排序的特点，divide and conquer（分治）。首先是把相邻的两个list两两配对，利用LeetCode 21 merge two sorted list的方法，分别把它们merge起来，然后继续两两配对，知道merge到一个list为止。

　　代码如下：

/**
 * 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) {
        ListNode res = mergeKListsHelper(lists,0,lists.length - 1);
        return res;
    }
    
    private ListNode mergeKListsHelper(ListNode[] lists, int left, int right) {
        //返回条件的三种情况。
        if (left > right) return null;
        //没有配对上的list
        if (left == right) return lists[left];
        //当left和right相差一个时，把它们merge起来。
        if (left + 1 == right) return mergeSortedList(lists[left],lists[right]);
        //分治，对于每一堆list，中间分开，左右各自合并，最后再merge
        int mid = (left + right) / 2;
        ListNode leftNode = mergeKListsHelper(lists, left, mid-1);
        ListNode rightNode = mergeKListsHelper(lists, mid, right);
        return mergeSortedList(leftNode, rightNode);
    }
    
    //merge两个list。和Leetcode 21一样。
    private ListNode mergeSortedList(ListNode l1, ListNode l2) {
        ListNode dumpNode = new ListNode(0);
        ListNode curr = dumpNode;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                curr.next = new ListNode(l1.val);
                l1 = l1.next;
            }
            else {
                curr.next = new ListNode(l2.val);
                l2 = l2.next;
            }
            curr = curr.next;
        }
        
        while (l1 != null) {
            curr.next = new ListNode(l1.val);
            l1 = l1.next;
            curr = curr.next;
        }
        
        while (l2 != null) {
            curr.next = new ListNode(l2.val);
            l2 = l2.next;
            curr = curr.next;
        }
        
        return dumpNode.next;
    }
}