【leetcode】Merge k Sorted Lists

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;
}