I've run both my solution and those solution using PriorityQueue multiple time. Their running time does not differ much and primarily ranges from 350ms to 380ms. I calculate the big-O of my solution to be O(nk) while n is the length of each sorted array assume they have equal length while k is the # of array. The PQ solution is claimed to be O(nlogk), so why isn't there a bigger differences?

```
public class Solution {
// what if some element is null
public ListNode mergeKLists(ListNode[] lists) {
int len = lists.length;
if ( len == 0 ) {
return null;
} else if ( len == 1) {
return lists[0];
} else {
ListNode[] newLists = new ListNode[(len+1)/2];
for ( int i = 0; i < newLists.length; i++ ) {
int left = i, right = len-1-i;
if ( left == right ) {
newLists[i] = lists[i];
} else {
newLists[i] = mergeTwoLists(lists[left], lists[right]);
}
}
return mergeKLists(newLists);
}
}
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
if ( list1 == null && list2 == null ) { return null; }
if ( list1 == null && list2 != null ) { return list2; }
if ( list1 != null && list2 == null ) { return list1; }
ListNode dummyHead = new ListNode(0);
ListNode p1 = list1, p2 = list2, p3 = dummyHead;
while ( p1 != null && p2 != null ) {
if ( p1.val <= p2.val ) {
p3.next = p1; p1 = p1.next;
} else {
p3.next = p2; p2 = p2.next;
}
p3 = p3.next;
}
p3.next = mergeTwoLists(p1, p2);
return dummyHead.next;
}
}
```