LEETCODE: Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

我只能说递归的力量是无穷的，首先我们要解决最基础的，就是两个list 的合并操作。然后，想办法把问题简化到两个，或者小于两个。

/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *merge2Lists(ListNode *list1, ListNode *list2) {
if(list1 == NULL)
return list2;
if(list2 == NULL)
return list1;

ListNode *newHead = NULL;
if(list1->val < list2->val) {
newHead = list1;
}
else {
newHead = list2;
}
while(list1 != NULL && list2 != NULL) {
ListNode *pre = NULL;
if(list1->val < list2->val) {
while(list1 != NULL && list1->val < list2->val) {
pre = list1;
list1 = list1->next;
}

pre->next = list2;

if(list1 == NULL) {
break;
}
}
else {
while(list2 != NULL && list2->val <= list1->val) {
pre = list2;
list2 = list2->next;
}

pre->next = list1;

if(list2 == NULL) {
break;
}
}
}

return newHead;
}

ListNode *mergeKListsInternal(vector<ListNode *> &lists) {
int size = lists.size();
if(size == 0) return NULL;
if(size == 1) return lists[0];
vector<ListNode *> lefts(lists.begin(), lists.begin() + size / 2);
vector<ListNode *> rights(lists.begin() + size / 2, lists.end());
ListNode *left = mergeKListsInternal(lefts);
ListNode *right = mergeKListsInternal(rights);
return merge2Lists(left, right);
}

ListNode *mergeKLists(vector<ListNode *> &lists) {
return mergeKListsInternal(lists);
}
};