LeetCode系列23—合并K个升序链表

题意

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

题解

前置知识：合并两个有序链表，代码如下，时间复杂度$O(n)$，空间复杂度为$O(1)$

ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
    if ((!a) || (!b)) return a ? a : b;
    ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
    while (aPtr && bPtr) {
        if (aPtr->val < bPtr->val) {
            tail->next = aPtr; aPtr = aPtr->next;
        } else {
            tail->next = bPtr; bPtr = bPtr->next;
        }
        tail = tail->next;
    }
    tail->next = (aPtr ? aPtr : bPtr);
    return head.next;
}

这道题有很多解法，我们来看看吧，假设有 k 个链表，每个链表的长度为 n

方法一：暴力求解

遍历所有链表，将所有值存入到一个数组中，对数组进行快速排序，然后通过数组构造链表

时间复杂度为$O(knlog(kn))$，空间复杂度为$O(n)$

方法二：逐步比较

与合并两个有序链表类似，每一步比较 k 个链表的首元素，将最小的添加到新构造的链表中

时间复杂度为$O(k^{2}n)$，空间复杂度为$O(n)$

方法三：优先队列

遍历所有链表，将所有值存入优先队列中，然后依次取出构造链表

时间复杂度为$O(kn\times logk)$，空间复杂度为$O(n)$，代码如下：

class Solution {
public:
    struct Status {
        int val;
        ListNode *ptr;
        bool operator < (const Status &rhs) const {
            return val > rhs.val;
        }
    };

    priority_queue <Status> q;

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        for (auto node: lists) {
            if (node) q.push({node->val, node});
        }
        ListNode head, *tail = &head;
        while (!q.empty()) {
            auto f = q.top(); q.pop();
            tail->next = f.ptr; 
            tail = tail->next;
            if (f.ptr->next) q.push({f.ptr->next->val, f.ptr->next});
        }
        return head.next;
    }
};

方法四：顺序合并

第一个链表和第二个链表合并，然后用合并的结果与接下来的链表合并

时间复杂度为$O(k^{2}n)$，空间复杂度为$O(1)$，代码如下：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *ans = nullptr;
        for (size_t i = 0; i < lists.size(); ++i) {
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }
};

方法五：分治合并

此题的最佳解法，将 k 个链表配对并将同一对中的链表合并， 第一轮合并后，k 个链表被合并成 k / 2个，下一轮被合并成 k / 4 个，依此类推，直到得到最终的有序链表

时间复杂度为$O(kn\times logk)$，空间复杂度为$O(logk)$，代码如下：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* merge(vector <ListNode*> &lists, int l, int r) {
        if (l == r) return lists[l];
        if (l > r) return nullptr;
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }
};