【Leetcode】【Hard】Merge k Sorted Lists

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

解题思路：

1、先取出k个list的首元素，每个首元素是对应list中的最小元素，组成一个具有k个结点的最小堆；o(k*logk)

2、此时堆顶元素就是所有k个list的最小元素，将其pop出，并用此最小元素所在list上的下一个结点（如果存在）填充堆顶，并执行下滤操作，重新构建堆。o(logk)

3、不断执行第二步，直到堆中元素为0。o(nlogk)

最终时间复杂度为o(nlogk)，k表示list的个数，n表示所有list总结点数；

解题方法1：

使用C++ make_heap，push_heap，pop_heap函数；

步骤：

1、新建一个结点preHead，指向最终返回结果链表的首结点；新建一个curNode指针，用于操作新建链表；

2、将每个list的首指针装入一个新建的vector v中，注意判断list不为空；

3、调用make_heap函数将这些首指针构造成堆；需要编写greater比较函数；

4、循环操作，只要v不为空：

　　（1）取出堆顶，放入新建链表的末端；

　　（2）pop_heap，交换当前堆首尾元素，并下滤首元素；

　　（3）pop_back，删除v最后一个元素（当前最小元素）；

　　（4）push_back，将当前最小元素的下一个元素加入堆尾；

　　（5）push_heap，对堆尾元素进行上滤；

5、返回preHead->next；

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) { //make_heap
        ListNode prehead(0);
        ListNode *curNode = &prehead;
        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 prehead.next;
    }
    
    static bool heapComp(ListNode* a, ListNode* b) {
            return a->val > b->val;
    }
};

解题方法2：

使用C++ priority_queue 构建最小堆；

步骤和上述基本一致；

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    struct cmp {
        bool operator()(const ListNode *n1, const ListNode *n2) {
            return n1->val > n2->val;
        }
    };

    ListNode *mergeKLists(vector<ListNode *> &lists) {
        priority_queue<ListNode*, vector<ListNode *>, cmp > heap;
        ListNode pre_head(0);
        ListNode *curNode = &pre_head;
        for (int i = 0; i < lists.size(); i++) {
            if (lists[i]) 
                heap.push(lists[i]);
        }
                
        while (!heap.empty()){
            curNode->next = heap.top();
            heap.pop();
            curNode = curNode->next;
            if (curNode->next) 
                heap.push(curNode->next);
        }
        
        return pre_head.next;
    }
};