Merge k Sorted Lists

https://oj.leetcode.com/problems/merge-k-sorted-lists/

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

解题思路：

首先想到的思路很generic，遍历k个链表的第一个节点，找出最小的那个，加入待返回的链表，同时这个节点往后一个，其他不动，然后再这样比较。在这个过程中，如果哪个链表的节点已经到了最后，就在lists里面删去他，这样直到lists为空就可以了。

这个过程中需要注意几点。第一是，在lists的循环内，进行remove操作，是有问题的。因为已经改变了lists的size，这样i其实已经往后走一个了，必须也i--。否则，就要使用iterator，这个迭代器可以避免这个问题。

第二就是，lists中获取某个节点，往后迭代，还要重新写回lists中，需要用到List.set(index, Object)的方法。

类似于lists.get(begin) = merge2Lists(lists.get(begin), lists.get(end));的写法有什么不对？因为左侧不是一个variable，而是一个对象，怎么能给他赋值？这时一个很初级却比较容易犯的错误。

假设有k个链表，最大的链表有n个元素，这个算法是需要k*nk的时间的，会超时。

/**

 * 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) {

        ListNode mergedNode = new ListNode(Integer.MAX_VALUE);

        ListNode headNode = mergedNode;

        

        while(lists.size() > 0){

            int minNodeIndex = 0;

            for(int i = 0; i < lists.size(); i++){

                if(lists.get(i) == null){

                    lists.remove(i);

                    i--;

                    continue;

                }

            

                int min = Integer.MAX_VALUE;

            

                if(lists.get(i).val < min){

                    minNodeIndex = i;

                }

            }

            if(lists.size() == 0){

                break;

            }

            mergedNode.next = lists.get(minNodeIndex);

            mergedNode = mergedNode.next;

            lists.set(minNodeIndex, lists.get(minNodeIndex).next);

        }

        return headNode.next;

    }

}

然后想到，可以把这kn个节点全部放入数组中，排序，然后形成新的链表，时间复杂度为O(knlog(kn))，空间复杂度为O(kn)。

也可以采用堆而不是数组的数据结构。建造一个最小堆，堆的大小为k。将本次遍历的k个元素放入堆，取出堆顶的元素，也就是当前最小的元素，然后和上面的步骤一样。因为堆的取出顶元素的时间为O(1)，insert时间为O(logn)，n为堆的大小。这样可以把kn*n的时间节省到kn*logk，空间复杂为O(k)。

在java语言中，PriorityQueue的类就是最小堆的实现。在实际实现的过程中，需要重写compareTo的方法，有两种。一种是让ListNode类去实现Comparable的接口，然后override它的compareTo()方法。这种方法要求修改ListNode类，不太可行。第二种就是自己写一个Compare implements Comparator<T>的类，去override它的compare()方法。然后建立PriorityQueue的时候，用new PriorityQueue(size, new Compare())去构造一个最小堆。

借助内部类，可以去尝试实现第二种方法，下面是具体的代码。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) {

 *         val = x;

 *         next = null;

 *     }

 * }

 */

public class Solution {

    public class Compare implements Comparator<ListNode>{

        public int compare(ListNode l1, ListNode l2){

            return l1.val - l2.val;

        }

    }

    

    public ListNode mergeKLists(List<ListNode> lists) {

        if(lists.size() == 0){

            return null;

        }

        

        ListNode headNode = new ListNode(0);

        ListNode iterateNode = headNode;

        PriorityQueue<ListNode> queue = new PriorityQueue<ListNode>(lists.size(), new Compare());

        

        for(int i = 0; i < lists.size(); i++){

            if(lists.get(i) == null){

                lists.remove(i);

                i--;

                continue;

            }

            queue.add(lists.get(i));

        }

        

        while(queue.size() > 0){

            iterateNode.next = queue.poll();

            iterateNode = iterateNode.next;

            if(iterateNode.next != null){

                queue.add(iterateNode.next);

            }

        }

        

        return headNode.next;

    }

}

上面的方法是AC的。

又想到借助于merge2Lists的方法，从第一个链表开始，每次merge下一个，两两归并，也就是在外面套了一层循环。很可惜，这种解法也是超时的。

/**

 * 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) {

        ListNode headNode = null;



        for(int i = 0; i < lists.size(); i++){

            headNode = merge2Lists(headNode, lists.get(i));

        }

        return headNode;

    }

    

    public ListNode merge2Lists(ListNode l1, ListNode l2) {

        if(l1 == null){

            return l2;

        }

        if(l2 == null){

            return l1;

        }

        ListNode dummy = new ListNode(0);

        ListNode returnNode = dummy;

        

        while(l1 != null && l2 != null){

            if(l1.val < l2.val){

                dummy.next = l1;

                dummy = dummy.next;

                l1 = l1.next;

            }else {

                dummy.next = l2;

                dummy = dummy.next;

                l2 = l2.next;

            }

        }

        

        if(l1 == null){

            dummy.next = l2;

        }

        if(l2 == null){

            dummy.next = l1;

        }

        return returnNode.next;

    }

}

为了解决超时的方法，这里使用两两归并排序的方法。使用两个指针，指向头尾节点，然后对他们排序，将排序得到的链表放入首节点的位置，然后两个节点往中间靠，直到首尾指针相遇。这时尾指针不动，首指针从0再开始循环，重复上述过程，直到尾指针到0。这时返回首元素，就是归并好的链表。

这个方法的时间复杂度为O(kn*logk)。

/**

 * 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.size() == 0){

            return null;

        }

        int end = lists.size() - 1;

        int begin = 0;

        

        while(end > 0){

            begin = 0;

            while(begin < end){

                lists.set(begin, merge2Lists(lists.get(begin), lists.get(end)));

                begin++;

                end--;

            }

        }

        return lists.get(0);

    }

    

    public ListNode merge2Lists(ListNode l1, ListNode l2) {

        if(l1 == null){

            return l2;

        }

        if(l2 == null){

            return l1;

        }

        ListNode dummy = new ListNode(0);

        ListNode returnNode = dummy;

        

        while(l1 != null && l2 != null){

            if(l1.val < l2.val){

                dummy.next = l1;

                dummy = dummy.next;

                l1 = l1.next;

            }else {

                dummy.next = l2;

                dummy = dummy.next;

                l2 = l2.next;

            }

        }

        

        if(l1 == null){

            dummy.next = l2;

        }

        if(l2 == null){

            dummy.next = l1;

        }

        return returnNode.next;

    }

}

总结一下，这道题有两种解法，一种是利用最小堆的数据结构，另一种利用merge2Lists的方法，而且在中间采用了二分排序，每次两两merge，也可以解决问题。

这两种解法虽然时间复杂度都是O(kn*logk)，但是思路上完全是两个方向，值得好好体会。特别是在解决一个问题，时间复杂度很高的时候，如果去降低它。我们看到可以借助更好的数据结构，比如堆，但是要花费一些额外的空间，可是能够很简便的解决比较复杂的问题。在不允许使用这种已有的数据结构时，多数是可以采用折半或者两两归并的方法，借助已有的方法，取解决问题，将线性的时间复杂度降低到对数时间。

参考文章：

http://bangbingsyb.blogspot.jp/2014/11/leetcode-merge-k-sorted-lists.html

http://fmarss.blogspot.jp/2014/09/leetcode-solution_11.html

http://blog.csdn.net/linhuanmars/article/details/19899259

https://oj.leetcode.com/discuss/26/is-the-complexity-o-kn

https://oj.leetcode.com/discuss/23855/java-solution-without-recursion-feel-free-to-comment

update 2015/06/21:

三刷，上面归并算法的一个递归的写法

/**

 * 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.length == 0) {

            return null;

        }

        return mergeHelper(lists, 0, lists.length - 1);

    }

    

    public ListNode mergeHelper(ListNode[] lists, int start, int end) {

        if(start == end) {

            return lists[start];

        }

        if(start > end) {

            return null;

        }

        int mid = start + (end - start) / 2;

        ListNode left = mergeHelper(lists, start, mid);

        ListNode right = mergeHelper(lists, mid + 1, end);

        return mergeTwoLists(left, right);

    }

    

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        ListNode dummy = new ListNode(0);

        ListNode res = dummy;

        while(l1 != null && l2 != null) {

            if(l1.val <= l2.val) {

                dummy.next = l1;

                l1 = l1.next;

                dummy = dummy.next;

            } else {

                dummy.next = l2;

                l2 = l2.next;

                dummy = dummy.next;

            }

        }

        if(l1 == null) {

            dummy.next = l2;

        } else {

            dummy.next = l1;

        }

        return res.next;

    }

}