LeetCode 23 - Merge k Sorted Lists

LeetCode 23 - Merge k Sorted Lists

LeetCode 23 - Merge k Sorted Lists
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

我的解答

这是我在Divide and Conquer分类中找的一道题，因为一眼看去思路很明显，所以我就拿来练手了。

很显然，这应该算是归并排序相关的题目，合并k个排序完的序列。最trivial的方法，是第一个链表和第二个链表合并，结果和第三个链表合并，再和第四个链表和并……如果假设有k个链表，每个链表有m个元素，那么操作数应为$2m+3m+4m+...+km=O(k^2 m)$。而如果考虑用归并排序的做法，也就是分治思想去做，即先让相邻两个链表两两合并，结果中再两两合并……那么考虑每层操作都是km次，一共$\log k$层，也就是说总共是$O(km\log k)$了。

实现的时候，为了递归且减少不必要的内存开销，需要借助一个helper函数。

最后，这道hard题真水啊……

class Solution {
public:
    ListNode* mergeKLists_helper(vector<ListNode*>& lists,int index,int size)
    {
        if(size==0)
        {
            return NULL;
        }
        else if(size==1)
        {
            return lists[index];
        }
        else if(size==2)
        {
            auto i=lists[index],j=lists[index+1];
            ListNode *head=NULL,*tail=NULL;
            if(i==NULL&&j==NULL)
            {

            }
            else if(i==NULL)
            {
                head=j;
                tail=head;
                j=NULL;
            }
            else if(j==NULL)
            {
                head=i;
                tail=head;
                i=NULL;
            }
            else
            {
                if(i->val<=j->val)
                {
                    head=new ListNode(i->val);
                    tail=head;
                    i=i->next;
                }
                else
                {
                    head=new ListNode(j->val);
                    tail=head;
                    j=j->next;
                }
            }

            while(!(i==NULL && j==NULL))
            {
                if(i==NULL)
                {
                    tail->next=j;
                    tail=tail->next;
                    j=NULL;
                }
                else if(j==NULL)
                {
                    tail->next=i;
                    tail=tail->next;
                    i=NULL;
                }
                else
                {
                    if(i->val<=j->val)
                    {
                        tail->next=new ListNode(i->val);
                        tail=tail->next;
                        i=i->next;
                    }
                    else
                    {
                        tail->next=new ListNode(j->val);
                        tail=tail->next;
                        j=j->next;
                    }
                }
            }
            return head;

        }
        else
        {
            auto left=mergeKLists_helper(lists, index, size/2);
            auto right=mergeKLists_helper(lists, index+size/2, size-size/2);
            vector<ListNode*>re={left,right};
            return mergeKLists_helper(re, 0, 2);
        }
    }

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

​
​
​