Lintcode : Merge K Sorted Lists

描述

合并k个排序链表，并且返回合并后的排序链表。尝试分析和描述其复杂度。

样例

给出3个排序链表[2->4->null,null,-1->null]，返回 -1->2->4->null

思路：

1. 利用归并排序，先两两合并，依次迭代，这里是利用一个递归的归并排序

    public ListNode mergeKLists(List<ListNode> lists) {
        // write your code here
        if(lists==null || lists.size()==0){
            return null;
        }
        return merge_helper(lists, 0, lists.size()-1);
    }

    private ListNode merge_helper(List<ListNode> lists, int start, int end) {
        if(start==end){
            return lists.get(start);
        }
        int mid = start+(end-start)/2;
        ListNode left = merge_helper(lists, start,mid);
        ListNode right = merge_helper(lists, mid+1, end);
        return merge_nerbor(left, right);
    }

    private ListNode merge_nerbor(ListNode h1, ListNode h2) {
        ListNode head = new ListNode(0);
        ListNode work = head;
        while (h1!=null && h2 !=null){
            if(h1.val<h2.val){
                work.next = h1;
                work = h1;
                h1 = h1.next;
            }else {
                work.next = h2;
                work = h2;
                h2 = h2.next;
            }
        }
        if(h1!=null){
            work.next = h1;
        }
        if(h2!=null){
            work.next = h2;
        }
        return head.next;
    }

2. 利用 小根堆， Java 中直接使用 PriorityQueue，比较器的定义就是比较链表节点中的 val， 每次我们取堆顶元素，

如果这个取出的节点有非空的next节点，就把这个几点添加进堆中，循环至堆空。

public static ListNode mergeKLists(List<ListNode> lists) {
        // write your code here
        if(lists==null || lists.size()==0){
            return null;
        }
        Comparator<ListNode> comparator = new Comparator<ListNode>() {
            @Override
            public int compare(ListNode o1, ListNode o2) {
                return o1.val-o2.val;
            }
        };
        PriorityQueue<ListNode> heap = new PriorityQueue<ListNode>(lists.size(), comparator);
        for (int i = 0; i < lists.size(); i++) {
            if(lists.get(i)!=null){
                heap.add(lists.get(i));
            }
        }
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (!heap.isEmpty()){
            ListNode temp = heap.poll();
            tail.next = temp;
            tail = temp;
            if(temp.next!=null){
                heap.add(temp.next);
            }
        }
        return dummy.next;
    }