Merge K Sorted Lists

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

Analyse: Similiar to merge sort algorithm. Reuse the code in Merge Two Sorted Lists.

Runtime: 408ms.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size() == 0) return NULL;
        if(lists.size() == 1) return lists[0];
        
        return divide(lists, 0, lists.size() - 1);
    }
    ListNode* divide(vector<ListNode*> &lists, int left, int right){
        if(left < right){
            int m = (left + right) / 2;
            return merge2lists(divide(lists, left, m), divide(lists, m + 1, right));
        }
        return lists[left];
    }
    ListNode *merge2lists(ListNode *l1, ListNode *l2) {
        ListNode pre(-1);
        
        for(ListNode* p = &pre; l1 || l2; p = p->next){
            int val1 = l1 == nullptr ? INT_MAX : l1->val;
            int val2 = l2 == nullptr ? INT_MAX : l2->val;
            
            if(val1 > val2){
                p->next = l2;
                l2 = l2->next;
            }
            else{
                p->next = l1;
                l1 = l1->next;
            }
        }
        return pre.next;
    }
};