合併 k 個排序連結串列，返回合併後的排序連結串列。請分析和描述演算法的複雜度。

示例:

輸入:
[
  1->4->5,
  1->3->4,
  2->6
]
輸出: 1->1->2->3->4->4->5->6

解答：

複用LeetCode21合併兩個連結串列的程式碼，將連結串列0和連結串列1進行合併生成新的連結串列，然後再將新的連結串列與連結串列2合併，依次類推。

時間複雜度為$m^2*n$，其中m代表連結串列的個數，n代表連結串列元素的個數。

**
 * Definition for singly-linked list.
 

 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) return l2;
        if (l2 == null) return l1;


        ListNode listNode = new ListNode(0);
        ListNode head =
 
 listNode;

        ListNode p = new ListNode(0);


        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                listNode.next = l1;
                p = l1;
                l1 = l1.next;
            }
            else{
                listNode.next = l2;
                p =
 
 l2;
                l2 = l2.next;
            }
            listNode = listNode.next;
        }

        if (l1 == null) p.next = l2;
        if (l2 == null) p.next = l1;
        // l1 作為返回連結串列
        return head.next;
    }

    public ListNode mergeKLists(ListNode[] lists) {
        int len = lists.length;
        if (len == 0) return null;
        if (len == 1) return lists[0];
        for (int i = 1; i < len; i++){
            lists[0] = mergeTwoLists(lists[0], lists[i]);
        }
        return lists[0];
    }
}

採用兩兩合併的方法，鄰近的兩個連結串列合併生成m/2個連結串列，再次兩兩合併，直至只剩下一個連結串列。時間複雜度為$O(mlogm*n)$，其中m代表連結串列的個數，n代表連結串列元素的個數。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {    
        if(lists ==null || lists.length == 0){
            return null;
        }
        
        return sort(lists,0,lists.length-1);
    }
    
    public ListNode sort(ListNode[] lists , int lo ,int hi){
        if(lo >= hi){return lists[lo];}
        
        int mid = (hi-lo)/2+lo;
        ListNode l1 = sort(lists,lo,mid);
        ListNode l2 = sort(lists,mid+1,hi);
        
        return merge(l1,l2);
        
    }
    
    public ListNode merge(ListNode l1, ListNode l2) {

        ListNode h1 = l1;
        ListNode h2 = l2;

        ListNode res = new ListNode(0);

        ListNode head = res;


        while (h1 != null || h2 != null) {
            if (h1 == null || h2 == null) {
                head.next = h1 == null ? h2 : h1;
                break;
            }

            //如果h2大於或等於h1
            if (h1.val <= h2.val) {
                head.next = h1;
                h1 = h1.next;
                head = head.next;
            } else if (h1.val >= h2.val) {
                head.next = h2;
                h2 = h2.next;
                head = head.next;
            }
        }
        return res.next;
    }
}