Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
O(N * logK)
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode **g_lists;
int g_num;
#define max_num 10000
struct ListNode *g_heap[max_num];
int heap_num;
void rebuildHeap(int i) {
int left = i * 2 + 1;
int right = i * 2 + 2;
if (left >= heap_num) {
return;
}
int min = i;
if (g_heap[i]->val > g_heap[left]->val) {
min = left;
}
if (right < heap_num && g_heap[min]->val > g_heap[right]->val) {
min = right;
}
if (min == i) {
return;
}
struct ListNode *tmp = g_heap[i];
g_heap[i] = g_heap[min];
g_heap[min] = tmp;
rebuildHeap(min);
}
void makeHeap() {
for (int i = heap_num / 2; i >= 0; --i) {
rebuildHeap(i);
}
}
struct ListNode *pickOne() {
if (heap_num == 0) {
return NULL;
}
struct ListNode *min = g_heap[0];
if (min->next == NULL) {
heap_num--;
g_heap[0] = g_heap[heap_num];
} else {
g_heap[0] = g_heap[0]->next;
}
rebuildHeap(0);
min->next = NULL;
return min;
}
struct ListNode *mergeKLists(struct ListNode *lists[], int k) {
if (k == 0) {
return NULL;
}
if (k == 1) {
return lists[0];
}
g_num = k;
g_lists = lists;
heap_num = 0;
for (int i = 0; i < g_num; ++i) {
if (g_lists[i] != NULL) {
g_heap[heap_num++] = g_lists[i];
}
}
makeHeap();
struct ListNode *head = NULL;
struct ListNode *cur = NULL;
struct ListNode *p = NULL;
while ((p = pickOne()) != NULL) {
if (head == NULL) {
head = p;
} else {
cur->next = p;
}
cur = p;
}
return head;
}