Leetcode OJ : Merge k Sorted Lists 归并排序+最小堆 mergesort heap C++ solution

 /**
  * Definition for singly-linked list.
  * struct ListNode {
  *     int val;
  *     ListNode *next;
  *     ListNode(int x) : val(x), next(NULL) {}
  * };
  */

 struct helper {
     ListNode *head;
     int len;
     helper(ListNode *h, int l) : head ( h ), len ( l ) {}
 };

 class helpercmp {
 public:
     bool operator() (const helper &a, const helper &b) {
         return a.len > b.len;
     }
 };

 class Solution {
 public:
     priority_queue<helper, vector<helper>, helpercmp> heap; 

     inline int listSize(ListNode *head) {
         int len = ;
         for ( ; head != nullptr; head = head->next, len++ );
         return len;
     }
     ListNode *mergeKLists(vector<ListNode *> &lists) {
         if ( lists.empty() ) return nullptr;
         if ( lists.size() ==  ) return lists[];
         ListNode *head = nullptr, *left = nullptr,  *right = nullptr;
         for ( auto list : lists ) {
             heap.push( helper(list, listSize(list) )  );
         }
         while ( heap.size() !=  ) {
             left = heap.top().head;
             heap.pop();
             right = heap.top().head;
             heap.pop();
             head = mergeList( left, right );
             heap.push( helper( head, listSize(head) ) );
         }
         return heap.top().head;
     }
     ListNode *mergeList(ListNode *a, ListNode *b) {
         ListNode dummy();
         ListNode *tail = &dummy;
         while ( a != nullptr && b != nullptr ) {
             if ( a-> val <= b->val ) {
                 tail->next = a;
                 a = a->next;
             } else {
                 tail->next = b;
                 b = b->next;
             }
             tail = tail->next;
         }
         tail->next =  a == nullptr ? b : a;
         return dummy.next;
     }
 };