23 合并K个升序链表

题目

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2：

输入：lists = []
输出：[]
示例 3：

输入：lists = [[]]
输出：[]

• 法一：每次合并相邻的两个链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return nullptr;
        ListNode *p=lists[0];
        for(int i=1; i<lists.size(); ++i)
        {
            p = mergeList(p, lists[i]);
        }
        return p;
    }

    ListNode* mergeList(ListNode* list1, ListNode* list2)
    {
        ListNode dummy(-1);
        ListNode *p=&dummy;
        if(list1==nullptr) return list2;
        if(list2==nullptr) return list1;
        for(;list1!=nullptr&&list2!=nullptr; p=p->next)
        {
            if(list1->val < list2->val)
            {
                p->next=list1;
                list1=list1->next;
            }else
            {
                p->next=list2;
                list2=list2->next;
            }
        }
        if(list1!=nullptr) p->next=list1;
        else p->next=list2;
        return dummy.next;
    }
};

• 时间复杂度O(n1+n2+…)

• 空间复杂度O(1)

• 思路

  • 合并相邻的两个链表，每次调用合并两个有序链表函数，一共调用n-1次

• 法二：分治合并

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return nullptr;
        return merge(0, lists.size()-1, lists);
    }
	//分治合并
    ListNode* merge(int l, int r, vector<ListNode*> &lists)
    {
        if(l==r) return lists[l];
        if(l>r) return nullptr;
        int mid=l+(r-l)/2;
        return mergeList(merge(l, mid, lists), merge(mid+1, r, lists));
    }
	//合并两个有序列表
    ListNode* mergeList(ListNode* list1, ListNode* list2)
    {
        ListNode dummy(-1);
        ListNode *p=&dummy;
        if(list1==nullptr) return list2;
        if(list2==nullptr) return list1;
        for(;list1!=nullptr&&list2!=nullptr; p=p->next)
        {
            if(list1->val < list2->val)
            {
                p->next=list1;
                list1=list1->next;
            }else
            {
                p->next=list2;
                list2=list2->next;
            }
        }
        if(list1!=nullptr) p->next=list1;
        else p->next=list2;
        return dummy.next;
    }
};

• 时间复杂度O(kn*lgk)
• 空间复杂度O(lgk)，递归使用的栈的空间
• 思路
  • 分治合并，每相邻两个先合并，再合并上一层，以此类推
  • 类似归并排序思想