力扣刷题之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

思路是这样的：

        核心思想是通过比较和选择来逐个合并链表中的结点。跟暴力破解差不多想法。

        首先，创建一个哨兵结点head，它的next指针将指向合并后的链表的头结点。这样做的好处已经在19.删除链表的倒数第n个结点中有提到过了。定义一个current指针，初始时指向哨兵结点。这个指针将在每次找到最小结点时后移，用于构建合并后的链表。

        哨兵的作用是在处理边界问题的时候会变的很方便，就像遇到了一个空链表，如果我们在不知情的情况下访问了头结点的next结点，可能会产生空指针异常。所以设置了哨兵的话就能保证怎么着都有一个结点能访问。还有一个就是能让我们清晰的知道这个链表的头/尾在哪。

        使用一个数组来存储所有待合并链表的头结点。这样做是为了在每次循环中快速访问和更新每个链表的头结点。

        在这里自己写好两个方法：判断链表不为空的方法hasMoreThanOneList和找到当前最小结点的方法findMinIndex。hasMoreThanOneList方法用于检查是否还有多个非空链表，如果有，继续合并过程。findMinIndex方法用于在listHeads数组中找到当前最小结点的索引。它遍历数组，比较每个非空链表的头结点的值，找到最小的那个。

        当所有链表都不为空时，执行循环进行合并。在每次循环中，通过findMinIndex方法找到当前最小的结点的索引下标。将最小结点添加到合并后的链表中，然后将current指向next。
        更新listHeads数组中对应链表的头结点，将其设置为原链表中的下一个结点，这样在下一次循环中可以继续比较和选择。

        当合并完成后，返回哨兵结点的next。

        这样做的好处是自己写的时候比较简单，仅限于自己写的时候。对于复杂度来说还是很大的。具体的解决方法还是没有想出来，下次再来好好解决。

代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode head = new ListNode(0);
        ListNode current = head;

        ListNode[] listHeads = new ListNode[lists.length];

        for (int i = 0; i < lists.length; i++) {
            if (lists[i] != null) {
                listHeads[i] = lists[i];
            }
        }

        while (hasMoreThanOneList(listHeads)) {
            int minIndex = findMinIndex(listHeads);
            ListNode minNode = listHeads[minIndex];

            current.next = minNode;
            current = current.next;

            listHeads[minIndex] = minNode.next;
        }

        return head.next;
    }

    // 检查是否还有多个非空链表
    private boolean hasMoreThanOneList(ListNode[] listHeads) {
        for (ListNode head : listHeads) {
            if (head != null) {
                return true;
            }
        }
        return false;
    }

    // 找到当前最小节点的索引
    private int findMinIndex(ListNode[] listHeads) {
        int minIndex = 0;
        for (int i = 1; i < listHeads.length; i++) {
            if (listHeads[i] != null && (listHeads[minIndex] == null || listHeads[i].val < listHeads[minIndex].val)) {
                minIndex = i;
            }
        }
        return minIndex;
    }
}

（算法大佬英雄哪里出来曾曰：过——啦）

解决了但还没完全解决。