【Leetcode】【Hard】Merge k Sorted Lists

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

 

解题思路：

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

二、此时堆顶元素就是全部k个list的最小元素，将其pop出，并用此最小元素所在list上的下一个结点（若是存在）填充堆顶，并执行下滤操做，从新构建堆。o(logk)

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

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

 

解题方法1：

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

步骤：

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

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

三、调用make_heap函数将这些首指针构形成堆；须要编写greater比较函数；

四、循环操做，只要v不为空：

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

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

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

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

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

五、返回preHead->next；

 

代码：

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 class Solution {
10 public:
11     ListNode* mergeKLists(vector<ListNode*>& lists) { //make_heap
12         ListNode prehead(0);
13         ListNode *curNode = &prehead;
14         vector<ListNode*> v;   
15         for(int i = 0; i < lists.size(); i++){
16             if (lists[i])
17                 v.push_back(lists[i]);
18         }
19         make_heap(v.begin(), v.end(), heapComp); //vector -> heap data strcture
20     
21         while(v.size() > 0){
22             curNode->next = v.front();
23             pop_heap(v.begin(), v.end(), heapComp); 
24             v.pop_back(); 
25             curNode = curNode->next;
26             if(curNode->next) {
27                 v.push_back(curNode->next); 
28                 push_heap(v.begin(), v.end(), heapComp);
29             }
30         }
31         
32         return prehead.next;
33     }
34     
35     static bool heapComp(ListNode* a, ListNode* b) {
36             return a->val > b->val;
37     }
38 };

 

解题方法2：

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

步骤和上述基本一致；

代码

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 class Solution {
10 public:
11     struct cmp {
12         bool operator()(const ListNode *n1, const ListNode *n2) {
13             return n1->val > n2->val;
14         }
15     };
16 
17     ListNode *mergeKLists(vector<ListNode *> &lists) {
18         priority_queue<ListNode*, vector<ListNode *>, cmp > heap;
19         ListNode pre_head(0);
20         ListNode *curNode = &pre_head;
21         for (int i = 0; i < lists.size(); i++) {
22             if (lists[i]) 
23                 heap.push(lists[i]);
24         }
25                 
26         while (!heap.empty()){
27             curNode->next = heap.top();
28             heap.pop();
29             curNode = curNode->next;
30             if (curNode->next) 
31                 heap.push(curNode->next);
32         }
33         
34         return pre_head.next;
35     }
36 };