Leetcode | Merge k Sorted Lists

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

想法很简单，就是两两合并。在Merge Two Sorted Lists这道题已经实现了两两合并的代码了，就直接拿过来用。

假设每条链平均长度为n，如果用二分法的话， 也就是将所有的链分成两份，每份各自合并完之后再合并起来。递归的空间复杂度会是O(logk)， 时间复杂度T(k)=2T(k/2) +O(nk)，由主定理得O(nklgk)。

主定理见wiki。

下面是两两合并的代码，时间复杂度是$O(2n+3n+ldots+kn)=O(k^2n)$.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        if (lists.empty()) return NULL;
        ListNode* head = lists[0];
        for (int i = 1; i < lists.size(); ++i) {
            head = mergeTwoLists(head, lists[i]);
        }
        
        return head;
    }
    
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        ListNode *head, *t3;
        head = t3 = new ListNode(0);
        while (l1 != NULL && l2 != NULL) {
            if (l1->val <= l2->val) {
                t3->next = l1;
                l1 = l1->next;
            } else {
                t3->next = l2;
                l2 = l2->next;
            }
            t3 = t3->next;
        }
        
        while (l1 != NULL) {
            t3->next = l1;
            t3= t3->next;
            l1 = l1->next;
        }
        while (l2 != NULL) {
            t3->next = l2;
            t3 = t3->next;
            l2 = l2->next;
        }
        
        ListNode *ret = head->next;
        delete head;
        return ret;
    }
};

 下面是二分的实现。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        ListNode h(0), *p = &h;
        while (l1 || l2) {
            if (l1 == NULL || (l2 != NULL && l2->val < l1->val)) {
                p->next = l2;
                l2 = l2->next;
            } else {
                p->next = l1;
                l1 = l1->next;
            }
            p = p->next;
        }
        return h.next;
    }
    ListNode *mergeKLists(vector<ListNode *> &lists) {
            if (lists.empty()) return NULL;
            
            vector<vector<ListNode *> > layers(2);
            int cur = 0, next = 1;
            layers[cur] = lists;
            while (layers[cur].size() > 1) {
                layers[next].clear();
                for (int i = 0; i < layers[cur].size(); i += 2) {
                    if (i + 1 < layers[cur].size()) layers[next].push_back(mergeTwoLists(layers[cur][i], layers[cur][i + 1]));
                    else layers[next].push_back(layers[cur].back());
                }
                cur = !cur; next = !next;
            }
            return layers[cur][0];
    }
};

非递归的空间复杂度可以优化到O(k)。