Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
Example:
Input: [ 1->4->5, 1->3->4, 2->6 ] Output: 1->1->2->3->4->4->5->6
這道題讓我們合併k個有序連結串列，最終合併出來的結果也必須是有序的，之前我們做過一道 Merge Two Sorted Lists，是混合插入兩個有序連結串列。這道題增加了難度，變成合並k個有序連結串列了，但是不管合併幾個，基本還是要兩兩合併。那麼我們首先考慮的方法是能不能利用之前那道題的解法來解答此題。答案是肯定的，但是需要修改，怎麼修改呢，最先想到的就是兩兩合併，就是前兩個先合併，合併好了再跟第三個，然後第四個直到第k個。這樣的思路是對的，但是效率不高，沒法通過OJ，所以我們只能換一種思路，這裡就需要用到分治法 Divide and Conquer Approach。簡單來說就是不停的對半劃分，比如k個連結串列先劃分為合併兩個k/2個連結串列的任務，再不停的往下劃分，直到劃分成只有一個或兩個連結串列的任務，開始合併。舉個例子來說比如合併6個連結串列，那麼按照分治法，我們首先分別合併0和3，1和4，2和5。這樣下一次只需合併3個連結串列，我們再合併1和3，最後和2合併就可以了。程式碼中的k是通過 (n+1)/2 計算的，這裡為啥要加1呢，這是為了當n為奇數的時候，k能始終從後半段開始，比如當n=5時，那麼此時k=3，則0和3合併，1和4合併，最中間的2空出來。當n是偶數的時候，加1也不會有影響，比如當n=4時，此時k=2，那麼0和2合併，1和3合併，完美解決問題，參見程式碼如下：
解法一：
class Solution { public: ListNode* mergeKLists(vector<ListNode*>& lists) { if (lists.empty()) return NULL; int n = lists.size(); while (n > 1) { int k = (n + 1) / 2; for (int i = 0; i < n / 2; ++i) { lists[i] = mergeTwoLists(lists[i], lists[i + k]); } n = k; } return lists[0]; } ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode *dummy = new ListNode(-1), *cur = dummy; while (l1 && l2) { if (l1->val < l2->val) { cur->next = l1; l1 = l1->next; } else { cur->next = l2; l2 = l2->next; } cur = cur->next; } if (l1) cur->next = l1; if (l2) cur->next = l2; return dummy->next; } };
我們再來看另一種解法，這種解法利用了最小堆這種資料結構，我們首先把k個連結串列的首元素都加入最小堆中，它們會自動排好序。然後我們每次取出最小的那個元素加入我們最終結果的連結串列中，然後把取出元素的下一個元素再加入堆中，下次仍從堆中取出最小的元素做相同的操作，以此類推，直到堆中沒有元素了，此時k個連結串列也合併為了一個連結串列，返回首節點即可，程式碼如下：
解法二：
class Solution { public: ListNode* mergeKLists(vector<ListNode*>& lists) { auto cmp = [](ListNode*& a, ListNode*& b) { return a->val > b->val; }; priority_queue<ListNode*, vector<ListNode*>, decltype(cmp) > q(cmp); for (auto node : lists) { if (node) q.push(node); } ListNode *dummy = new ListNode(-1), *cur = dummy; while (!q.empty()) { auto t = q.top(); q.pop(); cur->next = t; cur = cur->next; if (cur->next) q.push(cur->next); } return dummy->next; } };
下面這種解法利用到了混合排序的思想，也屬於分治法的一種，做法是將原連結串列分成兩段，然後對每段呼叫遞迴函式，suppose返回的left和right已經合併好了，然後再對left和right進行合併，合併的方法就使用之前那道 Merge Two Sorted Lists 中的任意一個解法即可，這裡我們使用了遞迴的寫法，而本題解法一中用的是迭代的寫法，參見程式碼如下：
解法三：
class Solution { public: ListNode* mergeKLists(vector<ListNode*>& lists) { return helper(lists, 0, (int)lists.size() - 1); } ListNode* helper(vector<ListNode*>& lists, int start, int end) { if (start > end) return NULL; if (start == end) return lists[start]; int mid = start + (end - start) / 2; ListNode *left = helper(lists, start, mid); ListNode *right = helper(lists, mid + 1, end); return mergeTwoLists(left, right); } ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if (!l1) return l2; if (!l2) return l1; if (l1->val < l2->val) { l1->next = mergeTwoLists(l1->next, l2); return l1; } else { l2->next = mergeTwoLists(l1, l2->next); return l2; } } };
下面這種解法利用到了計數排序的思想，由留言區二樓熱心網友閩A2436提供，思路是將所有的結點值出現的最大值和最小值都記錄下來，然後記錄每個結點值出現的次數，這樣我們從最小值遍歷到最大值的時候，就會按順序經過所有的結點值，根據其出現的次數，建立相對應個數的結點。但是這種解法有個特別需要注意的地方，那就是合併後的連結串列結點都是重新建立的，若在某些情況下，我們不能新建結點，而只能交換或者重新連結結點的話，那麼此解法就不能使用，但好在本題並沒有這種限制，可以完美過OJ，參見程式碼如下：
解法四：
class Solution { public: ListNode* mergeKLists(vector<ListNode*>& lists) { ListNode *dummy = new ListNode(-1), *cur = dummy; unordered_map<int, int> m; int mx = INT_MIN, mn = INT_MAX; for (auto node : lists) { ListNode *t = node; while (t) { mx = max(mx, t->val); mn = min(mn, t->val); ++m[t->val]; t = t->next; } } for (int i = mn; i <= mx; ++i) { if (!m.count(i)) continue; for (int j = 0; j < m[i]; ++j) { cur->next = new ListNode(i); cur = cur->next; } } return dummy->next; } };
類似題目：
參考資料：
https://leetcode.com/problems/merge-k-sorted-lists/
https://leetcode.com/problems/merge-k-sorted-lists/discuss/10640/Simple-Java-Merge-Sort