【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 };