Merge k Sorted Lists

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

堆实现：

class Solution {
public:
    struct cmp{
        bool operator()(ListNode* node1, ListNode* node2){
            return node1->val > node2->val;
        }
    };
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        ListNode *node = NULL;
        ListNode *head = NULL;
        priority_queue<ListNode*,vector<ListNode*>,cmp>temp;
        for(int i = 0; i < lists.size(); i++){
            if(lists[i] != NULL){
                temp.push(lists[i]);
            }
        }
        while(!temp.empty()){
            ListNode *p = temp.top();
            temp.pop();
            if(node == NULL){
				head = p;
			}
			else{
				node->next = p;
			}
            if(p->next){
                temp.push(p->next);
            }
            node = p;
        }
        return head;
    }
};

归并实现：

class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        if(lists.size() == 0){
            return NULL;
        }
        return merge(lists, 0,  lists.size() - 1);
    }
    ListNode *merge(vector<ListNode *>&lists, int left, int right){
        if(left < right){
            int m = (left + right) / 2;
            return twoMerge(merge(lists,left, m), merge(lists, m + 1, right)); 
        }
        return lists[left];
    }
    ListNode *twoMerge(ListNode *l1, ListNode *l2){
        ListNode *dummy = new ListNode(0);
        ListNode *curr = dummy;
        while(l1 != NULL && l2 != NULL){
            if(l1->val < l2->val){
                curr->next = l1;
                l1 = l1->next;
            }
            else{
                curr->next = l2;
                l2 = l2->next;
            }
            curr = curr->next;
        } 
        if(l1 != NULL){
            curr->next = l1;
        }
        if(l2 != NULL){
            curr->next = l2;
        }
        return dummy->next;
    }
};