题目来源

这是力扣一道困难难度的算法题，题目序号23，链接 https://leetcode-cn.com/problems/merge-k-sorted-lists/ 有兴趣的同学可以上去看下。

题目内容

给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表

示例 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

初步分析

比较常见的是两个有序链表的合并，算是链表的经典算法题。而本题是两个有序链表合并的升级，多个有序链表的合并。
但因为是一脉相承，我们从两个有序链表合并的思路，向多个有序链表扩展。
两个链表合并时我们用list1和list2，而多个链表，因为链表个数不确定，所以需要用上索引。

解题思路

循环判断各链表头节点，找出最小节点对应的索引index。
如果所有头节点都为空，则合并完成。
将index对应头节点挂在返回链表上。同时该index指向链表下一个节点。继续从步骤1开始处理。

代码实现

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

struct ListNode* mergeKLists(struct ListNode** lists, int listsSize){
    struct ListNode *head, **ppcur = &head;
    int i;

    //链表数组为空
    if (listsSize < 1)
    {
        return NULL;
    }

    //只有一个有序链表，直接返回即可
    if (listsSize == 1)
    {
        return lists[0];
    }

    while (1)
    {
        int min = -1;

        for (i = 0; i < listsSize; i++)
        {
            if (lists[i] == NULL)
            {
                continue;
            }

            //确定最小节点的索引
            if (min == -1)
            {
                min = i;
            }
            else
            {
                if (lists[i]->val < lists[min]->val)
                {
                    min = i;
                }
            }
        }

        if (min == -1)
        {
            //所有节点都处理完毕
            *ppcur = NULL;
            break;
        }
        else
        {
            //将节点挂在链表上，同时该索引指向链表下一节点。
            *ppcur = lists[min];
            lists[min] = lists[min]->next;
            ppcur = &(*ppcur)->next;
        }
    }

    return head;
}