leetcode:Merge k Sorted Lists

Merge k Sorted Lists

Total Accepted: 19819 Total Submissions: 92236

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

其实就是k路的归并排序

所以很快的, 只要对listNode 进行 K - 1次的归并排序即可,然后他给了我一个无情的tle

tle代码如下:

/** * 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 ans = null;        for(ListNode t : lists){            ans = merge2Lists(ans, t);        }        return ans;    }        public ListNode merge2Lists(ListNode h1, ListNode h2){        ListNode head = null;        if(h1 != null && h2 != null){            head = new ListNode(-1);            ListNode pre = head;            while(h1 != null && h2 != null){                if(h1.val < h2.val){                    pre.next = h1;                    pre = h1;                    h1 = h1.next;                }                else{                    pre.next = h2;                    pre = h2;                    h2 = h2.next;                }            }            pre.next = (h1 == null ? h2 : h1);            head = head.next;        }else {            head = (h1 == null ? h2 : h1);        }        return head;    }}

认真想,一个一个的归并起来会使得第一个的有序链表变得越来越大,

假设 K路的个数为k1,k2,k3, ... kk

那么第一次归并就是  = k1 ,

第二次就是归并      k1 + k2

第k次就是  k1 + k2 ... + kk   然后第一次到第k次的和就是归并的总次数了 可以计算得到为

 k * k1 + (k - 1) * k2 + (k - 2) * k3 ......+ kk

又假设平均长度为len , 那么 k * k1 + (k - 1) * k2 + (k - 2) * k3 ......+ kk = len * k * (k + 1) / 2

显然,我们是可以通过分治的思想进行减低时间复杂度的,

假设k 为2的幂次, function (k) 代表合并 k个链表花费的时间

那么就会有如下公式计算:

k == 2  : 那么就是直接两个ListNode的长度之和

k > 2 :    2 * function(k / 2)

function(k) = 2 * function (k / 2), 递归计算

所以时间复杂度就变成了 len * k * lg(k), 代码如下:

/** * 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 ans = dividerAndComquer(lists, 0, lists.size());        return ans;    }        public static  ListNode dividerAndComquer(List<ListNode> lists, int start, int end){        if(end - start <= 2){            ListNode ans = null;            while(start < end){                ans = merge2Lists(ans, lists.get(start));                ++start;            }            return ans;        }        else{            ListNode h1 = dividerAndComquer(lists, start, (start + end) / 2);            ListNode h2 = dividerAndComquer(lists, (start + end) / 2, end);            h1 = merge2Lists(h1, h2);            return h1;        }    }                    public static ListNode merge2Lists(ListNode h1, ListNode h2){        ListNode head = null;        if(h1 != null && h2 != null){            head = new ListNode(-1);            ListNode pre = head;            while(h1 != null && h2 != null){                if(h1.val < h2.val){                    pre.next = h1;                    pre = h1;                    h1 = h1.next;                }                else{                    pre.next = h2;                    pre = h2;                    h2 = h2.next;                }            }            pre.next = (h1 == null ? h2 : h1);            head = head.next;        }else {            head = (h1 == null ? h2 : h1);        }        return head;    }}