For this problem, use merge sort is simple and fast, I wonder why some guys solve it use PriorityQueue.

I think the complexity is k * n * logk. Because the recursion depth is logK, and in each level, every element will be compared.

```
public ListNode mergeKLists(ListNode[] lists) {
if (lists == null || lists.length == 0)
return null;
return mergeKLists(lists, 0, lists.length - 1);
}
private ListNode mergeKLists(ListNode[] lists, int start, int end) {
if (start == end) {
return lists[start];
} else if (start < end){
int mid = (end - start) / 2 + start;
ListNode left = mergeKLists(lists, start, mid);
ListNode right = mergeKLists(lists, mid + 1, end);
return mergeTwoLists(left, right);
} else {
return null;
}
}
```

mergeTwoLists is base on the Merge Two Sorted Lists problem.