Since they both require k - 1 times merge, then why using divide-conquer is better than merge list from first and one by one?

Solution 1 - Merge one by one (TLE):

```
public ListNode mergeKLists(ListNode[] lists) {
if (lists.length == 0) {
return null;
}
int i = 1;
ListNode newList = lists[0];
ListNode p = newList;
while (i < lists.length - 1) {
newList = mergeLists(newList, lists[i]);
i++;
}
return lists[i];
}
```

Solution 2 - 3ms:

```
public ListNode mergeKLists(ListNode[] lists) {
if (lists.length == 0) {
return null;
}
return mergeKLists(lists, 0, lists.length - 1);
}
public ListNode mergeKLists(ListNode[] lists, int i, int j) {
if (i == j) {
return lists[i];
}
ListNode a = lists[i];
ListNode b = lists[j];
if (j - i >= 2) {
int middle = i + (j - i) / 2;
a = mergeKLists(lists, i, middle);
if (middle + 1 != j) {
b = mergeKLists(lists, middle + 1, j);
}
}
return mergeLists(a,b);
}
```