Merge k Sorted Lists leetcode

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

Hide Tags

 Divide and Conquer Linked List Heap

Hide Similar Problems

 (E) Merge Two Sorted Lists (M) Ugly Number II

 

题目意思就是合并多个有序链表！采用分治递归！

第一种思路分析：分而治之，不断划分，直到变成两个有序链表合并的子问题！归并的动态图如右图所示：

 

本题建立在合并两个有序链表算法的基础之上，不断合并两个有序子链表，直到整个子链表合而为一。这道题目在分布式系统中非常常见，来自不同client的sorted list要在central server上面merge起来。

我们来分析一下上述算法的时间复杂度。假设总共有k个list，每个list的最大长度是n，那么运行时间满足递推式T(k) = 2T(k/2)+O(n*k)。根据主定理，可以算出算法的总复杂度是O(nklogk)。如果不了解主定理的朋友，可以参见 主定理-维基百科 。空间复杂度的话是递归栈的大小O(logk)。 

代码实现如下：

#include<iostream>
#include<vector>
using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
        if (lists.size() == 0)
            return NULL;
        if (lists.size() == 1)
            return lists[0];
        //vector<ListNode*> res;
        while (lists.size()!=1)
        {
            ListNode*temp= mergeTwoLists(lists[0], lists[1]);
            lists.push_back(temp);
            lists.erase(lists.begin());
            lists.erase(lists.begin());
        }
        return lists[0];

    }
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
    {
        if (!l1)
            return l2;
        if (!l2)
            return l1;
        ListNode n1(-1);
        n1.next = l1;
        ListNode *ptr1 = l1, *pre1, *ptr2 = l2, *b2;
        pre1 = &n1;
        while (ptr2)
        {
            b2 = ptr2->next;
            if (ptr1->val < ptr2->val)
            {
                ptr1 = ptr1->next;
                pre1 = pre1->next;///
                if (ptr1 == NULL)//这儿必须让其终止！否则运行会出错的
                    break;
            }
            else
            {
                pre1->next = ptr2;
                ptr2->next = ptr1;
                ptr2 = b2;
                pre1 = pre1->next;///
            }
        }
        if (ptr2 != NULL)
            pre1->next = ptr2;
        return n1.next;
    }
};

int main()
{
    Solution test;

    vector<ListNode*> val;
    ListNode *n1 = NULL;
    ListNode n2(-1),n3(5),n4(11);
    n2.next = &n3;
    n3.next = &n4;
    ListNode *n5 = NULL;
    ListNode n6(6), n7(10);
    n6.next = &n7;
    val.push_back(n1);
    val.push_back(&n2);
    val.push_back(n5);
    val.push_back(&n6);
    //cout << "the size of val:" << val.size() << " " << val.capacity() << endl;
    ListNode* result = test.mergeKLists(val);
    while (result)
    {
        cout << result->val << " ";
        result = result->next;
    }
    return 0;
}

第二种思路分析（用到了堆这种数据结构）：思路比较难想到，但是其实原理比较简单。维护一个大小为k的堆，每次取堆顶的最小元素放到结果中，然后读取该元素的下一个元素放入堆中，重新维护好。因为每个链表是有序的，每次又是去当前k个元素中最小的，所以当所有链表都读完时结束，这个时候所有元素按从小到大放在结果链表中。这个算法每个元素要读取一次，即是k*n次，然后每次读取元素要把新元素插入堆中要logk的复杂度，所以总时间复杂度是O(nklogk)。空间复杂度是堆的大小，即为O(k)。