106：Merge k Sorted Lists

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

解析1：反复调用 merge two sorted lists 函数，假设每条链平均长度为 n，则时间复杂度为 O(2n + 3n + … + kn) = O(nk^2)，代码如下：

class Solution {public:        ListNode* mergeKLists(vector<ListNode*>& lists) {                if (lists.size() == 0) return nullptr;                ListNode* p = lists[0];                for (int i = 1; i < lists.size(); ++i)                        p = mergeTwoLists(p, lists[i]);                return p;        }private:        ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {                ListNode dummy{-1};                dummy.next = l1;                ListNode* p = &dummy;                while (l1 && l2) {                        if (l1 -> val < l2 -> val) {                                p -> next = l1;                                l1 = l1 -> next;                        }                        else {                                p -> next = l2;                                l2 = l2 -> next;                        }                        p = p -> next;                }                if (l1) p -> next = l1;                else if (l2) p -> next = l2;                return dummy.next;        }};

解析2：建立一个大小为 k 的小根堆，建堆时间复杂度为 O(k/2 * logk)，每次取出堆元素以及插入堆元素的时间复杂度为 O(logk)。假设每条链平均长度为 n，则由于共要从堆中取出 nk 次元素，因此时间复杂度为 O(nklogk)，代码如下：

class Solution {public:        ListNode* mergeKLists(vector<ListNode*>& lists) {                if (lists.size() == 0) return nullptr;                ListNode dummy{-1};                ListNode* p = &dummy;                vector<ListNode*> heap;                for (int i = 0; i < lists.size(); ++i)                        if (lists[i]) head.push_back(lists[i]);                make_heap(heap.begin(), heap.end(), greater());                while (!heap.empty()) {                        pop_heap(heap.begin(), heap.end(), greater());                        ListNode* tmp = heap.back();                        heap.pop_back();                        if (tmp -> next) {                                heap.push_back(tmp -> next);                                push_heap(heap.begin(), heap.end(), greater());                        }                        p -> next = tmp;                        p = p -> next;                }                return dummy.next;        }private:        struct greater {                bool operator()(ListNode* l1, ListNode* l2) {                        return l2 -> val < l1 -> val;                }        };};