LeetCode 23.Merge K Sorted Lists 合并K个排序链表

题目描述

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists

思路

1. 合并 K 个排序链表** 与 合并两个有序链表 的区别点在于操作有序链表的数量上，因此完全可以按照上面的代码思路来实现合并 K 个排序链表。这里可以参考 **归并排序 **的分治思想，将这 K 个链表先划分为两个 K/2 个链表，处理它们的合并，然后不停的往下划分，直到划分成只有一个或两个链表的任务，开始合并。

2. 使用堆的思想： 这里需要将这 k 个排序链表整合成一个排序链表，也就是说有多个输入，一个输出，类似于漏斗一样的概念。

   因此，可以利用最小堆的概念。如果你对堆的概念不熟悉，可以戳这先了解一下~

   取每个 Linked List 的最小节点放入一个 heap 中，排序成最小堆。然后取出堆顶最小的元素，放入输出的合并 List 中，然后将该节点在其对应的 List 中的下一个节点插入到 heap 中，循环上面步骤，以此类推直到全部节点都经过 heap。

   由于 heap 的大小为始终为 k ，而每次插入的复杂度是 logk ，一共插入了 nk 个节点。时间复杂度为 O(nklogk)，空间复杂度为O(k)。

   动画演示

   

c++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
// 逐一两两合并链表
// 时间复杂度为O(N1+N2+...N3)
// 空间复杂度为O(1)
class Solution {
public:
    ListNode* mergeKLists(vector& lists) {
        if(lists.size() == 0) return nullptr;
        ListNode *p = lists[0];
        for(int i = 1; i < lists.size(); i ++){
            p = mergeTwoLists(p, lists[i]);
        }
        return p;
    }

    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2){
        ListNode head(-1); //定义一个假的结点
        for(ListNode* p = &head; l1 != nullptr || l2 != nullptr; p = p->next){
            int val1 = l1 == nullptr ? INT_MAX : l1->val;
            int val2 = l2 == nullptr ? INT_MAX : l2->val;
            if(val1 <= val2){
                p->next = l1;
                l1 = l1->next;
            }else{
                p->next = l2;
                l2 = l2->next;
            }
        }
        return head.next;
    }
};

// 最小堆的思想
// 时间复杂度为 O(Nklogk) 每次插入的复杂度是 logk ，一共插入了 Nk 个节点 (k个链表 N为总结点个数)
// 空间复杂度为O(k)
class Solution {
public:
    struct cmp{
        bool operator()(ListNode*a,ListNode*b){
            return a->val > b->val;
        }
    };
    ListNode* mergeKLists(vector& lists) {
        priority_queue,cmp> heap;
        ListNode Vhead(0),*p = &Vhead; 
        for(ListNode *node :lists){
            if(node!=NULL)heap.push(node);
        }
        while(!heap.empty()){
            ListNode * tmp = heap.top();
            heap.pop();
            if(tmp->next!=NULL)heap.push(tmp->next);
            p->next = tmp;
            p = tmp;
        }
        return Vhead.next;
    }
};

// 分治思想
// 时间复杂度为 O(Nlogk)
// 空间复杂度为O(1)
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == NULL) return l2;
        if (l2 == NULL) return l1;
        ListNode* pre = new ListNode(0);
        ListNode* cur = pre;
        while (l1 != NULL && l2 != NULL) {
            if (l1->val <= l2->val) {
                cur->next = l1;
                l1 = l1->next;
            } else {
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }

        cur->next = l1 != NULL ? l1 : l2;

        return pre->next;
    }

    ListNode* mergeKLists(vector& lists) {
        int len = lists.size();
        if (len == 0) return NULL;
        // 分组间隔每次扩大两倍
        int interval = 1;
        while (interval < len) {
            // 根据当前间隔，两两合并，合并后的结果保存在两个链表的第一个
            for (int i = 0; i < len - interval; i += 2 * interval) {
                lists[i]  = mergeTwoLists(lists[i], lists[i + interval]);
            }
            interval *= 2;
        }
        return lists[0];
    }
};