LeetCode OJ：Merge k Sorted Lists（归并k个链表）

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

类似于归并2个链表，暴力一点的方法就是，每取出一个list就与以前的list归并返回merge后list，知道所有list merge完成。

但是可惜，这样做会TLE。贴下代码先：

/**
 * 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) {
        ListNode * ret = NULL;
        for(auto * it : lists){
            ret = mergeList(ret, it);
        }
        return ret;
    }

    ListNode * mergeList(ListNode * head1, ListNode * head2)
    {
        if(!head1) return head2;
        if(!head2) return head1;
        ListNode * head = new ListNode(-1);
        head->next = head1;
        ListNode * prev = head;
        ListNode * tmpNode = NULL;
        while(head1 && head2){
            if(head1->val < head2->val){
                prev = prev->next;
                head1 = head1->next; 
            }else{
                tmpNode = head2->next;
                prev->next = head2;
                head2->next = head1;
                prev = head2;
                head2 = tmpNode;
            }
        }
        if(head2){
            prev->next = head2;
        }
        return head->next;
    }
};

下面是用堆来做的，先建立一个小堆，找到做小元素。将其merge到一个链表里面。如果后面还有元素，再将其放到堆中。代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    static bool Comp(ListNode * l1, ListNode * l2)
    {
        if(l1->val < l2->val)
            return false;
        return true;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        vector<ListNode *> removeNullList;
        removeNullList.reserve(lists.size());
        for(auto it = lists.begin(); it != lists.end(); ++it){
            if(*it != NULL)
                removeNullList.push_back(*it);
        }
        if(removeNullList.size() == 0) return NULL;    //首先去除Null节点
        make_heap(removeNullList.begin(), removeNullList.end(), Comp);
        ListNode * helper = new ListNode(-1);
        ListNode * tail = helper;
        ListNode * minNode = NULL;
        while(!removeNullList.empty()){
            pop_heap(removeNullList.begin(), removeNullList.end(), Comp);
            minNode = removeNullList[removeNullList.size()-1];
            removeNullList.pop_back();
            tail->next = minNode;
            tail = tail->next;
            if(minNode->next){//如果后面还有list的话，再次入堆
                removeNullList.push_back(minNode->next);
                make_heap(removeNullList.begin(), removeNullList.end(), Comp);
            }
        }
        return helper->next;
    }
};