lintcode-104-合并k个排序链表

104-合并k个排序链表

方法一（最简单，但效率不高）

每次从当前K个链表中，选取值最小的节点，加入已排序链表中

code

/**
* Definition of ListNode
* class ListNode {
* public:
*     int val;
*     ListNode *next;
*     ListNode(int val) {
*         this->val = val;
*         this->next = NULL;
*     }
* }
*/
class Solution {
public:
/**
* @param lists: a list of ListNode
* @return: The head of one sorted list.
*/
ListNode *mergeKLists(vector<ListNode *> &lists) {
// write your code here
ListNode * newHead = new ListNode(-1);
ListNode * current = newHead;

while(!isAllListEmpty(lists)) {
current->next = findMin(lists);
current = current->next;
}

return newHead->next;
}

bool isAllListEmpty(vector<ListNode *> &lists) {
for(int i=0; i<lists.size(); i++) {
if(lists[i] != NULL) {
return false;
}
}
return true;
}

ListNode *findMin(vector<ListNode *> &lists) {
int minValue = 0x7FFFFFFF;
int minIndex = 0;
ListNode * result = NULL;

for(int i=0; i<lists.size(); i++) {
if(lists[i] != NULL && lists[i]->val < minValue) {
minValue = lists[i]->val;
result = lists[i];
minIndex = i;
}
}
lists[minIndex] = lists[minIndex]->next;
return result;
}
};

方法二（使用最小堆）

方法一的时间消耗主要体现于在 k 个链表中寻找最小值，每次寻找最小值都需要 O(k) 的时间复杂度，所以可以采用最小堆，将 k 个链表的表头放入堆中，它们会自动排好序。然后取出堆顶元素加入已排序链表，把取出元素的下一个元素再加入堆中。以此类推，直至堆空。

code

/**
* Definition of ListNode
* class ListNode {
* public:
*     int val;
*     ListNode *next;
*     ListNode(int val) {
*         this->val = val;
*         this->next = NULL;
*     }
* }
*/
class Solution {
public:
/**
* @param lists: a list of ListNode
* @return: The head of one sorted list.
*/
struct cmp {
bool operator () (ListNode *a, ListNode *b) {
return a->val > b->val;
}
};

ListNode *mergeKLists(vector<ListNode *> &lists) {
// write your code here
priority_queue<ListNode*, vector<ListNode*>, cmp> minHeap;

for(int i=0; i<lists.size(); i++) {
if(lists[i] != NULL) {
minHeap.push(lists[i]);
}
}

ListNode *newHead = NULL, *current = NULL, *temp = NULL;
while (!minHeap.empty()) {
temp = minHeap.top();
minHeap.pop();

if (current == NULL) {
newHead = temp;
}
else {
current->next = temp;
}
current = temp;
if (temp->next != NULL) {
minHeap.push(temp->next);
}
}
return newHead;
}
};