LeetCode 23合并K个排序列表

LeetCode 23合并K个排序列表

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

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

• 思路一：使用优先队列，先将每个排序链表的头节点加入优先队列，每次将堆顶元素弹出加入新链表，并将堆顶后驱节点加入优先队列，循环直到优先队列为空

  空间复杂度 O(k)，时间复杂度 O(nlog(k))；n是所有节点个数，k是链表数

class Solution {
public:
    struct cmp{
        bool operator()(ListNode *a,ListNode *b){
            return a->val > b->val;
        }
    };

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, cmp> q;
        for (auto node : lists) 
            if(node) q.push(node);//将每个链表头节点加入优先队列

        ListNode *dummy = new ListNode(-1);
        auto cur = dummy;
        while(!q.empty())
        {
            auto t = q.top();
            q.pop();
            cur->next = t;
            cur = cur->next;
            if(cur->next) q.push(cur->next);//将堆顶元素的后驱节点加入优先队列
        }
        return dummy->next;
    }
};

• 思路二：从头开始两两链表合并。时间复杂度 O(kn) ，空间复杂度 O(1)

class Solution {
public:
    //合并两个有序链表
    ListNode* mergeLists(ListNode* l1, ListNode* l2)
    {
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        if(l1->val < l2->val) 
        {
            l1->next = mergeLists(l1->next, l2);
            return l1;
        }
        else
        {
            l2->next = mergeLists(l1, l2->next);
            return l2;
        }    
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty()) return NULL;
        //依次两两合并链表
        ListNode *head = lists[0];
        for(int i = 1; i < lists.size(); i++)
        {
            if(lists[i]) head = mergeLists(head, lists[i]);
        }
        return head;
    }
};

• 思路三：思路二的优化版，仍然利用两有序链表合并，将待合并的所有链表进行递归分治处理，即将当前链表的序列分成两部分，每部分递归进行合并，然后将当前左右两部分合并的结果再进行 二合并 即可。合并过程如下所示，时间复杂度 O(nlogk)，空间复杂度 O(1)

  1 2 3 4 5 6 7 8

  1 3 5 7

  1 5

  ​ 1

class Solution {
public:
    //合并两个有序链表
    ListNode* mergeLists(ListNode* l1, ListNode* l2)
    {
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        if(l1->val < l2->val) 
        {
            l1->next = mergeLists(l1->next, l2);
            return l1;
        }
        else
        {
            l2->next = mergeLists(l1, l2->next);
            return l2;
        }    
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty()) return NULL;
        if (lists.size() == 1) return lists[0];
        
        int mid = lists.size() / 2;
        //将待合并的链表分成两部分，再对各部分分别递归处理
        vector<ListNode*> left = vector<ListNode*>(lists.begin(), lists.begin() + mid);
        vector<ListNode*> right = vector<ListNode*>(lists.begin() + mid, lists.end());
        ListNode *l1 = mergeKLists(left);
        ListNode *l2 = mergeKLists(right);
        return mergeLists(l1, l2);
    }
};