LeetCode: Merge k Sorted Lists

ListNode *mergeKLists(vector<ListNode *>&lists) {
    int n = (int) lists.size();
    if (n == 0) return NULL;
    
    ListNode *p = new ListNode(0);
    ListNode *q = p;
    int empty = 0;
    int k;
    while (empty < n) {
        k = -1;
        int i;
        for (i = 0; i < n; ++i) {
            if (lists[i]) {
                k = i;
                break;
            }
        }
        for (int j = i + 1; j < n; ++j) {
            if (lists[j] && (lists[j]->val) < (lists[i]->val)) {
                k = j;
            }
        }
        
        if (k == -1) break;
        
        q->next = lists[k];
        q  = q->next;
        lists[k] = lists[k]->next;
        
        if (!q->next) ++empty;
    }
    
    q = p->next;
    delete p;
    return q;
    
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    class MergeCompareFunc {
        public:
            typedef ListNode * ListNodeP;
            bool operator() (const ListNodeP & a, const ListNodeP & b) const {return (a->val > b->val);}
        };
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
          if (lists.size() < 1) {
            return NULL;
        }
        
        priority_queue<ListNode*, vector<ListNode *>, MergeCompareFunc> pqueue;
        for (ListNode *node : lists) {
            if (node != NULL) {
                pqueue.push(node);
            }
        }
        ListNode *p = new ListNode(0);
        ListNode *q = p;
        while (pqueue.size() > 0) {
            ListNode *n = pqueue.top();
            pqueue.pop();
            q->next = n;
            q = q->next;
            if (n->next) pqueue.push(n->next);
        }
        
        q = p->next;
        delete  p;
        return q;
    }
};