23. Merge k Sorted Lists

▶ 合并 k 个已经排好序的单链表

● 代码，28 ms，二路归并递归版，时间复杂度 O(k n log k)

class Solution
{
public:
    ListNode *mergeTwoLists(ListNode* l1, ListNode* l2)
    {
        if (l1 == nullptr)
            return l2;
        if (l2==nullptr)
            return l1;
        if (l1->val <= l2->val)
        {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
        else
        {
            l2->next = mergeTwoLists(l1, l2->next);
            return l2;
        }
    }
    ListNode *mergeKLists(vector<ListNode *> &lists)
    {
        if (lists.empty())
            return nullptr;
        int i, len;
        for (len = lists.size(); len > 1; len = (len + 1) / 2)
        {
            for (i = 0; i < len / 2; i++)
                lists[i] = mergeTwoLists(lists[i], lists[len - 1 - i]);
        }
        return lists.front();
    }
};

● 代码，30 ms，二路归并非递归版，时间复杂度 O(k n log k)

class Solution
{
public:
    ListNode *mergeTwoLists(ListNode* l1, ListNode* l2)
    {
        ListNode  dummy(-1), *result = &dummy;
        for(;l1!=nullptr &&l2!=nullptr;)
        {
            if (l1->val <= l2->val)
            {
                result->next = l1;
                l1 = l1->next;
            }
            else
            {
                result->next = l2;
                l2 = l2->next;
            }
            result = result->next;
        }
        if (l1)
            result->next = l1;
        else if (l2)
            result->next = l2;
        return dummy.next;
    }
    ListNode *mergeKLists(vector<ListNode *> &lists)
    {
        if (lists.empty())
            return NULL;
        int i, len;
        for (len = lists.size(); len > 1; len = (len + 1) / 2)
        {
            for (i = 0; i < len / 2; i++)
                lists[i] = mergeTwoLists(lists[i], lists[len - 1 - i]);            
        }
        return lists.front();
    }
};

● 代码，29 ms，优先队列，最快的解法算法与之相同，时间复杂度 O(N log k)

class Solution
{
public:
    struct compare
    {
        bool operator()(const ListNode* l, const ListNode* r)
        {
            return l->val > r->val;
        }
    };
    ListNode *mergeKLists(vector<ListNode *> &lists)
    {
        priority_queue<ListNode *, vector<ListNode *>, compare> q;
        ListNode *result, *tail;
        for (auto l : lists) // 把各单链表首元素加入优先队中
        {
            if (l)
                q.push(l);
        }
        if (q.empty())
            return NULL;
        result = q.top(), q.pop();  // 取出头部
        if (result->next)           
            q.push(result->next);
        for (tail = result; !q.empty();)
        {
            tail->next = q.top(), q.pop();// 每次取出一个元素，若取出的元素有后继，则将后继加入优先队中
            tail = tail->next;
            if (tail->next)
                q.push(tail->next);
        }
        return result;
    }
};

● 代码，29 ms，使用堆，时间复杂度 O(N log k)

class Solution
{
public:
    static bool heapComp(ListNode* a, ListNode* b)
    {
        return a->val > b->val;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists)
    {
        ListNode head(0);
        ListNode *curNode = &head;
        vector<ListNode*> v;
        for (int i = 0; i<lists.size(); i++)
        {
            if (lists[i])
                v.push_back(lists[i]);
        }
        make_heap(v.begin(), v.end(), heapComp);// 建堆
        for (;v.size()>0;)
        {
            curNode->next = v.front();
            pop_heap(v.begin(), v.end(), heapComp);
            v.pop_back();
            curNode = curNode->next;
            if (curNode->next)
            {
                v.push_back(curNode->next);
                push_heap(v.begin(), v.end(), heapComp);
            }
        }
        return head.next;
    }
};