三刷23

Author: diguage

docs/0023-merge-k-sorted-lists.adoc

@@ -1,37 +1,84 @@
 [#0023-merge-k-sorted-lists]
-= 23. Merge k Sorted Lists
+= 23. 合并 K 个升序链表
 
-{leetcode}/problems/merge-k-sorted-lists/[LeetCode - Merge k Sorted Lists^]
+https://leetcode.cn/problems/merge-k-sorted-lists/[LeetCode - 23. 合并 K 个升序链表 ^]
 
-Merge _k_ sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
+给你一个链表数组，每个链表都已经按升序排列。
 
-*Example:*
+请你将所有链表合并到一个升序链表中，返回合并后的链表。
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:*
+*示例 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
 ]
-*Output:* 1->1->2->3->4->4->5->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^`
 
 == 思路分析
 
 优先队列是最优解，退而求其次，可以考虑使用分治。
 
 [[src-0023]]
+[tabs]
+====
+一刷::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0023_MergeKSortedLists.java[tag=answer]
 ----
+--
 
+二刷::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0023_MergeKSortedLists_2.java[tag=answer]
 ----
+--
+
+三刷::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0023_MergeKSortedLists_3.java[tag=answer]
+----
+--
+====
 
 == 参考资料
 

logbook/202503.adoc

@@ -85,6 +85,11 @@ endif::[]
 |{doc_base_url}/0295-find-median-from-data-stream.adoc[题解]
 |⭕️ 双堆，思路理解，写代码却有很多问题。
 
+|{counter:codes2503}
+|{leetcode_base_url}/merge-k-sorted-lists/[23. Merge k Sorted Lists^]
+|{doc_base_url}/0023-merge-k-sorted-lists.adoc[题解]
+|✅ 多路归并
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

src/main/java/com/diguage/algo/leetcode/_0023_MergeKSortedLists.java

@@ -31,6 +31,10 @@
 public class _0023_MergeKSortedLists {
   // tag::answer[]
 
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2019-10-22 12:40:12
+   */
   public ListNode mergeKLists(ListNode[] lists) {
     PriorityQueue<ListNode> heap = new PriorityQueue<>((l1, l2) -> l1.val - l2.val);
     for (ListNode l : lists) {

src/main/java/com/diguage/algo/leetcode/_0023_MergeKSortedLists_2.java

@@ -30,6 +30,11 @@
  */
 public class _0023_MergeKSortedLists_2 {
   // tag::answer[]
+
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2024-07-02 20:13:49
+   */
   public ListNode mergeKLists(ListNode[] lists) {
     if (Objects.isNull(lists) || lists.length == 0) {
       return null;

src/main/java/com/diguage/algo/leetcode/_0023_MergeKSortedLists_3.java

@@ -0,0 +1,42 @@
+package com.diguage.algo.leetcode;
+
+import com.diguage.algo.util.ListNode;
+
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.PriorityQueue;
+
+public class _0023_MergeKSortedLists_3 {
+  // tag::answer[]
+/**
+ * @author D瓜哥 · https://www.diguage.com
+ * @since 2025-03-30 23:20:44
+ */
+public ListNode mergeKLists(ListNode[] lists) {
+  if (Objects.isNull(lists) || lists.length == 0) {
+    return null;
+  }
+  // 注意：这里使用一个虚拟头节点，方便后续的操作
+  ListNode dummy = new ListNode(0);
+  // 自定义 Comparator，对堆内的 ListNode 头节点数字做排序
+  PriorityQueue<ListNode> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a.val));
+  for (ListNode node : lists) {
+    if (Objects.nonNull(node)) {
+      pq.offer(node);
+    }
+  }
+  ListNode current = dummy;
+  while (!pq.isEmpty()) {
+    ListNode node = pq.poll();
+    current.next = node;
+    current = node;
+    ListNode next = node.next;
+    node.next = null;
+    if (Objects.nonNull(next)) {
+      pq.offer(next);
+    }
+  }
+  return dummy.next;
+}
+  // end::answer[]
+}