【面试系列】合并K个升序链表

题意：

思路：
1、$O(nm)$枚举，$n$为总结点数，$m$为链表数
2、优先队列先将$m$个首元素加入，然后每次取最小的，再添加进去其下一个，时间复杂度：$O(n\log m)$

代码：
1、

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
    
    
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
    
    
        ListNode *dummy = new ListNode(-1);
        ListNode *tmp = dummy;

        while(true) {
    
    
            bool f = false;
            int idx = 0;
            for(int i = 0; i < lists.size(); ++i) {
    
    
                if(lists[i] == NULL) continue;
                if(!f || lists[i]->val < lists[idx]->val) {
    
    
                    f = true;
                    idx = i;
                }
            }
            if(!f) break;
            
            tmp->next = lists[idx];
            tmp = tmp->next;
            lists[idx] = lists[idx]->next;

        } tmp->next = NULL;
        
        return dummy->next;
    }
};

2、

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
    
    
public:
    
    struct Node {
    
    
        int val;
        ListNode* list;
        bool operator < (const Node &A) const {
    
    
            return val > A.val;
        }
    };
    
    ListNode* mergeKLists(vector<ListNode*>& lists) {
    
    
        priority_queue<Node> q;
        for(auto &u : lists) 
            if(u != NULL) q.push({
    
    u->val, u});

        ListNode* dummy = new ListNode(-1);
        ListNode* tmp = dummy;
        while(!q.empty()) {
    
    
            Node t = q.top(); q.pop();
            tmp->next = t.list;
            tmp = tmp->next;
            
            if(t.list->next != NULL) 
                q.push({
    
    (t.list)->next->val, (t.list)->next});
            
        } tmp->next = NULL;
        return dummy->next;
    }
};