leetcode题目 合并N个排序好的链表

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

思路： 两种方法，第一种思路调用合并两个排序好链表的函数，时间效率O（kN）,k是链表个数，N是所有链表节点总数。第二种思路采用一个最小堆，先将k的链表的头结点构造成一个最小堆，取出最小的元素，并将最小元素所在链表的下一个元素压入堆中。直至堆为空。时间效率O（Nlogk）。本文两种代码均实现了。

解法一： 容易理解，但是时间效率差。虽然在本地对数据量小的测试用例都通过了。但leetcode上本题的难度系数是困难，所以这种方法不会通过，结果是时间超限，

class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
if(!lists.size())
return NULL;

ListNode* phead=NULL;
for(auto i=lists.begin();i!=lists.end();++i)
{
phead=mergeTwoLists(phead,*i);
}
return phead;
}
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if(l1==NULL)
return l2;
if(l2==NULL)
return l1;
ListNode* pmerge=NULL;
if(l1->val<l2->val)
{
pmerge=l1;
pmerge->next=mergeTwoLists(l1->next,l2);
}
else
{
pmerge=l2;
pmerge->next=mergeTwoLists(l1,l2->next);
}
return pmerge;
}
};

解法二： 利用堆，时间效率好，代码如下

/**
* 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) {
vector<ListNode*> heap;
for(auto i=lists.begin();i!=lists.end();++i)
{
if(*i!=NULL)
heap.push_back(*i);
}

//若堆为空，表示所有链表都为空或者lists本身为空
if(!heap.size())
return NULL;

ListNode* head,*p;
make_heap(heap.begin(),heap.end(),greater);
pop_heap(heap.begin(),heap.end(),greater);
head=p=heap.back();
heap.pop_back();

//堆非空，取出最小结点，然后压入最小结点的下一个结点
while(heap.size())
{
if(p->next!=NULL)
{
heap.push_back(p->next);
push_heap(heap.begin(),heap.end(),greater);
}
pop_heap(heap.begin(),heap.end(),greater);
p->next=heap.back();
heap.pop_back();
p=p->next;
}
return head;
}

//本程序堆中存放的是指针，并且要实现最小堆，所以写一个简单的比较函数
static  bool greater(ListNode* l1,ListNode* l2)
{
if(l1->val>l2->val)
return true;
else
return false;
}
};

运行结果通过，并且击败了99.29%的代码有木有！！！