Merge k Sorted Lists
原题链接:https://leetcode.com/problems/merge-k-sorted-lists/description/
题目要求将k个已排好序(升序)的链表,合并成一个有序的链表。
Solution1: 第一种方法就是,用分治法,先将这k个list两两合并,得到k/2个长度为2n的新链表;然后继续将这k/2个链表两两合并,直到最后合并成一个链表。
ListNode* mergeKLists(vector<ListNode*>& lists) {
int k = lists.size();
if (k == 0) return NULL;
if (k == 1) return lists[0];
vector<ListNode*> A(lists.begin(), lists.begin() + k/2);
vector<ListNode*> B(lists.begin() + k/2, lists.end());
ListNode* list_A = mergeKLists(A);
ListNode* list_B = mergeKLists(B);
ListNode *result = NULL, *tempNode;
while(list_A || list_B) { // list 都是升序
if (!list_A) {
if (!result) {
result = new ListNode(list_B->val);
result -> next = list_B -> next;
} else {
tempNode->next = list_B;
}
break;
}
if (!list_B) {
while (list_A) {
if (!result) {
result = new ListNode(list_A->val);
tempNode = result;
} else {
tempNode->next = new ListNode(list_A->val);
tempNode = tempNode -> next;
}
list_A = list_A -> next;
}
break;
}
int value_A = list_A->val;
int value_B = list_B->val;
if (!result) {
result = new ListNode(min(value_A, value_B));
tempNode = result;
} else {
tempNode->next = new ListNode(min(value_A, value_B));
tempNode = tempNode -> next;
}
if (value_A < value_B) list_A = list_A -> next;
else list_B = list_B -> next;
}
return result;
}
算法复杂度: 假设k个list共有N个节点,则复杂度为O(Nlogk)。
Solution2: 可以使用priority_queue这种数据结构,因为priority_queue的第一个元素是它所包含的元素中最大或最小的。将k个list中所有节点的数据都存入priority_queue中,并根据这个priority_queue重新生成一个链表。
struct compareNodes {
bool operator()(const int a, const int b) {
return a > b;
}
};
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
priority_queue<int, vector<int>, compareNodes> p;
for (auto l : lists) {
while (l) {
p.push(l -> val);
l = l->next;
}
}
ListNode* result = NULL, *tail;
if (!p.empty()) {
result = new ListNode(p.top());
tail = result;
p.pop();
}
while (!p.empty()) {
tail -> next = new ListNode(p.top());
tail = tail -> next;
p.pop();
}
return result;
}
};
算法复杂度: 查找优先队列中的最小值,需要O(1),插入和删除需要O(logN),其中N为优先队列中元素个数。所以,假设k个list共有N个节点,这种方法的复杂度为O(NlogN)。
改进:若在k路归并中使用优先队列来选择最小值,则只需要构建一个长度为k的优先队列,因此时间复杂度可以达到O(Nlogk)。