Leetcode Merge k Sorted Lists 合併k個鏈表

題目：

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

分析：

1. 用暴力的方法一個一個合併鏈表會超時，分析所需要的時間複雜度：

假設鏈表的長度爲n，每兩個鏈表合併所需要的時間爲n+n，k個鏈表一共需要合併k-1次，那麼公式可以寫爲：

2n+3n+4n+..+kn = O(n*k^2)

2. 使用歸併排序的思想，兩個兩個的進行合併。兩兩合併的代碼和Merge Two Sorted Lists那一題一樣。分析一下這個方法所需要的時間複雜度：

把k個鏈表兩兩合併，問題規模的變化過程：k --> k/2 --> k/4 -->..-->1 一共需要logk次。

每次合併時鏈表的規模爲 ： n + 2n + 4n + 8n + .. + 2^(logk)n

所需要的時間複雜度爲： n*k + 2n*k/2 + 4n*k/4 + .. + 1*2^(logk)n = nk+nk+nk+..+nk = nklogk

Java代碼實現：

/**
 * 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) {
        if(lists==null || lists.length==0)
            return null;
        if(lists.length==1)
            return lists[0];
        
        int end = lists.length-1;
        while(end>0)
        {
            int start = 0;
            while(start<end)
            {
                lists[start] = merge2lists(lists[start], lists[end]);
                start++;
                end--;
            }
        }
        return lists[0];
    }
    private ListNode merge2lists(ListNode l1, ListNode l2)
    {
        if(l1==null)
            return l2;
        if(l2==null)
            return l1;
            
        ListNode dummy = new ListNode(0);
        ListNode node = dummy;
        while(l1!=null && l2!=null)
        {
            if(l1.val<=l2.val)
            {
                node.next = l1;
                l1 = l1.next;
            }
            else
            {
                node.next = l2;
                l2 = l2.next;
            }
            node = node.next;
        }
        while(l1!=null)
        {
            node.next = l1;
            node = node.next;
            l1 = l1.next;
        }
        while(l2!=null)
        {
            node.next = l2;
            node = node.next;
            l2 = l2.next;
        }
        
        return dummy.next;
    }
}