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 = [[]]
输出：[]

法一：暴力

• 先合并前两个链表，再把得到的新链表和第三个链表合并，再和第四个链表合并，依此类推

// 21. 合并两个有序链表
var mergeTwoLists = function (list1, list2) {
    const dummy = new ListNode(); // 哨兵节点
    let cur = dummy; // 指向新链表的末尾
    while (list1 && list2) {
        if (list1.val < list2.val) {
            cur.next = list1; // 添加 list1 的当前节点
            list1 = list1.next; // 移动 list1
        } else {
            cur.next = list2; // 添加 list2 的当前节点
            list2 = list2.next; // 移动 list2
        }
        cur = cur.next; // 更新新链表的末尾
    }
    cur.next = list1 ? list1 : list2; // 拼接剩余的链表
    return dummy.next; // 返回合并后的链表头节点
};

var mergeKLists = function (lists) {
    if (lists.length === 0) return null; // 如果没有链表，返回 null
    
    let mergedList = lists[0]; // 从第一个链表开始
    // 逐个合并其他链表
    for (let i = 1; i < lists.length; i++) {
        mergedList = mergeTwoLists(mergedList, lists[i]);
    }
    
    return mergedList; // 返回最终合并后的链表
};

法二：递归+分治

• 把 lists 一分为二，先合并前一半的链表，再合并后一半的链表，然后把这两个链表合并成最终的链表。如何合并前一半的链表呢？我们可以继续一分为二。如此分下去直到只有一个链表，此时无需合并。

// 21. 合并两个有序链表
var mergeTwoLists = function (list1, list2) {
    const dummy = new ListNode(); // 用哨兵节点简化代码逻辑
    let cur = dummy; // cur 指向新链表的末尾
    while (list1 && list2) {
        if (list1.val < list2.val) {
            cur.next = list1; // 把 list1 加到新链表中
            list1 = list1.next;
        } else { // 注：相等的情况加哪个节点都是可以的
            cur.next = list2; // 把 list2 加到新链表中
            list2 = list2.next;
        }
        cur = cur.next;
    }
    cur.next = list1 ? list1 : list2; // 拼接剩余链表
    return dummy.next;
};

var mergeKLists = function (lists) {
    // 合并从 lists[i] 到 lists[j-1] 的链表
    function dfs(i, j) {
        const m = j - i;
        if (m === 0) {
            return null; // 注意输入的 lists 可能是空的
        }
        if (m === 1) {
            return lists[i]; // 无需合并，直接返回
        }
        //Math.floor(m / 2)与(m >> 1)等价
        const left = dfs(i, i + Math.floor(m / 2)); // 合并左半部分
        const right = dfs(i + (m >> 1), j); // 合并右半部分
        return mergeTwoLists(left, right); // 最后把左半和右半合并
    }
    return dfs(0, lists.length);
};

法三、找最小

• 因为子链表都是升序，每次的最小值一定在子链表的头节点。

var mergeKLists = function(lists) {
    // 创建一个新的链表头
    const mergedHead = new ListNode(0);
    let current = mergedHead;

    while (true) {
        let minIndex = -1;//最小下标
        let minValue = Infinity;//最小值

        // 找到当前所有链表中最小的节点
        for (let i = 0; i < lists.length; i++) {
            //一开始lists[i].val是lists中子链表的头节点
            if (lists[i] && lists[i].val < minValue) {
                minValue = lists[i].val;
                minIndex = i;
            }
        }

        // 如果找到了最小节点，则将其添加到合并链表中
        if (minIndex !== -1) {
            current.next = lists[minIndex];
            current = current.next;
            lists[minIndex] = lists[minIndex].next; // 在该子链表中移动到下一个节点
        } else {
            // 如果没有找到最小节点，说明所有链表都已合并
            break;
        }
    }

    return mergedHead.next; // 返回合并后的链表头
};