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;
    }
}