合并K个有序链表(困难)
给你一个链表数组,每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中,返回合并后的链表。
示例
输入: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
输入:lists = []
输出:[]
lists = [[]]
输出:[]
解题
思路一:这个题和之前合并两个有序链表很像,只不过这次变成了多个链表合并,当然我们会想到先让第一个链表和第二个链表合并,然后让合并后的链表于第三个链表合并…一直重复即可。但是这样做效率太低,不能OJ。因此我们采用分治法,即不停的对半划分,比如k个链表先划分为合并两个 k/2 个链表的任务,再不停的往下划分,直到划分成只有一个或两个链表的任务,开始合并。
举个例子来说,比如合并6个链表,那么按照分治法,首先分别合并0和3,1和4,2和5。这样下一次只需合并3个链表,再合并1和3,最后和2合并就可以了。代码中的k是通过 (n+1)/2 计算的,这里为啥要加1呢,这是为了当n为奇数的时候,k能始终从后半段开始,比如当 n=5 时,那么此时 k=3,则0和3合并,1和4合并,最中间的2空出来。当n是偶数的时候,加1也不会有影响,比如当 n=4 时,此时 k=2,那么0和2合并,1和3合并,完美解决问题,参见代码如下
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
if (lists.empty()) return NULL;
int n = lists.size();
while (n > 1) {
int k = (n + 1) / 2;
for (int i = 0; i < n / 2; ++i) {
lists[i] = mergeTwoLists(lists[i], lists[i + k]);
}
n = k;
}
return lists[0];
}
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode *dummy = new ListNode(-1), *cur = dummy;
while (l1 && l2) {
if (l1->val < l2->val) {
cur->next = l1;
l1 = l1->next;
} else {
cur->next = l2;
l2 = l2->next;
}
cur = cur->next;
}
if (l1) cur->next = l1;
if (l2) cur->next = l2;
return dummy->next;
}
};
思路二:两个有序链表排序的思路都是一样的,在对多个链表的处理上我们也可以不采用对半划分,用递归的思路来做:做法是将原链表分成两段,然后对每段调用递归函数,suppose 返回的 left 和 right 已经合并好了,然后再对 left 和 right 进行合并,递归的结束条件是最后只剩下了一串链表,则返回这串链表,这样递归之后每次返回的链表都是已经排好序的链表。参见代码如下:
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
if(lists.empty())
return NULL;
int n=lists.size();
return digui(lists,0,n-1);
}
ListNode* digui(vector<ListNode*>& lists,int start,int end){
if(start>end) return NULL;
if(start==end) return lists[start];
int mid=start+(end-start)/2;
ListNode* left=digui(lists,start,mid);
ListNode* right=digui(lists,mid+1,end);
return mergeTwoLists(left,right);
}
ListNode* mergeTwoLists(ListNode* l1,ListNode* l2){
if(!l1) return l2;
if(!l2) return l1;
if(l1->val<l2->val){
l1->next=mergeTwoLists(l1->next,l2);
return l1;
}
else{
l2->next=mergeTwoLists(l1,l2->next);
return l2;
}
}
};
思路三:采用哈希函数(很厉害,思路清晰简单)
思路是将所有的结点值出现的最大值和最小值都记录下来,然后记录每个结点值出现的次数,这样从最小值遍历到最大值的时候,就会按顺序经过所有的结点值,根据其出现的次数,建立相对应个数的结点。但是这种解法有个特别需要注意的地方,那就是合并后的链表结点都是重新建立的,若在某些情况下,不能新建结点,而只能交换或者重新链接结点的话,那么此解法就不能使用,但好在本题并没有这种限制,可以完美过 OJ,参见代码如下:
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
ListNode *dummy = new ListNode(-1), *cur = dummy;
unordered_map<int, int> m;
int mx = INT_MIN, mn = INT_MAX;
for (auto node : lists) {
ListNode *t = node;
while (t) {
mx = max(mx, t->val);
mn = min(mn, t->val);
++m[t->val];
t = t->next;
}
}
for (int i = mn; i <= mx; ++i) {
if (!m.count(i)) continue;
for (int j = 0; j < m[i]; ++j) {
cur->next = new ListNode(i);
cur = cur->next;
}
}
return dummy->next;
}
};