Add LeetCode 103 Binary Tree Zigzag Level Order Traversal solutions

Author: myoshi2891

Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Python.md

@@ -0,0 +1,276 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: TypeScript
+> 適用ルールセット: 共通5ルール + TS固有5ルール
+> 参照ファイル: references/common.md + references/typescript.md
+
+---
+
+# 1. 問題の分析
+
+> 💡 **この問題は一言で言うと**「二分木（＝各ノードが最大2つの子を持つ木構造）を階層ごとに読み取り、偶数階層は左→右、奇数階層は右→左と**ジグザグ**に読む問題」です。
+
+## 競技プログラミング視点での分析
+
+通常のレベルオーダー（幅優先探索＝BFS）に「偶数階層か奇数階層かで読む向きを反転する」処理を追加します。
+
+- 全ノードを一度だけ訪問すれば解けるため、時間計算量（＝処理にかかる手間の目安）は **O(n)** が目標
+- キューに保持するノード数は「最も幅が広い階層のノード数」が上限 → 完全二分木なら最大 `n/2` ノード
+
+## 業務開発視点での分析
+
+- `TreeNode | null` という **Union型（＝複数の型のどちらかを表す型）** を通じてnull安全性を確保
+- `root` が `null`（空ツリー）のケースは最初にガードして早期リターンする
+- 各階層の結果を `number[][]` に格納するため、型が明確で保守しやすい
+
+## TypeScript特有の考慮点
+
+- LeetCode環境では `TreeNode` クラスが外部から定義されているため、ジェネリクスは使わず `number` 固定で問題なし
+- `readonly` や `const assertion` より**可読性を最優先**にした実装が現場にもマッチする
+
+> 📖 **このセクションで登場した用語**
+>
+> - **BFS（幅優先探索）**：木やグラフを「階層ごと」に左から右へ探索する方法。キュー（行列）を使う
+> - **Union型**：`A | B` のように「AかBのどちらかの型」を表すTypeScript独自の型表現
+> - **null安全性**：`null` や `undefined` への予期せぬアクセスでクラッシュしないように守る仕組み
+
+---
+
+# 2. アルゴリズムアプローチ比較
+
+> 💡 同じ問題でも解き方は複数あります。それぞれの「速さ（時間計算量）」と「メモリの使いやすさ（空間計算量）」を比べ、最適なものを選びます。
+
+| アプローチ                                       | 時間計算量 | 空間計算量  | TS実装コスト | 型安全性 | 可読性 | 備考                                  |
+| ------------------------------------------------ | ---------- | ----------- | ------------ | -------- | ------ | ------------------------------------- |
+| **BFS + 偶奇で reverse**                         | O(n)       | O(n)        | 低           | 高       | ⭐高   | 最もシンプル・直感的                  |
+| BFS + 両端キュー（deque）で先頭/末尾交互挿入     | O(n)       | O(n)        | 中           | 高       | 中     | JS標準にdequeがなく実装が煩雑         |
+| DFS（深さ優先探索）＋ 各階層にpush               | O(n)       | O(n) + O(h) | 中           | 高       | 中     | 再帰スタックが木の高さ h 分追加される |
+| ブルートフォース（全ノードを配列に格納して整理） | O(n²)      | O(n)        | 低           | 高       | 低     | reverseが各階層で走り非効率           |
+
+> 💡 **Big-O記法の読み方**
+>
+> - `O(n)`：ノード数が2倍になると処理も約2倍（一番無駄がない）
+> - `O(h)`：木の高さ h 分のスタック消費（最悪 O(n)、バランスが取れていれば O(log n)）
+>   📖 **このセクションで登場した用語**
+> - **時間計算量**：ノード数に対して処理の手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **deque（両端キュー）**：先頭・末尾どちらからでも追加・取り出しができるデータ構造
+
+---
+
+# 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**: **BFS + 偶数階層はそのまま / 奇数階層は reverse**
+
+| 観点                    | 理由                                                                                   |
+| ----------------------- | -------------------------------------------------------------------------------------- |
+| 計算量                  | O(n) で全ノードを一度だけ処理。反転は各階層のサイズに応じた O(k) なのでトータルは O(n) |
+| 型安全性                | キューの型を `TreeNode[]` で明示でき、null チェックも自然に書ける                      |
+| 可読性                  | BFS の骨格はシンプルなので「偶奇で方向を切り替える」意図がコードから一目で読み取れる   |
+| dequeを選ばなかった理由 | JavaScriptには標準の deque がなく、配列の `unshift` は O(n) コストがかかるため不利     |
+| DFSを選ばなかった理由   | 再帰の深さが木の高さ分スタックを消費するため、偏った木（線形に伸びた木）では危険       |
+
+> 📖 **このセクションで登場した用語**
+>
+> - **BFS（幅優先探索）**：キューを使って「今いる階層を全部処理してから次の階層へ」進む方法
+> - **reverse**：配列の要素順を逆にするメソッド
+> - **unshift**：配列の先頭に要素を追加するメソッド。末尾追加（push）と違い O(n) のコストがかかる
+
+---
+
+# 4. 実装コード
+
+> 💡 **コードの大まかな構造（骨格）**
+>
+> 1. `root` が `null` なら空配列を即リターン（ガード節）
+> 2. キュー（＝行列）に `root` を入れて BFS 開始
+> 3. 各階層のノードを全て取り出しながら値を収集し、子ノードをキューへ追加
+> 4. 奇数階層（1, 3, 5…）なら収集した値を逆順にして結果に追加
+> 5. 全階層を処理し終えた結果配列を返す
+
+```typescript
+function zigzagLevelOrder(root: TreeNode | null): number[][] {
+    // ── ガード節 ────────────────────────────────────────────────
+    // root が null（空ツリー）なら即座に空配列を返す。
+    // 後続の処理でノードへアクセスして null 参照エラーが起きるのを防ぐため。
+    if (root === null) return [];
+
+    // ── 結果格納用の配列 ─────────────────────────────────────────
+    // 各階層の値の配列を順に格納していく。最終的にこれを返す。
+    const result: number[][] = [];
+
+    // ── キュー（待ち行列）の初期化 ───────────────────────────────
+    // キューとは「先に入れたものが先に出る（FIFO）」データ構造。
+    // レジの行列と同じイメージで、最初にルートノードを並ばせる。
+    const queue: TreeNode[] = [root];
+
+    // ── BFS メインループ ─────────────────────────────────────────
+    // キューが空になるまで繰り返す。
+    // 「キューが空 = 未処理のノードがなくなった」ことを意味する。
+    while (queue.length > 0) {
+        // 現在の階層にいるノード数を確定させる。
+        // ループ中にキューへ子ノードを追加していくため、
+        // 「今の階層のノード数」をループ開始時点で固定しておく必要がある。
+        const levelSize: number = queue.length;
+
+        // この階層のノード値を格納する一時配列。
+        // 後で偶奇に応じて逆順にするため、先に全値を収集する。
+        const levelValues: number[] = [];
+
+        // ── 現在の階層を全て処理する ───────────────────────────────
+        for (let i = 0; i < levelSize; i++) {
+            // キューの先頭からノードを取り出す。
+            // shift() は配列の先頭を取り出す操作（BFS の「先入れ先出し」を実現）。
+            // ここで取り出すのは必ず TreeNode（null が入ることはない）
+            // のでアサーション（!）で TypeScript に伝える。
+            const node = queue.shift()!;
+
+            // 現在ノードの値を収集する。
+            // ジグザグ処理は後でまとめて行うため、ここでは単純に追加。
+            levelValues.push(node.val);
+
+            // 左の子ノードが存在すれば次の階層用にキューへ追加する。
+            // null チェックをしてから追加することで、
+            // null をキューに入れて後続処理がクラッシュするのを防ぐ。
+            if (node.left !== null) queue.push(node.left);
+
+            // 右の子ノードも同様にキューへ追加する。
+            if (node.right !== null) queue.push(node.right);
+        }
+
+        // ── ジグザグ処理（偶奇による方向切り替え）──────────────────
+        // result.length は「今まで完了した階層数」と等しい。
+        //   - result.length が偶数（0, 2, 4…）→ 左→右（そのまま）
+        //   - result.length が奇数（1, 3, 5…）→ 右→左（逆順）
+        // reverse() は配列を破壊的に逆順にする。levelValues は
+        // この後使わないので破壊的操作で問題ない。
+        if (result.length % 2 === 1) {
+            levelValues.reverse();
+        }
+
+        // 処理済み階層の値を最終結果に追加する。
+        result.push(levelValues);
+    }
+
+    // 全階層を処理した結果を返す。
+    return result;
+}
+```
+
+---
+
+# 5. 動作トレース
+
+入力: `root = [3, 9, 20, null, null, 15, 7]`
+
+```
+【ツリーの形状】
+        3          ← 階層 0（偶数 → 左→右）
+       / \
+      9   20       ← 階層 1（奇数 → 右→左）
+         /  \
+        15   7     ← 階層 2（偶数 → 左→右）
+
+┌─────────────────────────────────────────────────────────┐
+│ Step 0: 初期状態                                         │
+│   queue   = [Node(3)]                                   │
+│   result  = []                                          │
+└─────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────┐
+│ Step 1: 階層 0 を処理（result.length=0 → 偶数 → そのまま）│
+│   levelSize  = 1                                        │
+│   取り出し   : Node(3) → levelValues = [3]              │
+│   子を追加   : queue = [Node(9), Node(20)]              │
+│   偶数階層   : reverse しない → [3]                     │
+│   result     = [[3]]                                    │
+└─────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────┐
+│ Step 2: 階層 1 を処理（result.length=1 → 奇数 → 逆順）  │
+│   levelSize  = 2                                        │
+│   取り出し   : Node(9)  → levelValues = [9]             │
+│               Node(20) → levelValues = [9, 20]         │
+│   子を追加   : Node(9) の子は null / Node(20) の子追加  │
+│               queue = [Node(15), Node(7)]               │
+│   奇数階層   : reverse → [20, 9]                        │
+│   result     = [[3], [20, 9]]                           │
+└─────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────┐
+│ Step 3: 階層 2 を処理（result.length=2 → 偶数 → そのまま）│
+│   levelSize  = 2                                        │
+│   取り出し   : Node(15) → levelValues = [15]            │
+│               Node(7)  → levelValues = [15, 7]         │
+│   子を追加   : 子は全て null → queue = []               │
+│   偶数階層   : reverse しない → [15, 7]                  │
+│   result     = [[3], [20, 9], [15, 7]]                  │
+└─────────────────────────────────────────────────────────┘
+
+✅ queue が空になったのでループ終了
+🎉 最終出力: [[3], [20, 9], [15, 7]]
+```
+
+---
+
+# LeetCode 提出コード（最終版）
+
+```typescript
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 58.12 MB
+// Beats 22.08%
+function zigzagLevelOrder(root: TreeNode | null): number[][] {
+    if (root === null) return [];
+
+    const result: number[][] = [];
+    const queue: TreeNode[] = [root];
+
+    while (queue.length > 0) {
+        const levelSize: number = queue.length;
+        const levelValues: number[] = [];
+
+        for (let i = 0; i < levelSize; i++) {
+            const node = queue.shift()!;
+            levelValues.push(node.val);
+            if (node.left !== null) queue.push(node.left);
+            if (node.right !== null) queue.push(node.right);
+        }
+
+        if (result.length % 2 === 1) levelValues.reverse();
+        result.push(levelValues);
+    }
+
+    return result;
+}
+```
+
+---
+
+# TypeScript固有の最適化観点
+
+### `shift()!` の Non-null アサーション（`!`）について
+
+TypeScriptは `Array.shift()` の戻り値型を `T | undefined` と判断します。しかし今回は `levelSize = queue.length` でサイズを固定し、`levelSize` 回だけループしているため、**ループ内で `shift()` が `undefined` を返すことは構造上ありえません**。そのため `!` アサーション（＝「私が保証するのでundefinedチェックは不要」と伝える記号）を使うことで型エラーを回避しています。
+
+```typescript
+// TypeScript がエラーを出す（T | undefined を node: TreeNode に代入できない）
+const node: TreeNode = queue.shift(); // ❌
+
+// ! で「undefined にならないことを私が保証する」と伝える
+const node = queue.shift()!; // ✅
+```
+
+### なぜ `const` で `queue` を宣言するか
+
+`const` は「変数自体の再代入禁止」であり、配列の中身の変更（`push` / `shift`）は許されます。これにより「`queue` という名前が別の配列に差し替えられる」バグを防ぎつつ、BFSの操作は問題なく行えます。
+
+---
+
+> 📖 **このセクションで登場した用語**
+>
+> - **BFS（幅優先探索）**：キューを使って階層ごとに探索する方法。パン屋のレジ行列のように「先に来た人が先に処理される」
+> - **キュー（Queue）**：先入れ先出し（FIFO）のデータ構造。`push` で末尾追加、`shift` で先頭取り出し
+> - **ガード節（早期リターン）**：関数の冒頭でエラーや特殊ケースをチェックし、すぐ `return` する書き方。後続のコードをシンプルに保てる
+> - **Non-null アサーション（`!`）**：TypeScriptに「この値は絶対に null/undefined ではない」と伝える記号。使いすぎると危険なので、「構造上あり得ない」と証明できる場合のみ使う
+> - **reverse()**：配列を破壊的に（元の配列を直接変えて）逆順にするメソッド
+> - **shift()**：配列の先頭要素を取り出すメソッド。取り出した要素は配列から削除される