LeetCode 23. Merge k Sorted Lists

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

一开始按照Merge 2 Sorted Lists 的思路，然后就超时了。不过把代码贴在这儿，便于后面比较，称为方法1.

/** * 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[] listsChange = lists;        ListNode head = null;        int minIndex = -1;        for(int i=0; i< listsChange.length; i++){            if(listsChange[i]==null) continue;            if(minIndex == -1) minIndex = i;            if(listsChange[i].val < listsChange[minIndex].val){                minIndex = i;            }        }                if(minIndex == -1){            return head;        }                        head = listsChange[minIndex];        listsChange[minIndex] = listsChange[minIndex].next;        ListNode nextHead = mergeKLists(listsChange);        head.next= nextHead;        return head;    }}

看到论坛上到处Merge， 就想到应该用MergeSort来实现。代码2， 通过。

/** * Definition for singly-linked list. * public class ListNode { *     int val; *     ListNode next; *     ListNode(int x) { val = x; } * } */public class Solution {    public ListNode merge(ListNode l1, ListNode l2){        if(l1 == null) return l2;        if(l2 == null) return l1;        if(l1.val > l2.val){            l2.next = merge(l1, l2.next);            return l2;        }else{            l1.next = merge(l1.next, l2);            return l1;        }    }            public ListNode partion(ListNode[] lists, int s , int e){        if(s == e) return lists[s];        if(s>e) return null;        int q=s+(e-s)/2;        ListNode l1 = partion(lists, s, q);        ListNode l2 = partion(lists, q+1, e);                return merge(l1, l2);    }        public ListNode mergeKLists(ListNode[] lists) {        return partion(lists, 0, lists.length-1);    }}

另外，在论坛上还有看到用堆或者优先级队列的点击打开链接。代码如下。

public class Solution {    public ListNode mergeKLists(List<ListNode> lists) {        if (lists==null||lists.size()==0) return null;                PriorityQueue<ListNode> queue= new PriorityQueue<ListNode>(lists.size(),new Comparator<ListNode>(){            @Override            public int compare(ListNode o1,ListNode o2){                if (o1.val<o2.val)                    return -1;                else if (o1.val==o2.val)                    return 0;                else                     return 1;            }        });                ListNode dummy = new ListNode(0);        ListNode tail=dummy;                for (ListNode node:lists)            if (node!=null)                queue.add(node);                    while (!queue.isEmpty()){            tail.next=queue.poll();            tail=tail.next;                        if (tail.next!=null)                queue.add(tail.next);        }        return dummy.next;    }}

算法分析：

先假设几个条件。假设每个List长度相同均为m， 共用k个List， 那么一共有n = k*m 个节点。

对于方法一，每一次选一个最大的元素需要O(k)的时间复杂度， 而每个节点都需要进行一次排序，所以总的时间复杂度为O(k*(k*m)) = O(mk^2) = O(n*k)。 

对于方法二，每两个m长度的Lists 合并成一个2m长度的List 需要 O(2m)的时间复杂度，共用k/2对m长度的list， 那么全部融化成2m长度的lists需要O(2m*k/2) = O(m*k)时间复杂出。同理所有的2m长度的lists融合成4m的需要时间复杂度为O(m*k) ， 那么根据merge sort 的性质可以知道，总的时间复杂度为O(m*k *logk) =O(n*logk) ，其中logk表示由m长度到km长度所需要的步骤。

对于方法三，每个元素入堆的复杂度为O(logk)， 共用 k*m =n 个元素，那么总时间复杂度为O(m*k*logk) = O(n*logk)。

最后在看一下空间复杂度，第一种方法和第二种方法没有创建额外的空间，所以空间复杂均为O(1), 第三种方法需要维持一个最大为k的堆，所以空间复杂度为O(k)。