[Leetcode] Merge k Sorted Lists

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

no comment.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getNext(vector<ListNode *> &lists) {
        ListNode *next = NULL;
        int min = INT_MAX;
        int idx = 0;
        for (int i = 0; i < lists.size(); ++i) {
            if (lists[i] != NULL && lists[i]->val < min) {
                min = lists[i]->val;
                idx = i;
                next = lists[i];
            }
        }
        if (lists[idx] != NULL) lists[idx] = lists[idx]->next;
        return next;
    }
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        if (lists.size() < 1) return NULL;
        ListNode *res = new ListNode(-1);
        ListNode *pos = res;
        while(pos != NULL) {
            pos->next = getNext(lists);
            pos = pos->next;
        }
        return res->next;
    }
};

 现在LeetCode更新的测试样例，上面的算法会超时。可以使用一个堆来优化。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
struct cmp {
    bool operator () (ListNode* a, ListNode* b) {
        return a->val > b->val;
    }
};

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode dummy(0);
        ListNode *p = &dummy;
        priority_queue<ListNode*, vector<ListNode*>, cmp> heap;
        for (auto &list : lists) {
            if (list) heap.push(list);
        }
        for ( ; !heap.empty(); heap.pop()) {
            auto u = heap.top();
            p->next = u;
            p = p->next;
            if (u->next) heap.push(u->next);
        }
        return dummy.next;
    }
};