Merge k Sorted Lists

Date:

　　Nov, 7, 2017.

Problem:

　　https://leetcode.com/problems/merge-k-sorted-lists/discuss/

Description:

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

　　考虑暴力解法，写一个MergeTwoSortedLists对输入链表依次归并。

class Solution:
    def mergeKLists(self, lists):
        if len(lists) == 0:
            return None
        while len(lists) > 1:
            lists.append(self.mergeTwoLists(lists[0], lists[1]))
            lists.pop(0)
            lists.pop(0)
        return lists[0]
    def mergeTwoLists(self, list1, list2):
        if list1 == None:
            return list2
        if list2 == None:
            return list1
        if list1.val <= list2.val:
            list1.next = self.mergeTwoLists(list1.next, list2)
            return list1
        if list1.val > list2.val:
            list2.next = self.mergeTwoLists(list1, list2.next)
            return list2

　　提交，超过递归深度。

　　第一次见到这种错误类型……

　　那就写一个优先队列吧。

class Solution {
public:
    struct compare {
        bool operator()(const ListNode* l, const ListNode* r) {
            return l->val > r->val;
        }
    };
    ListNode *mergeKLists(vector<ListNode *> &lists) { 
        priority_queue<ListNode *, vector<ListNode *>, compare> q;
        for (auto i : lists)
            if (i)
                q.push(i);
        if (q.empty())
            return NULL;
        ListNode* result = q.top();
        q.pop();
        if (result->next)
            q.push(result->next);
        ListNode* p = result;            
        while (!q.empty()) {
            p->next = q.top();
            q.pop();
            p = p->next;
            if(p->next)
                q.push(p->next);
        }
        return result;
    }
};

　　AC。时间复杂度为O(Nlog(N))。

　　mingjun的堆写法，效率与优先队列相似。

static bool heapComp(ListNode* a, ListNode* b) {
        return a->val > b->val;
}
ListNode* mergeKLists(vector<ListNode*>& lists) { //make_heap
    ListNode head(0);
    ListNode *curNode = &head;
    vector<ListNode*> v;   
    for(int i =0; i<lists.size(); i++){
        if(lists[i]) v.push_back(lists[i]);
    }
    make_heap(v.begin(), v.end(), heapComp); //vector -> heap data strcture

    while(v.size()>0){
        curNode->next=v.front();
        pop_heap(v.begin(), v.end(), heapComp); 
        v.pop_back(); 
        curNode = curNode->next;
        if(curNode->next) {
            v.push_back(curNode->next); 
            push_heap(v.begin(), v.end(), heapComp);
        }
    }
    return head.next;
}