n is the length of input-list

m is the expected length of Linked-List

Time Complexity: O(n*logn*m)

Space Complexity: O(n*logn*m)

Is That RIGHT?

```
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
# @param {ListNode} l1
# @param {ListNode} l2
# @return {ListNode}
def mergeTwoLists(self, l1, l2):
l = ListNode(0)
c = l
p = None
if l1 is None:
return l2
if l2 is None:
return l1
while l1 is not None and l2 is not None:
if l1.val < l2.val:
c.next = l1
l1 = l1.next
else:
c.next = l2
l2 = l2.next
c = c.next
if l1 is None:
c.next = l2
if l2 is None:
c.next = l1
return l.next
# @param {ListNode[]} lists
# @return {ListNode}
def mergeKLists(self, lists):
if len(lists) == 0:
return None
elif len(lists) == 1:
return lists[0]
elif len(lists) == 2:
return self.mergeTwoLists(*lists)
else:
half = int(len(lists)/2 + len(lists)%2)
return self.mergeKLists([self.mergeKLists(lists[:half]),
self.mergeKLists(lists[half:])])
```