Merge k Sorted Lists

一. Merge k Sorted Lists

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

Difficulty:Hard

TIME：16MIN

解法一

我们都知道合并两个有序的列表，时间复杂度为$O(n)$，但如果是合并k个列表呢？最简单的做法当然是每次从k个列表中找到符合要求的元素，然后加入新的列表中。

ListNode* mergeKLists(vector<ListNode*>& lists) {
    ListNode *head = NULL;
    ListNode *p = NULL;
    bool loo = true;
    while(loo) {
        loo = false;
        ListNode *tmp;
        int val = INT32_MAX;
        int index;
        for(int i = 0; i < lists.size(); i++) {
            if(lists[i] != NULL && lists[i]->val <= val) {
                val = lists[i]->val;
                tmp = lists[i];
                index = i;
                loo = true;
            }
        }
        if(!loo)
            break;
        if(head == NULL)
            head = tmp;
        if(p != NULL)
            p->next = tmp;
        p = tmp;
        lists[index] = lists[index]->next;
    }
    return head;
}

代码的时间复杂度为$O(kn)$，其中$k$为要合并的列表个数。

解法二

其实在做的过程中就发现，根本就不需要每次遍历k个列表寻找符合要求的元素，其实只需要第一次遍历k个列表就行了，之后只需要遍历一次列表，就可以获取符合要求的元素，不过需要最小优先队列。

时间复杂度为$O(nlogk)$。

解法三

合并列表，可能就会想到归并排序，如果合并k个列表，那么采用归并的方法，其实也只需要操作$logk$次而已，因此时间复杂度是和采用最小优先队列是一样的。

ListNode* merge(ListNode *a,ListNode *b) { //合并两个列表
    ListNode *head = NULL;
    ListNode *p = NULL;
    while(a != NULL || b != NULL) {
        ListNode *tmp = NULL;
        if(b != NULL && (a == NULL || a->val >= b->val)) {
            tmp = b;
            b = b->next;
        }
        else {
            tmp = a;
            a = a->next;
        }
        if(head == NULL)
            head = tmp;
        if(p != NULL)
            p->next = tmp;
        p = tmp;
    }
    return head;
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
    lists.push_back(NULL);
    deque<ListNode*> que(lists.begin(), lists.end()); //这里采用双端队列
    while(que.size() > 1) {
        que.push_back(merge(que[0],que[1]));
        que.pop_front();
        que.pop_front();
    }
    return que[0];
}

时间复杂度为$O(nlogk)$。