23. 合并 K 个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：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

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

#define swap(a, b)                                                             \
    {                                                                          \
        __typeof(a) __c = (a);                                                 \
        (a) = (b);                                                             \
        (b) = __c;                                                             \
    }

void up_upgrade(struct ListNode** arr, int n) {
    if (n == 1)
        return;
    int f = n / 2;
    if (arr[n]->val < arr[f]->val) {
        swap(arr[n], arr[f]);
        up_upgrade(arr, f);
    }
    return;
}

void down_upgrade(struct ListNode** arr, int i, int n) {
    if (n == 1)
        return;
    int ind = i, l = i * 2, r = i * 2 + 1;
    if (l <= n) {
        if (arr[ind]->val > arr[l]->val)
            ind = l;
        if (r <= n && arr[ind]->val > arr[r]->val)
            ind = r;
        if (ind == i)
            return;
        swap(arr[ind], arr[i]);
        down_upgrade(arr, ind, n);
    }
    return;
}

struct ListNode* pop(struct ListNode** arr, int n) {
    swap(arr[1], arr[n]);
    down_upgrade(arr, 1, n - 1);
    return arr[n];
}

int push(struct ListNode** arr, int n) {
    if (arr[n]->next) {
        arr[n] = arr[n]->next;
        up_upgrade(arr, n);
        return 0;
    }
    return 1;
}

void heap_sort(struct ListNode** arr, int n) {
    for (int i = n / 2; i >= 1; i--) {
        down_upgrade(arr, i, n);
    }
    return;
}

struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {
    struct ListNode** __arr =
        (struct ListNode**)malloc(sizeof(struct ListNode*) * listsSize);
    struct ListNode root, *node = NULL, **arr = __arr - 1;
    root.next = NULL;
    node = &root;
    int n = 0;
    for (int i = 0; i < listsSize; i++) {
        if(lists[i]!=NULL){
            __arr[n++] = lists[i];
        }
    }
    heap_sort(arr, n);
    while (n) {
        node->next = pop(arr, n);
        n -= push(arr, n);
        node = node->next;
    }
    return root.next;
}