一刷25

Author: diguage

README.adoc

@@ -201,12 +201,12 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 |Medium
 |
 
-//|{counter:codes}
-//|{leetcode_base_url}/reverse-nodes-in-k-group/[25. Reverse Nodes in k-Group^]
-//|{source_base_url}/_0025_ReverseNodesInKGroup.java[Java]
-//|{doc_base_url}/0025-reverse-nodes-in-k-group.adoc[题解]
-//|Hard
-//|
+|{counter:codes}
+|{leetcode_base_url}/reverse-nodes-in-k-group/[25. Reverse Nodes in k-Group^]
+|{source_base_url}/_0025_ReverseNodesInKGroup.java[Java]
+|{doc_base_url}/0025-reverse-nodes-in-k-group.adoc[题解]
+|Hard
+|
 
 |{counter:codes}
 |{leetcode_base_url}/remove-duplicates-from-sorted-array/[26. Remove Duplicates from Sorted Array^]

docs/0025-reverse-nodes-in-k-group.adoc

@@ -1,29 +1,43 @@
 [#0025-reverse-nodes-in-k-group]
-= 25. Reverse Nodes in k-Group
+= 25. K 个一组翻转链表
 
-{leetcode}/problems/reverse-nodes-in-k-group/[LeetCode - Reverse Nodes in k-Group^]
+https://leetcode.cn/problems/reverse-nodes-in-k-group/[LeetCode - 25. K 个一组翻转链表 ^]
 
-Given a linked list, reverse the nodes of a linked list _k_ at a time and return its modified list.
+给你链表的头节点 `head`，每 `k` 个节点一组进行翻转，请你返回修改后的链表。
 
-_k_ is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of _k_ then left-out nodes in the end should remain as it is.
+`k` 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 `k` 的整数倍，那么请将最后剩余的节点保持原有顺序。
 
+你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
 
+*示例 1：*
 
+image::images/0025-01.jpg[{image_attr}]
 
-*Example:*
+....
+输入：head = [1,2,3,4,5], k = 2
+输出：[2,1,4,3,5]
+....
 
-Given this linked list: `1->2->3->4->5`
+*示例 2：*
 
-For _k_ = 2, you should return: `2->1->4->3->5`
+image::images/0025-02.jpg[{image_attr}]
 
-For _k_ = 3, you should return: `3->2->1->4->5`
+....
+输入：head = [1,2,3,4,5], k = 3
+输出：[3,2,1,4,5]
+....
 
-*Note:*
+*提示：*
 
+* 链表中的节点数目为 `n`
+* `+1 <= k <= n <= 5000+`
+* `+0 <= Node.val <= 1000+`
 
-* Only constant extra memory is allowed.
-* You may not alter the values in the list's nodes, only nodes itself may be changed.
+**进阶：**你可以设计一个只用 stem:[O(1)] 额外内存空间的算法解决此问题吗？
 
+== 思路分析
+
+先统计链表长度，然后根据长度将链表切段，每段使用递归反转链表，最后再接上剩余不够一段的部分。代码如下：
 
 [[src-0025]]
 [tabs]
@@ -42,7 +56,7 @@ include::{sourcedir}/_0025_ReverseNodesInKGroup.java[tag=answer]
 // --
 // [{java_src_attr}]
 // ----
-// include::{sourcedir}/_0015_3Sum_20.java[tag=answer]
+// include::{sourcedir}/_0025_ReverseNodesInKGroup_2.java[tag=answer]
 // ----
 // --
 ====

docs/images/0025-01.jpg

@@ -126,7 +126,7 @@ include::0023-merge-k-sorted-lists.adoc[leveloffset=+1]
 
 include::0024-swap-nodes-in-pairs.adoc[leveloffset=+1]
 
-// include::0025-reverse-nodes-in-k-group.adoc[leveloffset=+1]
+include::0025-reverse-nodes-in-k-group.adoc[leveloffset=+1]
 
 include::0026-remove-duplicates-from-sorted-array.adoc[leveloffset=+1]
 

docs/images/0025-02.jpg

@@ -62,7 +62,7 @@ endif::[]
 
 |{counter:codes2503}
 |{leetcode_base_url}/remove-duplicate-letters/[316. 去除重复字母^]
-|{doc_base_url}/0316-remove-duplicate-letters.adoc[题解]
+|{doc_base_url}/316. 去除重复字母[题解]
 |❌ 完全想不到单调栈！
 
 |{counter:codes2503}
@@ -120,6 +120,11 @@ endif::[]
 |{doc_base_url}/0215-kth-largest-element-in-an-array.adoc[题解]
 |✅ 快速选择
 
+|{counter:codes2503}
+|{leetcode_base_url}/reverse-nodes-in-k-group/[25. K 个一组翻转链表^]
+|{doc_base_url}/0025-reverse-nodes-in-k-group.adoc[题解]
+|✅ 分段递归反转，在拼接
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

docs/index.adoc

@@ -1,7 +1,52 @@
 package com.diguage.algo.leetcode;
 
+import com.diguage.algo.util.ListNode;
+
 public class _0025_ReverseNodesInKGroup {
   // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-04-02 16:12:21
+   */
+  public ListNode reverseKGroup(ListNode head, int k) {
+    int size = 0;
+    ListNode cur = head;
+    while (cur != null) {
+      size++;
+      cur = cur.next;
+    }
+    int sect = size / k;
+    // 如果长度不够一段，则直接返回
+    if (sect == 0) {
+      return head;
+    }
+    // 将链表分段做反转，再拼接
+    ListNode dummy = new ListNode(0);
+    ListNode tail = dummy;
+    cur = head;
+    for (int i = 0; i < sect; i++) {
+      ListNode[] result = reverse(cur, cur, null, k);
+      tail.next = result[0];
+      tail = result[1];
+      cur = result[2];
+    }
+    tail.next = cur; // 把最后的尾部给接上
+    return dummy.next;
+  }
 
+  // 参数：1、head，2、curr，3、prev，4、k
+  // 结果：1、head，2、tail（反转过来，参数的 head 就是 tail），3、next
+  private ListNode[] reverse(ListNode head,
+                             ListNode cur, ListNode prev, int k) {
+    if (k == 0) {
+      return new ListNode[]{null, head, cur};
+    }
+    ListNode[] result = reverse(head, cur.next, cur, k - 1);
+    if (k == 1) {
+      result[0] = cur;
+    }
+    cur.next = prev;
+    return result;
+  }
   // end::answer[]
 }