leetcode 25. Reverse Nodes in k-Group singly-linked list

Author: myoshi2891

DataStructures/LinkedLists/leetcode/25. Reverse Nodes in k-Group/README.md

@@ -0,0 +1,194 @@
+以下に、「連結リストを k 個ずつ反転する」問題において、各処理ステップを **図解とともに** 詳しく解説します。Python 実装に基づいて、`k = 3` の例 `head = [1 → 2 → 3 → 4 → 5 → 6 → 7]` を使います。
+
+---
+
+## ✅ 初期構造と目的
+
+```
+Input List:       1 → 2 → 3 → 4 → 5 → 6 → 7
+k = 3
+
+目標:
+1グループ目 → [1,2,3] → 反転 → 3 → 2 → 1  
+2グループ目 → [4,5,6] → 反転 → 6 → 5 → 4  
+残り → [7] はk未満なのでそのまま
+
+出力: 3 → 2 → 1 → 6 → 5 → 4 → 7
+```
+
+---
+
+## ✅ ステップ別処理図解
+
+### 🔷 Step 1: 長さのカウント
+
+```python
+node = head
+while node:
+    count += 1
+    node = node.next
+```
+
+```
+1 → 2 → 3 → 4 → 5 → 6 → 7
+↑    ↑    ↑    ↑    ↑    ↑
+1    2    3    4    5    6    7ノードあるので count = 7
+```
+
+---
+
+### 🔷 Step 2: ダミーノード作成
+
+```python
+dummy = ListNode(0)
+dummy.next = head
+prev_group_end = dummy
+```
+
+```
+dummy → 1 → 2 → 3 → 4 → 5 → 6 → 7
+↑
+prev_group_end
+```
+
+ダミーノードにより、最初のグループの先頭を簡単に付け替え可能。
+
+---
+
+### 🔷 Step 3: 最初の3ノードを反転（1回目）
+
+```python
+prev = None
+curr = prev_group_end.next  # 1
+group_start = curr          # 1
+
+for _ in range(k):
+    next_node = curr.next
+    curr.next = prev
+    prev = curr
+    curr = next_node
+```
+
+#### ⏳反転処理の流れ
+
+```
+初期:
+prev = None
+curr = 1 → 2 → 3
+
+1回目:
+curr = 1 → 2
+1.next → None（prev）
+prev = 1
+
+2回目:
+curr = 2 → 3
+2.next → 1
+prev = 2 → 1
+
+3回目:
+curr = 3 → 4
+3.next → 2 → 1
+prev = 3 → 2 → 1
+```
+
+結果: `prev = 3 → 2 → 1`, `curr = 4`
+
+---
+
+### 🔷 Step 4: 接続調整（グループ外リンク修正）
+
+```python
+prev_group_end.next = prev  # dummy.next = 3
+group_start.next = curr     # 1.next = 4
+prev_group_end = group_start
+```
+
+```
+dummy → 3 → 2 → 1 → 4 → 5 → 6 → 7
+                          ↑
+                    prev_group_end
+```
+
+---
+
+### 🔷 Step 5: 次の3ノードを反転（2回目）
+
+反転対象: 4 → 5 → 6
+初期状態:
+
+```
+prev = None
+curr = 4
+group_start = 4
+```
+
+#### ⏳反転処理
+
+```
+1回目: 4.next → None（prev） → prev = 4
+2回目: 5.next → 4 → prev = 5 → 4
+3回目: 6.next → 5 → 4 → prev = 6 → 5 → 4
+```
+
+curr = 7
+
+---
+
+### 🔷 Step 6: 接続調整（再び）
+
+```python
+prev_group_end.next = prev  # 1.next = 6
+group_start.next = curr     # 4.next = 7
+prev_group_end = group_start  # prev_group_end = 4
+```
+
+結果:
+
+```
+dummy → 3 → 2 → 1 → 6 → 5 → 4 → 7
+                                       ↑
+                               prev_group_end
+```
+
+---
+
+### 🔷 Step 7: 残りノード < k（終了）
+
+* 残りノード数 = 1（7のみ）
+* `count = 1 < k` なのでループ終了
+
+---
+
+## ✅ 最終結果
+
+```
+出力:
+3 → 2 → 1 → 6 → 5 → 4 → 7
+```
+
+---
+
+## ✅ 全体処理フローまとめ図（抽象）
+
+```
+dummy → [kノード] → [kノード] → 残りノード
+        ↓反転       ↓反転        そのまま
+
+dummy → reversed_k1 → reversed_k2 → rest
+```
+
+---
+
+## ✅ 時間・空間複雑度（再確認）
+
+| 指標    | 値                    |
+| ----- | -------------------- |
+| 時間計算量 | O(n)（各ノードを一度ずつ操作）    |
+| 空間計算量 | O(1)（追加ノードなし）        |
+| メモリ   | リスト構造のみ使用            |
+| 実行時間  | ≒ 80〜100ms（LeetCode） |
+
+---
+
+図付きステップやアニメーション的な表示をご希望であれば、さらに細かくビジュアルで表現することも可能です。ご希望があれば教えてください。

DataStructures/LinkedLists/leetcode/25. Reverse Nodes in k-Group/Reverse-Nodes–in-k-Group.js

@@ -0,0 +1,100 @@
+// 以下に、**LeetCode環境（Node.js 18.16.1）向け**に「k個ずつノードを反転する」問題の解法を、**関数形式で記述したJavaScriptコード**を提示します。
+// **ノードの値は変更せず、ノード自体を操作する必要があります。**
+
+// ---
+
+// ## ✅ 実装の概要
+
+// * `reverseKGroup` 関数を定義。
+// * ノードをk個ずつ確認して反転。
+// * 反転できない残りのノードはそのまま保持。
+// * O(1) 空間（再帰なし・配列使用なし）で対応。
+
+// ---
+
+// ### ✅ JavaScript 実装（関数形式）
+
+// ```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val);
+ *     this.next = (next===undefined ? null : next);
+ * }
+ */
+
+/**
+ * @param {ListNode} head - 単方向連結リストの先頭ノード
+ * @param {number} k - グループ単位の反転サイズ（1 <= k <= n）
+ * @return {ListNode} - k個ごとに反転された新しいリストの先頭ノード
+ */
+function reverseKGroupJs(head, k) {
+    if (k === 1 || head === null) return head;
+
+    // 長さを測定
+    let count = 0;
+    let node = head;
+    while (node !== null) {
+        count++;
+        node = node.next;
+    }
+
+    // ダミーヘッド（操作の単純化）
+    let dummy = new ListNode(0);
+    dummy.next = head;
+
+    let prevGroupEnd = dummy;
+
+    while (count >= k) {
+        let prev = null;
+        let curr = prevGroupEnd.next;
+        let next = null;
+        let groupStart = curr;
+
+        // k個反転
+        for (let i = 0; i < k; i++) {
+            next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+
+        // 接続処理
+        prevGroupEnd.next = prev;
+        groupStart.next = curr;
+        prevGroupEnd = groupStart;
+        count -= k;
+    }
+
+    return dummy.next;
+}
+
+// ## ✅ 処理の流れ（図解付き）
+
+// ### 例: `head = [1, 2, 3, 4, 5], k = 3`
+
+// 1. `1 → 2 → 3 → 4 → 5`
+// 2. `3 → 2 → 1 → 4 → 5`（最初の3つを反転）
+// 3. 残り（4,5）は反転されずそのまま
+
+// ---
+
+// ## ✅ 時間・空間計算量
+
+// | 項目     | 値                    |
+// | ------ | -------------------- |
+// | 時間計算量  | O(n)                 |
+// | 空間計算量  | O(1)（再帰なし、定数領域）      |
+// | メモリ消費  | ノード再配置のみ             |
+// | 実行速度目安 | 約100ms前後（LeetCode基準） |
+
+// ---
+
+// ## ✅ 補足
+
+// * `ListNode` は LeetCode が自動的に用意するので、自分で定義しなくてOK。
+// * クラスベースでなく、関数形式にしたため他コードとの結合も簡単です。
+
+// ---
+
+// 必要であれば、テスト用コードや図でのステップ解説も追記可能です。