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(-);
         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() == ) return NULL;    //首先去除Null节点
         make_heap(removeNullList.begin(), removeNullList.end(), Comp);
         ListNode * helper = new ListNode(-);
         ListNode * tail = helper;
         ListNode * minNode = NULL;
         while(!removeNullList.empty()){
             pop_heap(removeNullList.begin(), removeNullList.end(), Comp);
             minNode = removeNullList[removeNullList.size()-];
             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;
     }
 };