[leetcode]Merge k Sorted Lists

Merge k Sorted Lists

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

 

这道题，第一次刷是过了，第二次同样的代码超时了，看来case是在不断加强的

算法

思路1：

最土的算法，两个月前能过，现在TLE，同[leetcode]Merge Two Sorted Lists，

首先把l1和l2合并到l1中，遍历2n个节点

再把合并之后的l1和l3合并到l1中，遍历3n个节点

再把合并之后的l1和l4合并到l1中，遍历4n个节点

....

最后把合并后的l1和lm合并到l1中，遍历m*n个节点

总共遍历了（2+3+...+m）*n个节点，时间复杂度为O(n*m^2)

代码如下：

  public ListNode mergeKLists(List<ListNode> lists) {
        if(lists == null || lists.size() == 0) return null;
        ListNode l1 = lists.get(0);
        for(int i = 1; i < lists.size(); i++)
            l1 = mergeTwoLists(l1,lists.get(i));
        return l1;
    }
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) return l2;
        if(l2 == null) return l1;
        ListNode head = new ListNode(1);
        head.next = l1;
        ListNode pre = head;
        ListNode node = l2;
        while(l2 != null){
            node = l2;
            while(pre.next != null && pre.next.val <= node.val){
                pre = pre.next;
            }
            l2 = node.next;
            node.next = pre.next;
            pre.next = node;
            pre = node;
        }
        return head.next;
    }

 

思路2：

分治法，将m个list分成两拨list1,list2，对每一拨分别处理

当list.size() = 1时，直接返回， size() = 2时候，即：merge2ListNode

处理完list1 和list2之后，再把二者合并

时间负责度O(n*klogk)【其中k为list.size()】

代码如下：

public class Solution {
    public ListNode mergeKLists(List<ListNode> lists) {
        if(lists == null || lists.size() == 0) return null;
        if(lists.size() == 1) return lists.get(0);
        if(lists.size() == 2){
            return merge2List(lists.get(0), lists.get(1));
        }
        List<ListNode> l1 = new ArrayList<ListNode>();
        List<ListNode> l2 = new ArrayList<ListNode>();
        for(int i = 0;i < lists.size() ; i++){
            if(i < lists.size() / 2) l1.add(lists.get(i));
            else l2.add(lists.get(i));
        }
        ListNode list1 = mergeKLists(l1);
        ListNode list2 = mergeKLists(l2);
        return merge2List(list1, list2);
    }
    private ListNode merge2List(ListNode l1,ListNode l2){
        ListNode head = new ListNode(1);
        head.next = l1;
        ListNode pre = head;
        ListNode node = l2;
        while(l2 != null){
            node = l2;
            while(pre.next != null && pre.next.val <= node.val){
                pre = pre.next;
            }
            l2 = node.next;
            node.next = pre.next;
            pre.next = node;
            pre = node;
        }
        return head.next;
    }
}

 

思路3：

堆，由于对堆不熟悉，所以写出来的代码很丑，不过好歹AC了，时间复杂度同分治法，明天过来再优化一下：

渣代码如下：

public class Solution {
    public ListNode mergeKLists(List<ListNode> lists) {
        if(lists == null || lists.size() == 0) return null;
        int k = 0;
        List<ListNode> list = new ArrayList<ListNode>();
        for(int i = 0; i < lists.size(); i++){
            if(lists.get(i) != null) {
                k++;
                list.add(lists.get(i));
            }
        }
        if(k == 0) return null;
        if(k == 1) return list.get(0);
        ListNode[] heap = new ListNode[k];
        for(int i = 0 ; i < k ; heap[i] = list.get(i),i++);
        for(int i = k / 2  - 1; i >= 0; i--){
            adjustHeap(heap, k, i);
        }
        ListNode result = new ListNode(0);
        ListNode tail = result;
        while(true){
            if(heap[0] == null){
                heap[0] = heap[k - 1];
                k--;
            }
            adjustHeap(heap, k, 0);
            tail.next = heap[0];
            if(k == 0) break;
            heap[0] = heap[0].next;
            tail = tail.next;
        }
        return result.next;
    }
    private void adjustHeap(ListNode[] heap,int size,int i){
        while( 2 * i + 1 < size ){
            ListNode left = heap[2 * i + 1];
            if(left == null) return;
            if(2 * i + 2 < size){
                ListNode right = heap[2 * i + 2];
                if(right.val <= left.val && right.val < heap[i].val){
                    ListNode tem = right;
                    heap[2 * i + 2] = heap[i];
                    heap[i] = tem;
                    i = 2 * i + 2;
                }else if(left.val <= right.val && left.val < heap[i].val){
                    ListNode tem = left;
                    heap[2 * i + 1] = heap[i];
                    heap[i] = tem;
                    i = 2 * i + 1;
                }else return;
            }else{
                if(left.val < heap[i].val){
                    ListNode tem = left;
                    heap[2 * i + 1] = heap[i];
                    heap[i] = tem;
                }
                return;
            }
        }
    }
    
}

 

第二遍：

 使用PriorityQueue的算法更简单一点，不过需要注意要定义比较器

代码如下：

public class Solution {
    public ListNode mergeKLists(List<ListNode> lists) {
        if(lists == null || lists.size() == 0) return null;
        Queue<ListNode> pq = new PriorityQueue<ListNode>(20,new Comparator<ListNode>(){
            @Override
            public int compare(ListNode a,ListNode b){
                return a.val - b.val;
            }
        });
        ListNode newHead = new ListNode(0);
        ListNode tail = newHead;
        for(ListNode head : lists){
            if(head != null) pq.offer(head);
        }
        while(!pq.isEmpty()){
            ListNode node = pq.poll();
            tail.next = node;
            if(node.next != null) pq.offer(node.next);
            node.next = null;
            tail = node;
        }
        return newHead.next;
    }
}

 

 

 

 

 

 

 

 

参考资料：