LeetCode

Merge k Sorted Lists

2013.12.7 01:32

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

Solution:

　　You must've done the job of merging two sorted linked lists quite often, this time it's k lists. The simple way is to find the smallest of all k head nodes, pick it out and put into the result list, then move the corresponding node forward by 1 step. Do this until all k lists are empty.

　　In that case, the time complexity would be O(n * k), where $n is the total number of nodes in k lists. Every time we use linear search through k nodes to find the minimum, that's where the problem lies.

　　With minimal heap we can achieve O(n * log(k)) time, with O(k) extra space complexity. But note that you cannot put a pointer into the priority_queue STL, so might as well use some trick to deal with this trivial matter, e.g. a wrapper struct or class will do.

Accepted code:

// 9CE, 1WA, 1AC, pointer can't be elements of priority_queue, might as well wrap it with a class.
// Seem so silly...
#include <queue>
using namespace std;
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class ListNodeSt{
public:
    ListNode *ptr;
    
    ListNodeSt(ListNode *_ptr = nullptr){
        ptr = _ptr;
    }
};

bool operator < (const ListNodeSt a, const ListNodeSt b) {
    return a.ptr->val > b.ptr->val;
}

class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int k;
        ListNode *root, *par, *tmp;
        ListNodeSt st;
        
        while(!pq.empty()){
            pq.pop();
        }
        k = lists.size();
        if(k <= 0){
            return nullptr;
        }
        
        
        int i;
        for(i = 0; i < k; ++i){
            if(lists[i] != nullptr){
                pq.push(ListNodeSt(lists[i]));
            }
        }
        root = nullptr;
        par = root;
        while(!pq.empty()){
            st = pq.top();
            tmp = st.ptr;
            pq.pop();
            if(par == nullptr){
                par = tmp;
                root = par;
            }else{
                par->next = tmp;
            }
            if(tmp->next != nullptr){
                pq.push(ListNodeSt(tmp->next));
            }
            tmp->next = nullptr;
            par = tmp;
        }
        
        return root;
    }
private:
    priority_queue<ListNodeSt> pq;
};