leetcode--23. Merge k Sorted Lists

題目

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
合併n個有序鏈表

解法一

可以採用分治法。先把大任務先分成兩個子任務，然後遞歸求子任務，最後回溯回來。有點類似先分後合。這個題目也可以採用這樣的算法。即將k個鏈表平均分成兩份，繼續劃分，直到左邊界和右邊界相等，返回這個鏈表，也就是最後會分成剩下一個鏈表。 然後每兩個鏈表合併，合併之後再合併，回溯回來。最後合併成一個鏈表。完成。代碼如下。（表達不清楚，還請見諒）其中merge是合併兩個鏈表的算法。

  public ListNode mergeKLists(ListNode[] lists) {
        if(lists == null || lists.length==0) return null;
        return partion(lists,0,lists.length-1);
    }

    public static ListNode partion(ListNode[] lists,int l,int r){
        if(l<r){
            int m = (l+r)/2;
            ListNode l1 = partion(lists,l,m);
            ListNode l2 = partion(lists,m+1,r);
            return merge(l1,l2);
        } else{
            return lists[l];
        }
    }

    public static ListNode merge(ListNode l1,ListNode l2){
        if(l1 == null) return l2;
        if(l2 == null) return l1;
        if(l1.val < l2.val){
            l1.next = merge(l1.next,l2);
            return l1;
        }else{
            l2.next = merge(l1,l2.next);
            return l2;
        }
    }

解法二

使用優先隊列。優先對列底層默認使用最小堆實現的。即從對堆裏面取一個數取到的是最小的數。因此我們可以把k個節點放入優先隊列中，每次從中取最小的一個。取完再把取出節點的下一節點放進去。因爲鏈表是有序的，因此當優先隊列爲空時，所有列表都已經遍歷完了。

public ListNode mergeKLists(ArrayList<ListNode> lists) {  
    PriorityQueue<ListNode> heap = new PriorityQueue<ListNode>(10,new Comparator<ListNode>(){  
            @Override  
            public int compare(ListNode n1, ListNode n2)  
            {  
                return n1.val-n2.val;  
            }  
        });  
    for(int i=0;i<lists.size();i++)  
    {  
        ListNode node = lists.get(i);   
        if(node!=null)  
        {  
            heap.offer(node);  
        }  
    }  
    ListNode head = null;  
    ListNode pre = head;  
    while(heap.size()>0)  
    {  
        ListNode cur = heap.poll();  
        if(head == null)  
        {  
            head = cur;  
            pre = head;  
        }  
        else  
        {  
            pre.next = cur;  
        }  
        pre = cur;  
        if(cur.next!=null)  
            heap.offer(cur.next);  
    }  
    return head;  
}