leetcode 23: Merge k Sorted Lists

/**
* 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* res=new ListNode(-1);
ListNode* curr=res;
vector<ListNode*> heap;
heap.push_back(res);
for(int i=0;i<lists.size();i++)
if(lists[i])
heap.push_back(lists[i]);
for(int i=(heap.size()-1)/2;i>0;i--)
minheap(heap,i);
while(heap.size()>1)
{
curr->next=heap[1];
curr=curr->next;
if(heap[1]->next)
heap[1]=heap[1]->next;
else
{
swap(heap[1],heap[heap.size()-1]);
heap.pop_back();
}
minheap(heap,1);
}
return res->next;
}
void minheap(vector<ListNode*>& heap,int n)
{
if(n<1)
return;
int left=n<<1;
int right=left+1;
int mid=n;
if(left<heap.size()&&heap[left]->val<heap[mid]->val)
mid=left;
if(right<heap.size()&&heap[right]->val<heap[mid]->val)
mid=right;
if(mid!=n)
{
swap(heap[mid],heap
);
minheap(heap,mid);
}
}
};

The following code uses the heap from STL.

/**
* 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*> minHeap;
ListNode* dummyHead=new ListNode(0);
int size=lists.size();
for(int i=0;i<size;i++)
if(lists[i])
minHeap.push_back(lists[i]);
make_heap(minHeap.begin(),minHeap.end(),cmp);
ListNode* curr=dummyHead;
while(!minHeap.empty())
{
curr->next=new ListNode(minHeap[0]->val);
curr=curr->next;
pop_heap(minHeap.begin(),minHeap.end(),cmp);
minHeap.back()=minHeap.back()->next;
if(minHeap.back())
push_heap(minHeap.begin(),minHeap.end(),cmp);
else
minHeap.pop_back();

}
return dummyHead->next;
}
private:
static bool cmp(const ListNode* a,const ListNode* b)
{
return a->val>b->val;
}
};