diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Python.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Python.md
new file mode 100644
index 0000000..9538949
--- /dev/null
+++ b/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,454 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Python (CPython 3.11.10)
+> 適用ルールセット: 共通5ルール + Python固有4ルール
+> 参照ファイル: references/common.md + references/python.md
+
+---
+
+# 1. 問題分析
+
+> 💡 **この問題は一言で言うと**「二分木を階層ごとに読み取り、偶数階層は左→右、奇数階層は右→左と**交互にジグザグで**値を収集する問題」です。
+
+## Pythonで解く際に特に気をつけるべきCPython特有の注意点
+
+BFS（幅優先探索）の実装では **キューの先頭から要素を取り出す操作が頻繁に発生**します。`list.pop(0)` は先頭要素を取り出しますが、これは残り全要素を1つずつ左にシフトするため **O(n) のコスト**がかかります。CPythonの `collections.deque`（両端キュー）を使えば `popleft()` で **O(1)** を実現できます。ノード数が最大2000という制約でも、deque を使う習慣をつけることが Python で BFS を書く上での鉄則です。
+
+## 競技プログラミング視点
+
+- 全ノードを一度だけ訪問 → 時間計算量（＝処理にかかる手間の目安）**O(n)**
+- 追加で使うメモリは各階層の値リスト + deque → 空間計算量 **O(n)**
+- `deque.popleft()` で先頭取り出しを O(1) に保つ
+- `list.reverse()` はインプレース操作（＝新しいリストを作らず元のリストを直接逆順にする操作）なので余計なメモリを使わない
+
+## 業務開発視点
+
+- `Optional[TreeNode]`（＝`TreeNode` または `None` のどちらかを表す型）で `root` の型を明示 → pylance（VSCodeの静的型チェッカー）がエラーを実行前に検出できる
+- `root` が `None` のケースを最初にガード節（＝早期リターン）で弾く
+- 各階層の「反転するかどうか」の判定ロジックを変数で分離し、意図を読みやすくする
+
+## Python特有分析
+
+| データ構造の選択    | 理由                                                       |
+| ------------------- | ---------------------------------------------------------- |
+| `collections.deque` | BFS のキュー。`popleft()` が O(1)（`list.pop(0)` は O(n)） |
+| `list`              | 各階層の値収集用。末尾への `append` が O(1)                |
+| `list.reverse()`    | ジグザグ反転。インプレース操作でメモリ節約                 |
+
+> 📖 **このセクションで登場した用語**
+>
+> - **CPython**：最も広く使われる Python の実装。C言語で書かれており、`deque` などの組み込みデータ構造の操作がC言語レベルで高速に動く
+> - **BFS（幅優先探索）**：木やグラフを「階層ごと」に左から右へ探索する方法。キューを使う
+> - **インプレース操作**：新しいオブジェクトを作らず、既存のオブジェクトを直接書き換える操作。`list.reverse()` がその例
+> - **O(1)**：入力の大きさに関わらず、常に一定の時間で済む操作（最速）
+> - **ガード節**：関数の冒頭で特殊なケースをチェックし、すぐ `return` する書き方
+
+---
+
+# 2. 採用アルゴリズムと根拠
+
+> 💡 同じ問題でも解き方は複数あります。Python では「**C実装の関数を使えるか**」と「**不要なメモリアロケーションが起きるか**」がパフォーマンスに大きく影響するため、その観点も含めて比較します。
+
+| アプローチ                                 | 時間計算量 | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用  | CPython最適化 | 備考                                           |
+| ------------------------------------------ | ---------- | ---------- | ---------------- | ------ | ------------------- | ------------- | ---------------------------------------------- |
+| **BFS + deque + reverse**                  | O(n)       | O(n)       | 低               | ★★★    | `collections.deque` | ✅ 適         | **採用**。最もシンプルで高速                   |
+| BFS + deque + `collections.deque` 両端挿入 | O(n)       | O(n)       | 中               | ★★☆    | `collections.deque` | ✅ 適         | `appendleft` で挿入方向を制御。やや複雑        |
+| DFS（再帰）+ 各階層に append               | O(n)       | O(n)+O(h)  | 中               | ★★☆    | なし                | ⚠️ 再帰コスト | 再帰深度がノード数に依存。CPython は再帰が遅い |
+| list を使った BFS（pop(0) 使用）           | O(n²)      | O(n)       | 低               | ★★★    | なし                | ❌ 非最適     | `pop(0)` が O(n) で最悪 O(n²) になる           |
+
+- **選択理由**: `deque` + `reverse()` はどちらもCPythonのC実装。Pythonインタープリタを介さずに処理されるため最速。コードの意図も「BFSで収集 → 奇数階層を逆順」と直読できて可読性も最高
+- **DFSを選ばなかった理由**: CPythonのデフォルト再帰上限は1000。ノード数最大2000の制約では `sys.setrecursionlimit` が必要になり、スタックオーバーフローのリスクも残る
+- **`pop(0)` を選ばなかった理由**: `list.pop(0)` はO(n)のコスト。全ノード分繰り返すと O(n²) になり、`deque` の使用と比べて明確に非効率
+
+> 📖 **このセクションで登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **C実装**：Python コードではなく、内部でC言語で実装された関数。Pure Python より大幅に高速
+> - **再帰上限**：CPython はデフォルトで関数が1000回以上入れ子になるとエラー（RecursionError）を出す
+
+---
+
+# 3. 実装パターン
+
+> 💡 **コードの大まかな構造（骨格）**
+>
+> 1. `root` が `None` なら空リストを即リターン（ガード節）
+> 2. `deque` にルートノードを入れて BFS 開始
+> 3. 各階層のノード数を固定し、全ノードを取り出して値を収集・子を deque に追加
+> 4. `len(result) % 2 == 1` が奇数なら `.reverse()` で逆順にする
+> 5. 全階層の結果リストを返す
+
+---
+
+## 【業務開発版を使う場面】
+
+チームで長期間メンテナンスするプロダクションコードに向きます。型ヒントと docstring を充実させることで、後から読んだ人がコードの意図を理解しやすくなります。pylance による静的型チェックも通るため、実行前にバグを検出できます。
+
+```python
+from collections import deque
+from typing import Optional
+
+
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        """
+        二分木のジグザグレベルオーダー走査を返す。
+
+        Args:
+            root: 二分木のルートノード（None の場合は空ツリー）
+
+        Returns:
+            各階層の値リストを格納した 2次元リスト。
+            偶数階層は左→右、奇数階層は右→左の順。
+
+        Complexity:
+            Time:  O(n) - 全ノードを一度だけ訪問
+            Space: O(n) - deque と結果リストの合計
+        """
+        # ── ガード節 ─────────────────────────────────────────────
+        # root が None（空ツリー）なら即座に空リストを返す。
+        # 後続の処理でノード属性にアクセスして AttributeError が起きるのを防ぐ。
+        if root is None:
+            return []
+
+        # ── 結果格納用リストの初期化 ──────────────────────────────
+        # 各階層の値リストを順に格納していく。最終的にこれを返す。
+        result: list[list[int]] = []
+
+        # ── deque（両端キュー）の初期化 ──────────────────────────
+        # BFS のキューには必ず collections.deque を使う。
+        # list.pop(0) は先頭を取り出すたびに残り全要素を左シフトするため O(n) のコスト。
+        # deque.popleft() は C実装 で O(1)。全ノード分繰り返すと差は歴然になる。
+        queue: deque[TreeNode] = deque([root])
+
+        # ── BFS メインループ ──────────────────────────────────────
+        # queue が空になるまで繰り返す。
+        # 「queue が空 = 未処理のノードがなくなった」ことを意味する。
+        while queue:
+
+            # 現在の階層にいるノード数を「今」確定させる。
+            # ループ中に子ノードを queue に追加していくので、
+            # 「今の階層のノード数」をループ開始時点で固定しておかないと
+            # 次の階層のノードまで同じ階層として処理してしまう。
+            level_size: int = len(queue)
+
+            # この階層のノード値を格納する一時リスト。
+            # あらかじめサイズが分かっているので list を選択（deque より高速）。
+            level_values: list[int] = []
+
+            # ── 現在の階層を全て処理する ──────────────────────────
+            for _ in range(level_size):
+
+                # queue の先頭からノードを取り出す。
+                # deque.popleft() は O(1)。list.pop(0) と違ってシフト操作が発生しない。
+                node: TreeNode = queue.popleft()
+
+                # 現在ノードの値を収集する。
+                # ジグザグ処理は後でまとめて行うため、ここでは単純に追加。
+                # list.append() は O(1)（C実装）のため高速。
+                level_values.append(node.val)
+
+                # 左の子ノードが存在すれば次の階層用に queue の末尾に追加する。
+                # Python の if は None・0・空リストなどを False と判定するが、
+                # TreeNode は自前クラスなのでここでは `is not None` で明示的にチェック。
+                if node.left is not None:
+                    queue.append(node.left)
+
+                # 右の子ノードも同様に queue の末尾に追加する。
+                if node.right is not None:
+                    queue.append(node.right)
+
+            # ── ジグザグ処理（偶奇による方向切り替え）────────────
+            # len(result) は「今まで完了した階層数」と等しい。
+            #   len(result) が偶数（0, 2, 4…）→ 左→右（そのまま）
+            #   len(result) が奇数（1, 3, 5…）→ 右→左（逆順）
+            #
+            # 最適化前（新しいリストを作る方法）:
+            #   level_values = level_values[::-1]  ← 新しいリストを生成するため O(k) のアロケーション発生
+            #
+            # 最適化後（インプレース操作）:
+            #   level_values.reverse()  ← 同じリストを直接逆順にする。新しいリストを作らないので高速
+            #
+            # なぜ reverse() が速いか: C言語実装のインプレース操作。
+            # メモリアロケーション（＝新しいメモリ領域を確保する操作）が発生しない。
+            if len(result) % 2 == 1:
+                level_values.reverse()
+
+            # 処理済み階層の値リストを最終結果に追加する。
+            result.append(level_values)
+
+        # 全階層を処理した結果を返す。
+        return result
+```
+
+---
+
+## 【競技プログラミング版を使う場面】
+
+LeetCode など制限時間内に正解を出すことが目的のコードに向きます。型ヒントを最小限に抑え、エラーハンドリングを省略した上でロジックを短く書いています。
+
+### 非推奨: 誤例（コピー禁止）
+
+> ⚠️ **競技版の補足**: 下記の内包表記版は `queue.popleft()` で値を取り出してしまうため子ノードの追加が別途必要であり、未完成のままでは動作しません。実際の提出では業務版のコードがそのままシンプルで使いやすいため、競技の場でも業務版を推奨します。
+
+```python
+from collections import deque
+from typing import Optional
+
+
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        # root が None なら即リターン
+        if not root:
+            return []
+
+        result, queue = [], deque([root])
+
+        while queue:
+            # 今の階層のノード数を固定して値を収集
+            level = [queue.popleft().val for _ in range(len(queue))]
+            # 奇数階層（result に奇数個が溜まっているとき）は逆順
+            if len(result) % 2 == 1:
+                level.reverse()
+            result.append(level)
+
+            # 子ノードを追加（内包表記で手短に書く）
+            # ※この版では子の追加を別途行う必要がある（下記参照）
+
+        return result
+```
+
+---
+
+# 4. 動作トレース
+
+入力: `root = [3, 9, 20, null, null, 15, 7]`
+
+```
+【ツリーの形状】
+        3          ← 階層 0（len(result)=0 → 偶数 → 左→右）
+       / \
+      9   20       ← 階層 1（len(result)=1 → 奇数 → 右→左）
+         /  \
+        15   7     ← 階層 2（len(result)=2 → 偶数 → 左→右）
+
+┌──────────────────────────────────────────────────────────────┐
+│ 初期状態                                                      │
+│   queue   = deque([Node(3)])                                  │
+│   result  = []                                                │
+└──────────────────────────────────────────────────────────────┘
+
+┌──────────────────────────────────────────────────────────────┐
+│ Step 1: 階層 0 の処理（len(result)=0 → 偶数 → そのまま）      │
+│                                                              │
+│   level_size = 1                                             │
+│   ─ popleft() → Node(3) を取り出す                           │
+│       val=3 → level_values = [3]                             │
+│       left=Node(9)  → queue.append(Node(9))                  │
+│       right=Node(20) → queue.append(Node(20))                │
+│                                                              │
+│   len(result)=0 → 偶数 → reverse() しない                    │
+│   result.append([3])                                         │
+│                                                              │
+│   queue  = deque([Node(9), Node(20)])                        │
+│   result = [[3]]                                             │
+└──────────────────────────────────────────────────────────────┘
+
+┌──────────────────────────────────────────────────────────────┐
+│ Step 2: 階層 1 の処理（len(result)=1 → 奇数 → 逆順）         │
+│                                                              │
+│   level_size = 2                                             │
+│   ─ popleft() → Node(9)  → level_values = [9]               │
+│       left=None, right=None → queue への追加なし             │
+│   ─ popleft() → Node(20) → level_values = [9, 20]           │
+│       left=Node(15) → queue.append(Node(15))                 │
+│       right=Node(7)  → queue.append(Node(7))                 │
+│                                                              │
+│   len(result)=1 → 奇数 → level_values.reverse()             │
+│   level_values = [20, 9]（インプレースで変更・メモリ節約）    │
+│   result.append([20, 9])                                     │
+│                                                              │
+│   queue  = deque([Node(15), Node(7)])                        │
+│   result = [[3], [20, 9]]                                    │
+└──────────────────────────────────────────────────────────────┘
+
+┌──────────────────────────────────────────────────────────────┐
+│ Step 3: 階層 2 の処理（len(result)=2 → 偶数 → そのまま）      │
+│                                                              │
+│   level_size = 2                                             │
+│   ─ popleft() → Node(15) → level_values = [15]              │
+│   ─ popleft() → Node(7)  → level_values = [15, 7]           │
+│       全て子なし → queue への追加なし                         │
+│                                                              │
+│   len(result)=2 → 偶数 → reverse() しない                    │
+│   result.append([15, 7])                                     │
+│                                                              │
+│   queue  = deque([])  ← 空!                                  │
+│   result = [[3], [20, 9], [15, 7]]                           │
+└──────────────────────────────────────────────────────────────┘
+
+✅ while queue: → queue が空 → ループ終了
+🎉 最終出力: [[3], [20, 9], [15, 7]]
+```
+
+---
+
+# Python最適化ポイント まとめ
+
+```python
+# ❌ 最適化前：list.pop(0) は O(n)
+queue = [root]
+node = queue.pop(0)   # 残り全要素をシフトするため遅い
+
+# ✅ 最適化後：deque.popleft() は O(1)
+from collections import deque
+queue = deque([root])
+node = queue.popleft()  # C実装・シフト操作なし
+# なぜ速いか: deque は内部的に双方向リンクリストで実装されており、
+#            先頭要素の取り出しにシフト操作が不要。C言語レベルで処理される。
+
+# ❌ 最適化前：スライスで新しいリストを作る
+level_values = level_values[::-1]  # 新しいリストをアロケーション
+
+# ✅ 最適化後：インプレース操作で既存リストを逆順にする
+level_values.reverse()  # 新しいリストを作らない。C実装で高速。
+# なぜ速いか: メモリアロケーションが発生しない。同じリストを直接書き換えるだけ。
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`collections.deque`**：前からも後ろからも O(1) で追加・取り出しができる「両端開きの箱」。`list` の先頭操作（O(n)）と比べて BFS のキューに最適
+> - **`popleft()`**：`deque` の先頭要素を O(1) で取り出すメソッド。`list.pop(0)` の O(n) と対比される
+> - **`list.reverse()`**：リストをインプレースで逆順にする C実装メソッド。スライス `[::-1]` より速くメモリ節約にもなる
+> - **インプレース操作**：新しいオブジェクトを作らず、既存のオブジェクトを直接書き換える操作。メモリアロケーションが発生しない
+> - **`Optional[TreeNode]`**：`TreeNode` または `None` のどちらかであることを表す型ヒント。pylance が `None` の可能性を検出してくれる
+> - **ガード節**：関数の先頭で特殊ケースをチェックし `return` する書き方。後続の処理をシンプルに保てる
+> - **メモリアロケーション**：新しいメモリ領域を動的に確保する操作。頻繁に発生すると速度が落ちる
+
+## バグの精査
+
+競技プログラミング版の問題箇所を特定します。
+
+```python
+# ❌ バグのあるコード
+while queue:
+    level = [queue.popleft().val for _ in range(len(queue))]  # ← 問題1 & 2
+```
+
+**問題1：子ノードをキューに追加していない**
+内包表記の中で `popleft()` でノードを取り出していますが、そのノードの `.left` / `.right` を `queue` に追加する処理が**完全に抜け落ちています**。次の階層のノードがキューに入らないため、ルートと第1階層しか処理されません。
+
+**問題2：`len(queue)` の評価タイミング**
+`range(len(queue))` は内包表記の**開始時点**で一度だけ評価されます。しかし問題1のせいで子が追加されないため、2テストケース目以降（第2階層以降が存在する木）で誤った結果になります。
+
+---
+
+## 修正版
+
+```python
+# Runtime 0 ms
+# Beats 100.00%
+# Memory 19.45 MB
+# Beat 60.53%
+
+from collections import deque
+from typing import Optional
+
+
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        # root が None なら即リターン（空ツリーのガード節）
+        if not root:
+            return []
+
+        # result: 全階層の結果、queue: BFS 用の両端キュー
+        result: list[list[int]] = []
+        queue: deque[TreeNode] = deque([root])
+
+        while queue:
+            # 現在の階層のノード数を先に固定する。
+            # ここで固定しないと、子を追加するたびに len(queue) が変わり
+            # 「今の階層」と「次の階層」の境界が崩れてしまう。
+            level_size = len(queue)
+            level: list[int] = []
+
+            for _ in range(level_size):
+                # popleft() は deque の先頭を O(1) で取り出す（list.pop(0) の O(n) と違う）
+                node = queue.popleft()
+                level.append(node.val)
+
+                # ✅ 修正箇所：子ノードを必ずキューに追加する
+                # 元の競技版ではここが丸ごと抜けていたため
+                # 第2階層以降が処理されなかった。
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+
+            # 奇数階層（result に奇数個溜まっているとき）は逆順にする。
+            # reverse() はインプレース操作なので新しいリストを作らず高速。
+            if len(result) % 2 == 1:
+                level.reverse()
+
+            result.append(level)
+
+        return result
+```
+
+---
+
+## 動作トレース（修正版での確認）
+
+入力: `root = [3, 9, 20, null, null, 15, 7]`
+
+```
+初期状態: queue = deque([Node(3)])、result = []
+
+─ Step 1: 階層 0（len(result)=0 → 偶数 → そのまま）─────────────
+  level_size = 1
+  ループ1回目:
+    popleft() → Node(3)、level = [3]
+    ✅ Node(9)  を queue に追加
+    ✅ Node(20) を queue に追加
+  reverse しない → result = [[3]]
+  queue = deque([Node(9), Node(20)])
+
+─ Step 2: 階層 1（len(result)=1 → 奇数 → 逆順）────────────────
+  level_size = 2
+  ループ1回目:
+    popleft() → Node(9)、level = [9]
+    子なし → queue 変化なし
+  ループ2回目:
+    popleft() → Node(20)、level = [9, 20]
+    ✅ Node(15) を queue に追加
+    ✅ Node(7)  を queue に追加
+  reverse() → [20, 9] → result = [[3], [20, 9]]
+  queue = deque([Node(15), Node(7)])
+
+─ Step 3: 階層 2（len(result)=2 → 偶数 → そのまま）────────────
+  level_size = 2
+  ループ1回目: popleft() → Node(15)、level = [15]
+  ループ2回目: popleft() → Node(7)、 level = [15, 7]
+  reverse しない → result = [[3], [20, 9], [15, 7]]
+  queue = deque([])  ← 空
+
+✅ while queue: が False → ループ終了
+🎉 出力: [[3], [20, 9], [15, 7]]
+```
+
+---
+
+## 業務版との差分まとめ
+
+| 観点          | 業務開発版                                        | 修正後の競技版                             |
+| ------------- | ------------------------------------------------- | ------------------------------------------ |
+| 型ヒント      | `deque[TreeNode]`・`list[list[int]]` など完全付与 | `result`・`queue` のみ付与（pylance 対応） |
+| null チェック | `is not None` で明示的                            | `if node.left:` で省略形                   |
+| docstring     | あり（Args / Returns / Complexity）               | なし                                       |
+| ロジック      | 完全同一 ✅                                       | 完全同一 ✅                                |
+
+> 📖 **このセクションで登場した用語**
+>
+> - **インプレース操作**：新しいオブジェクトを作らず元のオブジェクトを直接書き換える操作。`list.reverse()` がその例でメモリ節約になる
+> - **ガード節**：関数の先頭で特殊ケースをチェックし即 `return` する書き方。後続の処理をシンプルに保てる
+> - **`deque.popleft()`**：先頭要素を O(1) で取り出す操作。`list.pop(0)` の O(n) と対比される
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Rust.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Rust.md
new file mode 100644
index 0000000..9d6d6eb
--- /dev/null
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Rust.md	
@@ -0,0 +1,370 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Rust
+> 適用ルールセット: 共通5ルール + Rust固有5ルール
+> 参照ファイル: references/common.md + references/rust.md
+
+---
+
+# 1. 問題の分析
+
+> 💡 **この問題は一言で言うと**「`Rc<RefCell<TreeNode>>` という複雑な所有権構造を持つ二分木を、階層ごとにジグザグ（左→右、右→左と交互）に読み取る問題」です。
+
+## Rustで解く際に特に気をつけるべき点
+
+LeetCodeのRust版では木のノードが `Option<Rc<RefCell<TreeNode>>>` という型で定義されています。これはTypeScript版の `TreeNode | null` と比べてかなり複雑に見えますが、**Rustの所有権ルールを守りながら「複数の箇所から同じノードを参照できる」ことを安全に実現するための仕組み**です。この型の読み解き方が実装の鍵になります。
+
+## 競技プログラミング視点での分析
+
+- `VecDeque`（＝両端から追加・取り出しができる効率的なキュー）を使ったBFSで全ノードを一度だけ訪問する → 時間計算量 **O(n)**
+- 追加のヒープアロケーション（＝動的にメモリを確保する操作）は各階層の結果格納用 `Vec` のみ → 空間計算量 **O(n)**
+- `Rc::clone()` は参照カウント（＝何箇所から参照されているかの数）をインクリメントするだけなので、データのコピーは発生しない
+
+## 業務開発視点での分析
+
+- `root` が `None`（空ツリー）のケースは最初にガード節で早期リターン
+- `borrow()` で `RefCell` の中身を安全に読み取り、パニックのリスクを最小限に抑える
+- 各階層の反転判定は `result.len() % 2 == 1` という明示的な条件で可読性を確保
+
+## Rust特有の考慮点
+
+| 概念         | この問題での使われ方                                                                   |
+| ------------ | -------------------------------------------------------------------------------------- |
+| `Option<T>`  | ノードの子が存在するかどうかを `None` / `Some(...)` で安全に表現                       |
+| `Rc<T>`      | キューへのノード格納時に所有権を複製せず参照カウントを増やすだけ                       |
+| `RefCell<T>` | 実行時に `borrow()` して中身を読み取る（コンパイル時に読み取り専用を保証できないため） |
+| `VecDeque`   | `push_back` / `pop_front` が O(1) の効率的キュー                                       |
+
+> 📖 **このセクションで登場した用語**
+>
+> - **所有権**：値を「誰が管理するか」をコンパイル時に決めるRust独自の仕組み。メモリを自動で安全に管理できる
+> - **`Rc<T>`**：Reference Counted（参照カウント）の略。複数の場所から同じ値を「共同所有」できる仕組み。本の「図書館への登録」で何人が参照しているか管理するイメージ
+> - **`RefCell<T>`**：通常Rustは「借用はコンパイル時にチェック」するが、`RefCell` は実行時にチェックする特殊な箱。ツリーのように再帰構造で内部を変更する際に必要
+> - **`VecDeque`**：配列の先頭・末尾どちらにも O(1) で追加・取り出しできるキュー構造
+
+---
+
+# 2. アルゴリズムアプローチ比較
+
+> 💡 同じ問題でも解き方は複数あります。Rustでは「**ヒープアロケーションの回数**」と「**所有権の移動が発生するか**」が実装難易度に直結するため、その観点も含めて比較します。
+
+| アプローチ                           | 時間計算量 | 空間計算量 | Rust実装コスト | 安全性 | 可読性 | 備考                                          |
+| ------------------------------------ | ---------- | ---------- | -------------- | ------ | ------ | --------------------------------------------- |
+| **BFS + 偶奇で reverse**             | O(n)       | O(n)       | **低**         | 高     | ⭐高   | `VecDeque` + `reverse()` のみ。所有権移動なし |
+| BFS + `VecDeque` の先頭/末尾交互挿入 | O(n)       | O(n)       | 中             | 高     | 中     | `push_front` / `push_back` 切り替え。やや複雑 |
+| DFS（深さ優先）+ 各階層に `push`     | O(n)       | O(n)+O(h)  | 中             | 高     | 中     | 再帰スタックが高さ h 分追加。偏った木で危険   |
+| ブルートフォース（全格納後に整理）   | O(n²)      | O(n)       | 低             | 高     | 低     | `reverse` が各階層で O(k)。非効率             |
+
+> 📖 **このセクションで登場した用語**
+>
+> - **時間計算量**：ノード数に対して処理の手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **ヒープアロケーション**：`Vec` や `Rc` などの動的メモリ確保操作。スタックより低速
+> - **再帰スタック**：関数が自分自身を呼び出すたびに積まれるメモリ。深い木では溢れる可能性がある（スタックオーバーフロー）
+
+---
+
+# 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**: **BFS（`VecDeque` キュー）+ 偶数階層はそのまま / 奇数階層は `.reverse()`**
+
+| 観点                                | 理由                                                                                 |
+| ----------------------------------- | ------------------------------------------------------------------------------------ |
+| 計算量                              | 全ノードを一度だけ訪問する O(n)。`reverse()` は各階層サイズ O(k) で合計 O(n)         |
+| 所有権との相性                      | `Rc::clone()` で参照カウントを増やすだけ。データのコピーや所有権移動が不要           |
+| 可読性                              | 「BFSで階層を読んで偶奇で反転する」という意図がコードから直読できる                  |
+| DFSを選ばなかった理由               | 制約「ノード数最大2000」でも偏った木（一方向に連なる木）では再帰深度が2000に達し危険 |
+| 先頭/末尾交互挿入を選ばなかった理由 | `push_front` と `push_back` の切り替えロジックが複雑になり、バグの温床になりやすい   |
+
+## Rust特有の最適化ポイント
+
+`Rc::clone()` はデータをコピーせず、参照カウンタ（内部の整数）を +1 するだけなので **O(1) コスト**。JavaやPythonのオブジェクト参照と似ていますが、Rustはカウントがゼロになった瞬間に自動でメモリを解放します（ガベージコレクタ不要）。
+
+> 📖 **このセクションで登場した用語**
+>
+> - **ゼロコスト抽象化**：`.iter()` や `.reverse()` などの便利な書き方をしても、手書きの低レベルコードと同等の速さになるRustの特性
+> - **参照カウント**：「今何箇所からこの値が参照されているか」を数える整数。0になった時点でメモリを解放する仕組み
+> - **スタックオーバーフロー**：再帰呼び出しが深くなりすぎてスタックメモリが溢れるエラー
+
+---
+
+# 4. 実装コード
+
+> 💡 **コードの大まかな構造（骨格）**
+>
+> 1. `root` が `None` なら空の `Vec` を即リターン（ガード節）
+> 2. `VecDeque` にルートノードを入れて BFS 開始
+> 3. 現在階層のノード数を固定し、全ノードを取り出して値を収集・子をキューに追加
+> 4. `result.len() % 2 == 1` が奇数なら `reverse()` で逆順にする
+> 5. 全階層を処理した `result` を返す
+
+```rust
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+impl Solution {
+    pub fn zigzag_level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
+
+        // ── ガード節 ──────────────────────────────────────────────
+        // root が None（空ツリー）なら即座に空の Vec を返す。
+        // Rustの Option<T> は「値があるかないかを型で表現する箱」。
+        // JavaやPythonの null 参照と違い、None かどうかを確認しないと
+        // 中身にアクセスできないようになっている（コンパイルが通らない）ため安全。
+        let root = match root {
+            None => return vec![],  // None なら空配列を即返す
+            Some(node) => node,     // Some なら中身の Rc<RefCell<TreeNode>> を取り出す
+        };
+
+        // ── 結果格納用の Vec の初期化 ─────────────────────────────
+        // 各階層の値の Vec を順に格納していく最終結果。
+        let mut result: Vec<Vec<i32>> = Vec::new();
+
+        // ── VecDeque（両端キュー）の初期化 ──────────────────────
+        // VecDeque は配列の先頭・末尾どちらにも O(1) で操作できるデータ構造。
+        // 通常の Vec で先頭取り出し（.remove(0)）を行うと O(n) のコストがかかるため、
+        // BFS のキューには必ず VecDeque を使うのが Rust の慣習。
+        // Rc<RefCell<TreeNode>> を格納する。Rc::clone() は参照カウントを +1 するだけ
+        // なので、データのコピーは発生しない（コストは O(1)）。
+        let mut queue: VecDeque<Rc<RefCell<TreeNode>>> = VecDeque::new();
+        queue.push_back(root); // ルートノードをキューの末尾に追加
+
+        // ── BFS メインループ ──────────────────────────────────────
+        // キューが空になるまで繰り返す。
+        // 「キューが空 = 未処理のノードがなくなった」ことを意味する。
+        while !queue.is_empty() {
+
+            // 現在の階層にいるノード数を「今」確定させる。
+            // ループ中に子ノードをキューへ追加していくので、
+            // 「今の階層のノード数」をループ開始時点で固定しておかないと
+            // 次の階層のノードまで同じ階層として処理してしまう。
+            let level_size = queue.len();
+
+            // この階層のノード値を格納する一時 Vec。
+            // 偶奇判定後に逆順にするため、先に全値を収集する。
+            let mut level_values: Vec<i32> = Vec::with_capacity(level_size);
+            // with_capacity は「この階層のノード数分だけ先にメモリを確保」する。
+            // push するたびに再アロケーション（メモリ拡張）が起きるのを防ぐための最適化。
+
+            // ── 現在の階層を全て処理する ──────────────────────────
+            for _ in 0..level_size {
+
+                // キューの先頭からノードを取り出す。
+                // pop_front() は Option<T> を返すが、
+                // level_size 回のループ内では必ず Some(_) が返ることが
+                // 構造上保証されているため unwrap() してよい。
+                // （queue が空になるのは level_size 回取り出した後なので）
+                let node_rc = queue.pop_front().unwrap();
+
+                // RefCell の borrow() で中身を読み取る。
+                // Rust の借用チェッカーはコンパイル時に「同時に複数の可変参照がない」を
+                // チェックするが、Rc<RefCell<T>> の場合は実行時チェックになる。
+                // borrow() は「読み取り専用の参照」を返す（書き込みは borrow_mut()）。
+                // node_ref はこのスコープを抜けると自動で解放されるため安全。
+                let node_ref = node_rc.borrow();
+
+                // 現在ノードの値を収集する。
+                // ジグザグ処理は後でまとめて行うため、ここでは単純に追加。
+                level_values.push(node_ref.val);
+
+                // 左の子ノードが存在すれば次の階層用にキューへ追加する。
+                // if let は「Option の中身が Some だった場合だけ処理する」書き方。
+                // Rc::clone() はデータをコピーせず参照カウントを +1 するだけ（O(1) コスト）。
+                if let Some(left) = node_ref.left.as_ref() {
+                    queue.push_back(Rc::clone(left));
+                }
+
+                // 右の子ノードも同様にキューへ追加する。
+                if let Some(right) = node_ref.right.as_ref() {
+                    queue.push_back(Rc::clone(right));
+                }
+
+                // node_ref はここでスコープを抜け、borrow() が解放される。
+                // これにより RefCell の実行時借用チェックが正常にリセットされる。
+            }
+
+            // ── ジグザグ処理（偶奇による方向切り替え）────────────
+            // result.len() は「今まで完了した階層数」と等しい。
+            //   result.len() が偶数（0, 2, 4…）→ 左→右（そのまま）
+            //   result.len() が奇数（1, 3, 5…）→ 右→左（逆順）
+            // .reverse() は Vec を「破壊的に（元の Vec を直接変えて）」逆順にする。
+            // level_values はこの後使わないので、新しい Vec を作るより効率的。
+            if result.len() % 2 == 1 {
+                level_values.reverse();
+            }
+
+            // 処理済み階層の値を最終結果に追加する。
+            result.push(level_values);
+        }
+
+        // 全階層を処理した結果を返す。
+        // Rust では関数の最後に書いた式が戻り値になる（セミコロンなし）。
+        result
+    }
+}
+```
+
+---
+
+# 5. 動作トレース
+
+入力: `root = [3, 9, 20, null, null, 15, 7]`
+
+```
+【ツリーの形状】
+        3          ← 階層 0（result.len()=0 → 偶数 → 左→右）
+       / \
+      9   20       ← 階層 1（result.len()=1 → 奇数 → 右→左）
+         /  \
+        15   7     ← 階層 2（result.len()=2 → 偶数 → 左→右）
+
+┌─────────────────────────────────────────────────────────────────┐
+│ 初期状態                                                         │
+│   queue   = [Rc(Node{val:3})]                                   │
+│   result  = []                                                  │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│ Step 1: 階層 0 の処理（result.len()=0 → 偶数 → そのまま）        │
+│                                                                 │
+│   level_size = 1                                                │
+│   ─ pop_front() → Node{val:3} を取り出す                        │
+│       borrow() → val=3 を読み取る → level_values = [3]         │
+│       left=Some(Node{9})  → Rc::clone して queue に push_back  │
+│       right=Some(Node{20}) → Rc::clone して queue に push_back │
+│       borrow() スコープ終了 → RefCell 解放                      │
+│                                                                 │
+│   result.len()=0 → 偶数 → reverse しない                        │
+│   result.push([3])                                              │
+│                                                                 │
+│   queue  = [Rc(Node{9}), Rc(Node{20})]                         │
+│   result = [[3]]                                                │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│ Step 2: 階層 1 の処理（result.len()=1 → 奇数 → 逆順）           │
+│                                                                 │
+│   level_size = 2                                                │
+│   ─ pop_front() → Node{val:9}  → level_values = [9]            │
+│       left=None, right=None → queue への追加なし                │
+│   ─ pop_front() → Node{val:20} → level_values = [9, 20]        │
+│       left=Some(Node{15}) → push_back                          │
+│       right=Some(Node{7})  → push_back                         │
+│                                                                 │
+│   result.len()=1 → 奇数 → reverse() → [20, 9]                  │
+│   result.push([20, 9])                                          │
+│                                                                 │
+│   queue  = [Rc(Node{15}), Rc(Node{7})]                         │
+│   result = [[3], [20, 9]]                                       │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│ Step 3: 階層 2 の処理（result.len()=2 → 偶数 → そのまま）        │
+│                                                                 │
+│   level_size = 2                                                │
+│   ─ pop_front() → Node{val:15} → level_values = [15]           │
+│       left=None, right=None → 追加なし                          │
+│   ─ pop_front() → Node{val:7}  → level_values = [15, 7]        │
+│       left=None, right=None → 追加なし                          │
+│                                                                 │
+│   result.len()=2 → 偶数 → reverse しない → [15, 7]              │
+│   result.push([15, 7])                                          │
+│                                                                 │
+│   queue  = [] (空)                                              │
+│   result = [[3], [20, 9], [15, 7]]                              │
+└─────────────────────────────────────────────────────────────────┘
+
+✅ while !queue.is_empty() が false → ループ終了
+🎉 最終出力: [[3], [20, 9], [15, 7]]
+```
+
+---
+
+# `Rc<RefCell<TreeNode>>` の仕組みを図解
+
+LeetCodeのRust版ツリーで使われるこの型は「3層の入れ子」になっています。
+
+```
+Option<  Rc<  RefCell<TreeNode>  >  >
+  │       │        │
+  │       │        └─ TreeNode の実データを包む「実行時借用チェック箱」
+  │       │           → borrow() で読み取り参照を取り出せる
+  │       │
+  │       └─ 参照カウントポインタ
+  │           → Rc::clone() で所有者を増やせる（データコピーなし）
+  │           → 全所有者がいなくなると自動でメモリ解放
+  │
+  └─ ノードが存在するか(Some)しないか(None) の表現
+      → None = 子ノードなし（null の安全な代替）
+```
+
+| 他言語                           | Rustでの対応                | 違い                                    |
+| -------------------------------- | --------------------------- | --------------------------------------- |
+| Java: `TreeNode node = null;`    | `Option<Rc<...>>` の `None` | null 参照エラーがコンパイル時に防がれる |
+| Java: `node.left`                | `node_ref.left.as_ref()`    | `borrow()` が必要（実行時安全チェック） |
+| Python: オブジェクト参照のコピー | `Rc::clone()`               | データコピーなし・参照カウント +1 のみ  |
+
+---
+
+# LeetCode 提出コード（最終版）
+
+```rust
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 2.18 MB
+// Beats 97.14%
+
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+impl Solution {
+    pub fn zigzag_level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
+        let root = match root {
+            None => return vec![],
+            Some(node) => node,
+        };
+
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut queue: VecDeque<Rc<RefCell<TreeNode>>> = VecDeque::new();
+        queue.push_back(root);
+
+        while !queue.is_empty() {
+            let level_size = queue.len();
+            let mut level_values: Vec<i32> = Vec::with_capacity(level_size);
+
+            for _ in 0..level_size {
+                let node_rc = queue.pop_front().unwrap();
+                let node_ref = node_rc.borrow();
+                level_values.push(node_ref.val);
+
+                if let Some(left) = node_ref.left.as_ref() {
+                    queue.push_back(Rc::clone(left));
+                }
+                if let Some(right) = node_ref.right.as_ref() {
+                    queue.push_back(Rc::clone(right));
+                }
+            }
+
+            if result.len() % 2 == 1 {
+                level_values.reverse();
+            }
+            result.push(level_values);
+        }
+
+        result
+    }
+}
+```
+
+---
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`VecDeque`**：先頭・末尾どちらにも O(1) で追加・取り出しができるキュー。レジの行列と同じ「先に来た人が先に出る（FIFO）」構造
+> - **`Rc<T>`**：複数箇所から同じ値を共同所有できるスマートポインタ。`Rc::clone()` はデータをコピーせず参照カウントを +1 するだけ
+> - **`RefCell<T>`**：通常コンパイル時の借用チェックを、実行時チェックに切り替える特殊な箱。ツリー構造のような複雑な場合に使う
+> - **`borrow()`**：`RefCell<T>` の中身を読み取り専用で借用するメソッド。スコープを抜けると自動で解放される
+> - **`if let Some(x) = option`**：`Option` の中身が `Some` だった場合だけ処理する構文。`match` の省略形
+> - **`with_capacity(n)`**：`Vec` を作る際に n 個分のメモリを先に確保する。追加のたびに再アロケーションが起きるのを防ぐ最適化
+> - **`unwrap()`**：`Option<T>` や `Result<T, E>` の中身を取り出す。`None` / `Err` の場合はパニックするため、「絶対に `Some` が来る」と構造的に保証できる場合のみ使う
+> - **`.reverse()`**：`Vec` を破壊的に（元のデータを直接変更して）逆順にするメソッド
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Typescript.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Typescript.md
new file mode 100644
index 0000000..c441cd8
--- /dev/null
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Typescript.md	
@@ -0,0 +1,275 @@
+> 🎯 **[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²) | O(n)        | 低           | 高       | 低     | 各階層でreverseなら全体O(n)。unshift(先頭挿入)を繰り返すとO(n²)に悪化 |
+
+> 💡 **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];
+    // パフォーマンス最適化のため、queue.shift() (O(n)) を使わず head インデックス (O(1)) を用いる
+    let head = 0;
+
+    // ── BFS メインループ ─────────────────────────────────────────
+    // 未処理のノードがなくなるまで（head が queue の長さに追いつくまで）繰り返す。
+    while (head < queue.length) {
+        // 現在の階層にいるノード数を確定させる。
+        // ループ中にキューへ子ノードを追加していくため、
+        // 「今の階層のノード数」をループ開始時点で固定しておく必要がある。
+        const levelSize: number = queue.length - head;
+
+        // この階層のノード値を格納する一時配列。
+        // 後で偶奇に応じて逆順にするため、先に全値を収集する。
+        const levelValues: number[] = [];
+
+        // ── 現在の階層を全て処理する ───────────────────────────────
+        for (let i = 0; i < levelSize; i++) {
+            // キューの先頭からノードを取り出す。
+            // head インデックスを進めることで O(1) でのデキューを実現。
+            const node = queue[head++];
+
+            // 現在ノードの値を収集する。
+            // ジグザグ処理は後でまとめて行うため、ここでは単純に追加。
+            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)]                                   │
+│   head    = 0                                           │
+│   result  = []                                          │
+└─────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────┐
+│ Step 1: 階層 0 を処理（result.length=0 → 偶数 → そのまま）│
+│   levelSize  = 1                                        │
+│   取り出し   : queue[0] = Node(3) → head は 1 に        │
+│               levelValues = [3]                         │
+│   子を追加   : queue = [Node(3), Node(9), Node(20)]     │
+│   偶数階層   : reverse しない → [3]                     │
+│   result     = [[3]]                                    │
+└─────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────┐
+│ Step 2: 階層 1 を処理（result.length=1 → 奇数 → 逆順）  │
+│   levelSize  = 2                                        │
+│   取り出し   : queue[1] = Node(9) → head は 2 に        │
+│               queue[2] = Node(20) → head は 3 に       │
+│               levelValues = [9, 20]                     │
+│   子を追加   : Node(9) の子は null / Node(20) の子追加  │
+│               queue = [Node(3), Node(9), Node(20),      │
+│                        Node(15), Node(7)]               │
+│   奇数階層   : reverse → [20, 9]                        │
+│   result     = [[3], [20, 9]]                           │
+└─────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────┐
+│ Step 3: 階層 2 を処理（result.length=2 → 偶数 → そのまま）│
+│   levelSize  = 2                                        │
+│   取り出し   : queue[3] = Node(15) → head は 4 に       │
+│               queue[4] = Node(7) → head は 5 に        │
+│               levelValues = [15, 7]                     │
+│   子を追加   : 子は全て null                            │
+│               queue (要素追加なし、長さ5のまま)         │
+│   偶数階層   : reverse しない → [15, 7]                  │
+│   result     = [[3], [20, 9], [15, 7]]                  │
+└─────────────────────────────────────────────────────────┘
+
+✅ head === queue.length (5 === 5) となったのでループ終了
+🎉 最終出力: [[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];
+    let head = 0;
+
+    while (head < queue.length) {
+        const levelSize: number = queue.length - head;
+        const levelValues: number[] = [];
+
+        for (let i = 0; i < levelSize; i++) {
+            const node = queue[head++];
+            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固有の最適化観点
+
+### O(1) デキューと型安全性について
+
+TypeScriptにおいて配列へのインデックスアクセス（例：`queue[head]`）の戻り値はコンパイラ設定によって `T | undefined` と解釈されることがありますが、今回は `head < queue.length` および `levelSize = queue.length - head` によってループ回数を厳密に制御しているため、**ループ内で `queue[head++]` が `undefined` を返すことは構造上ありえません**。
+
+また、`Array.shift()` は先頭要素を取り出した後に残りの全要素を左にシフトするため O(n) のコストがかかりますが、先頭インデックス `head` を進める方式（`queue[head++]`）を採用することで、要素のシフトを回避し O(1) でのデキュー（取り出し）を実現しています。これにより、アルゴリズム全体が O(n^2) に悪化することを防いでいます。
+
+### なぜ `const` で `queue` を宣言するか
+
+`const` は「変数自体の再代入禁止」であり、配列の中身の変更（`queue` への `push`）や、`head` ポインタ（インデックス）を進めることによる要素へのアクセスは許されます。これにより「`queue` という名前が別の配列に差し替えられる」バグを防ぎつつ、`shift` を使わないBFSループ内での操作は問題なく行えます。
+
+---
+
+> 📖 **このセクションで登場した用語**
+>
+> - **BFS（幅優先探索）**：キューを使って階層ごとに探索する方法。パン屋のレジ行列のように「先に来た人が先に処理される」
+> - **キュー（Queue）**：先入れ先出し（FIFO）のデータ構造。TypeScript では配列とインデックス（`head`）を使って擬似的に高速なキューを実現できる
+> - **ガード節（早期リターン）**：関数の冒頭でエラーや特殊ケースをチェックし、すぐ `return` する書き方。後続のコードをシンプルに保てる
+> - **O(1) / O(n)**：処理の計算量を示す表記。O(1) はデータ量に関わらず一定時間、O(n) はデータ量に比例して時間が増えることを意味する
+> - **reverse()**：配列を破壊的に（元の配列を直接変えて）逆順にするメソッド
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README.md
new file mode 100644
index 0000000..00c2f8a
--- /dev/null
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README.md	
@@ -0,0 +1,344 @@
+# Binary Tree Zigzag Level Order Traversal — BFS + 偶奇反転で階層をジグザグに読む
+
+---
+
+## 目次（Table of Contents）
+
+- [Overview](#overview)
+- [Algorithm](#algorithm)
+- [Complexity](#complexity)
+- [Implementation](#implementation)
+- [Optimization](#optimization)
+
+---
+
+<h2 id="overview">Overview</h2>
+
+> 💡 **この問題は一言で言うと**、「二分木を階層ごとに読み取り、偶数階層は左→右・奇数階層は右→左と **交互にジグザグ** で値を収集する問題」です。
+
+### 問題の要件
+
+- **入力**：二分木のルートノード `root`（`None` の場合は空ツリー）
+- **出力**：各階層の値を格納した 2次元リスト `list[list[int]]`
+    - 階層 0（ルート）：左→右
+    - 階層 1：右→左
+    - 階層 2：左→右
+    - … 以降交互に繰り返す
+
+### なぜこの問題が難しいのか
+
+「木を階層ごとに読む（幅優先探索＝BFS）」自体は典型的な手法ですが、**「偶数・奇数階層で読む向きを変える」という追加条件**をどこで・どのように処理するかがポイントです。向きを間違えると隣接する階層の境界が崩れ、Wrong Answer になります。また Python では **キューの実装の選び方（`list` か `deque` か）** がパフォーマンスに直結します。
+
+### 制約
+
+| 項目       | 値                       |
+| ---------- | ------------------------ |
+| ノード数   | 0 以上 2000 以下         |
+| ノードの値 | &minus;100 以上 100 以下 |
+
+> 📖 **この章で登場した用語**
+>
+> - **BFS（幅優先探索）**：木やグラフを「階層ごと」に左から右へ順番に訪問する探索方法。キュー（待ち行列）を使う
+> - **ルートノード**：木の最上位にあるノード（頂点）。木全体の出発点
+> - **制約**：入力として与えられる値の範囲や条件のこと。例：「ノード数は 0 以上 2000 以下」
+
+### 図解
+
+> 💡 **Mermaid フローチャートの読み方**：
+>
+> - **長方形 `[]`**：何らかの処理を行うステップ
+> - **ひし形 `{}`**：条件を判定する分岐点（Yes/No に分かれる）
+> - **矢印 `-->`**：処理の流れの方向
+
+#### フローチャート
+
+この図は `zigzagLevelOrder` 関数全体の処理の流れを表しています。上から下へ読み進めてください。
+
+```mermaid
+flowchart TD
+  Start[Start zigzagLevelOrder]
+  Start --> NullCheck{root is None?}
+  NullCheck -- Yes --> RetEmpty[Return empty list]
+  NullCheck -- No --> Init[Init result list and deque with root]
+  Init --> WhileCheck{queue is not empty?}
+  WhileCheck -- No --> RetResult[Return result]
+  WhileCheck -- Yes --> FixSize[Fix level_size = len queue]
+  FixSize --> InnerLoop[Pop node from front of deque]
+  InnerLoop --> Collect[Append node.val to level_values]
+  Collect --> AddLeft{node.left exists?}
+  AddLeft -- Yes --> PushLeft[Append left child to deque]
+  AddLeft -- No --> AddRight{node.right exists?}
+  PushLeft --> AddRight
+  AddRight -- Yes --> PushRight[Append right child to deque]
+  AddRight -- No --> MoreNodes{More nodes in this level?}
+  PushRight --> MoreNodes
+  MoreNodes -- Yes --> InnerLoop
+  MoreNodes -- No --> OddCheck{len result is odd?}
+  OddCheck -- Yes --> Rev[Reverse level_values in place]
+  OddCheck -- No --> AppendLevel[Append level_values to result]
+  Rev --> AppendLevel
+  AppendLevel --> WhileCheck
+```
+
+**主要なノードの意味：**
+
+- `NullCheck`：空ツリーを最初に弾くガード節。`None` なら即リターン
+- `FixSize`：現在の階層のノード数を確定するステップ。ここで固定しないと次の階層のノードが混入する
+- `InnerLoop`：deque の先頭からノードを O(1) で取り出す（`popleft()`）
+- `OddCheck`：`len(result) % 2 == 1` で奇数階層かを判定。奇数なら逆順にする
+
+---
+
+#### データフロー図
+
+この図は `root = [3, 9, 20, null, null, 15, 7]` を入力したとき、データがどのように変換されるかを表しています。
+
+```mermaid
+graph LR
+  subgraph Input
+    A[root Node 3]
+  end
+  subgraph Level0
+    A --> B[deque Node3]
+    B --> C[level_values 3]
+    C --> D[result 3]
+  end
+  subgraph Level1
+    D --> E[deque Node9 Node20]
+    E --> F[level_values 9 20]
+    F --> G[reverse to 20 9]
+    G --> H[result 3 then 20 9]
+  end
+  subgraph Level2
+    H --> I[deque Node15 Node7]
+    I --> J[level_values 15 7]
+    J --> K[result 3 then 20 9 then 15 7]
+  end
+```
+
+**主要な流れの説明：**
+
+- **Level0**：ルートノード 3 を deque から取り出し、値 `[3]` を収集。`len(result)=0` は偶数なので逆順にしない
+- **Level1**：ノード 9・20 を順に取り出し `[9, 20]` を収集。`len(result)=1` は奇数なので `reverse()` → `[20, 9]`
+- **Level2**：ノード 15・7 を順に取り出し `[15, 7]` を収集。`len(result)=2` は偶数なので逆順にしない
+
+---
+
+> 💡 **代表例でのトレース**：`root = [3, 9, 20, null, null, 15, 7]` を入力として各ノードを通過する様子
+
+```
+初期状態:
+  queue  = deque([Node(3)])
+  result = []
+
+─ Step 1: 階層 0（len(result)=0 → 偶数 → そのまま）─────────────
+  level_size = 1
+  popleft() → Node(3)、level_values = [3]
+  → Node(9)  を queue の末尾に追加
+  → Node(20) を queue の末尾に追加
+  len(result)=0 → 偶数 → reverse しない
+  result = [[3]]
+  queue  = deque([Node(9), Node(20)])
+
+─ Step 2: 階層 1（len(result)=1 → 奇数 → 逆順）────────────────
+  level_size = 2
+  popleft() → Node(9)、 level_values = [9]    （子なし）
+  popleft() → Node(20)、level_values = [9, 20]
+  → Node(15) を queue に追加
+  → Node(7)  を queue に追加
+  len(result)=1 → 奇数 → reverse() → [20, 9]
+  result = [[3], [20, 9]]
+  queue  = deque([Node(15), Node(7)])
+
+─ Step 3: 階層 2（len(result)=2 → 偶数 → そのまま）────────────
+  level_size = 2
+  popleft() → Node(15)、level_values = [15]   （子なし）
+  popleft() → Node(7)、 level_values = [15, 7]（子なし）
+  len(result)=2 → 偶数 → reverse しない
+  result = [[3], [20, 9], [15, 7]]
+  queue  = deque([])  ← 空
+
+while queue: → False → ループ終了
+最終出力: [[3], [20, 9], [15, 7]] ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **フローチャート**：処理の手順を図形と矢印で表したもの。ひし形＝条件分岐、長方形＝処理ステップ
+> - **データフロー図**：データがどのように変換・移動するかを示す図
+> - **サブグラフ**：フローチャートの中で関連する処理をグループ化した区画
+
+---
+
+<h2 id="algorithm">Algorithm</h2>
+
+### アルゴリズム要点（TL;DR）
+
+> 💡 **TL;DR**（Too Long; Didn't Read）とは「長くて読めない人向けの要約」という意味です。
+> ここでは「なんとなくこういう手順で解くんだな」というイメージを掴んでください。詳細は後の章で説明します。
+
+1. **`root` が `None` ならすぐ `[]` を返す**（ガード節＝特殊ケースを先に弾く処理）
+2. **`collections.deque` をキューとして使う**：`list.pop(0)` は O(n) コストがかかるため非効率。`deque.popleft()` は O(1) で取り出せる
+3. **各階層の開始時点でノード数を固定する**：ループ中に子ノードをキューへ追加していくため、「今の階層のノード数」を事前に確定しないと次の階層と混在してしまう
+4. **値を収集してから偶奇判定で逆順にする**：`list.reverse()` は元のリストを直接書き換える in-place 操作なので、新しいリストを作る `[::-1]` より高速
+5. **全階層を処理したら結果リストを返す**
+
+- **選択したデータ構造**：`collections.deque`（キュー）、`list`（各階層の値収集）
+- **時間計算量**：O(n)
+- **空間計算量**：O(n)
+
+> 📖 **この章で登場した用語**
+>
+> - **ガード節（早期リターン）**：関数の冒頭で特殊ケースをチェックし、すぐ `return` する書き方。後続の処理をシンプルに保てる
+> - **in-place 操作**：新しいメモリを確保せず、元のデータを直接書き換える操作。`list.reverse()` がその代表例
+> - **O(1)**：入力の大きさに関わらず、常に一定時間で完了する操作の意味
+> - **TL;DR**：「長すぎて読めない人向けの要約」を意味する略語
+
+### 正しさのスケッチ
+
+> 💡 「なぜこのアルゴリズムで必ず正しい答えが出るのか」の証明の道筋です。
+
+1. **BFSによる階層の分離**: `for _ in range(level_size)` ループによって、キューの先頭から現在階層のノードのみを正確にすべて取り出し、次の階層のノードが混ざることを防ぎます。この時点で、「階層ごとのデータ」は正しくグループ化されます。
+2. **偶奇の正確な判定**: `result` の長さは「すでに処理が終わった階層の数」と一致します。したがって、ルート（階層0）を処理しているときは `len(result) == 0`（偶数）、次の階層1を処理しているときは `len(result) == 1`（奇数）となり、これによって偶奇階層の判定を誤差なく行えます。
+3. **反転の適用**: 各階層の値を（まずは左から右へ）すべて `level_values` に収集しきった後で、上記の偶奇判定に基づいて `reverse()` を行います。キューに入れる時点（子ノードを left, right の順に入れる）では常に左から右へ巡回し、結果を保存する直前にだけ配列を逆順にするため、木を探索するロジック自体を複雑にすることなくジグザグの要件を満たせます。
+4. **有限性と停止**: 木のノード数は有限であり、各ノードはキューに一度だけ入り、一度だけ取り出されます。そのため、無限ループに陥ることなく O(n) で必ず停止します。
+
+---
+
+<h2 id="complexity">Complexity</h2>
+
+- **時間計算量（Time Complexity）：O(n)**
+    - 木の全てのノードをちょうど1回ずつキューに入れ、1回ずつ取り出します。各ノードでの処理（`popleft()`, 子ノードの `append()`, 値の取得）は O(1) です。
+    - 各階層で `reverse()` を行う場合がありますが、すべての階層のノード数の合計は n になるため、`reverse()` にかかる総時間も O(n) です。
+    - したがって、全体としての時間計算量は O(n) となります。
+- **空間計算量（Space Complexity）：O(n)**
+    - キューのサイズは、二分木の最大の幅（完全二分木の場合は葉の数 ≈ n/2）に等しくなります。これは最悪ケースで O(n) のメモリを消費します。
+    - また、最終的な結果配列 `result` も n 個の要素の値を保持するため O(n) のメモリを必要とします。
+    - したがって、全体としての空間計算量は O(n) となります。
+
+---
+
+<h2 id="implementation">Implementation</h2>
+
+### Python 実装
+
+業務で保守・運用しやすく、バグを防ぐことを重視した「業務コード版」です。型ヒントやエッジケース（特殊な入力）への安全な対応が含まれています。
+
+```python
+from collections import deque
+from typing import Optional
+
+# TreeNode は LeetCode 側で定義されている前提としますが、
+# 手元で動かす際のために型チェック時のみ読み込むように定義します。
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    class TreeNode:
+        val: int
+        left: Optional['TreeNode']
+        right: Optional['TreeNode']
+        def __init__(self, val=0, left=None, right=None) -> None: ...
+
+class Solution:
+    def zigzagLevelOrder(self, root: Optional['TreeNode']) -> list[list[int]]:
+        """
+        二分木を BFS で階層ごとに探索し、奇数階層（1, 3, ...）のみ逆順にして返す。
+        """
+        # 1. ガード節：空のツリーに対する処理
+        # root が None の場合、後続処理で属性アクセス (.val) をするとエラーになるため
+        # 早期に空のリストを返して関数を終了します。
+        if root is None:
+            return []
+
+        # 結果を格納する2次元リスト
+        result: list[list[int]] = []
+
+        # 2. キューの初期化
+        # 探索するノードを一時的に保持する待ち行列。最初は root のみを入れておきます。
+        queue = deque([root])
+
+        # 3. BFS メインループ
+        # キューに未処理のノードが残っている限りループを継続します。
+        while queue:
+            # 現在の階層に含まれるノード数を固定します。
+            # ループ内でキューに子ノードを追加していくため、ここで固定しないと
+            # 「次の階層のノード」まで今回処理してしまいます。
+            level_size = len(queue)
+
+            # 現在の階層の値を一時的に格納するリスト
+            level_values: list[int] = []
+
+            # 現在の階層の全ノードに対して処理を行います
+            for _ in range(level_size):
+                # キューの先頭からノードを取り出す (O(1) 操作)
+                node = queue.popleft()
+
+                # ノードの値を収集
+                level_values.append(node.val)
+
+                # 左の子が存在すればキューに追加
+                if node.left is not None:
+                    queue.append(node.left)
+
+                # 右の子が存在すればキューに追加
+                if node.right is not None:
+                    queue.append(node.right)
+
+            # 4. 偶奇判定と逆順化
+            # result の長さが「処理済みの階層数」を表します。
+            # 例えば result が空 (長さ 0) の時は階層 0 なので偶数です。
+            # 長さが奇数 (1, 3, 5...) の場合は、今収集したリストを逆順にします。
+            if len(result) % 2 == 1:
+                # [::-1] で新しいリストを作るよりも、元のリストを直接操作する
+                # reverse() の方がわずかにメモリ効率が良いです。
+                level_values.reverse()
+
+            # 5. 処理が完了した階層を最終結果に追加
+            result.append(level_values)
+
+        # 全ての階層の処理が完了したら結果を返します
+        return result
+```
+
+### エッジケースと検証観点
+
+> 💡 **エッジケース**：通常とは異なる極端な入力パターン。システムをクラッシュさせやすい。
+
+| ケース                   | 内容                           | 対応方法                                                                      |
+| ------------------------ | ------------------------------ | ----------------------------------------------------------------------------- |
+| `root = None`            | 空ツリー                       | 関数の先頭で `if root is None: return []` として早期リターンする。            |
+| 左または右に偏ったツリー | 全てのノードが一列に並んでいる | 階層サイズが常に1となり、奇数・偶数が毎回反転し続けるが、問題なく処理できる。 |
+| 1ノードのみ              | `root` だけが存在し子がいない  | 最初の `while` ループで1回だけ実行され、`[[root.val]]` を返す。               |
+| ノードの値が負の数       | `root.val < 0` など            | 値の正負はアルゴリズムの制御フローに影響を与えない。                          |
+
+### FAQ
+
+> 💡 よくある疑問とその回答
+
+- **Q: なぜ `len(result) % 2 == 1` で奇数階層と判定できるのですか？**
+    - A: `result` は処理が完了した階層を格納していくリストです。まだ1つも格納していない最初の階層（階層 0）を処理しているとき、`len(result)` は 0 です（偶数）。階層 0 の処理が終わって `result` に追加されると `len(result)` は 1 になります。次に階層 1 を処理するときには `len(result)` は 1（奇数）になります。つまり、`len(result)` は「現在処理している階層のインデックス（0番目から数えた番号）」と常に一致するため、これで偶奇を正しく判定できます。
+- **Q: 階層ごとに `deque` を作り直す方法はダメですか？**
+    - A: ダメではありませんが、メモリの確保と破棄が毎階層発生するため、1つの `deque` を使い回し、`level_size` を使って境界を区切る方が一般的に高速でメモリ効率も良いです。
+- **Q: 左から右へ探索するのではなく、奇数階層のときは右から左へ探索するようにキューに入れる順番を変えれば、`reverse()` しなくて済むのでは？**
+    - A: 可能ですが、コードが非常に複雑になります。「キューのどちら側から出し入れするか」「子を右・左どちらから追加するか」を階層ごとに切り替える必要があり（双方向キューを活用した蛇腹式のBFS）、バグを生みやすくなります。まずは「すべて左から右へ収集し、最後だけ `reverse()` する」というアプローチがシンプルで確実です。
+
+---
+
+<h2 id="optimization">Optimization</h2>
+
+### CPython 最適化ポイント
+
+> 💡 **Python 特有の言語仕様** を活かして、より安全・高速に書くためのコツです。
+
+1. **リストの先頭削除を避ける（`collections.deque` の利用）**:
+    - Python の標準リスト `list` は配列（連続したメモリ領域）として実装されています。
+    - `list.pop(0)` を行うと、先頭の要素を削除した後、残りのすべての要素を1つずつ前にずらす必要があり、**O(n) の時間**がかかります。
+    - これをループの中で繰り返すと、全体の計算量が O(n^2) に悪化してしまいます。
+    - `collections.deque`（両端キュー）は双方向連結リストとして実装されており、先頭からの削除 `popleft()` を **O(1)** で行えます。BFS を実装する際は、Python では必ず `deque` を使用してください。
+2. **インプレース（破壊的）な逆順化（`list.reverse()` vs `[::-1]`）**:
+    - リストを逆順にする方法として、スライス `[::-1]` もよく使われます。
+    - しかし、`[::-1]` は「逆順に並んだ**新しいリスト**をメモリ上に作成」します。
+    - 一方 `list.reverse()` は、新しいメモリ領域を確保せず、元のリストの要素の並びだけを直接書き換えます（インプレース操作）。
+    - BFS で各階層のリストが大きくなる場合、メモリの割り当てと解放（ガベージコレクション）のオーバーヘッドを避けるため、`reverse()` を使う方がわずかに高速でメモリ効率に優れます。
+3. **`is None` による明示的な Null チェック**:
+    - `if not node.left:` よりも `if node.left is not None:` の方が、意図が明確であり、処理系にとってもごく僅かですが判定が高速になる場合があります（Python において `None` はシングルトンであり、メモリアドレスの比較だけで済むため）。
+    - 特に「値が `0` のノード」などが存在する場合、`if not node.val:` と書いてしまうとバグになるため、オブジェクトの存在確認は `is None` または `is not None` を使う習慣が安全です。
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html
new file mode 100644
index 0000000..8d69d4f
--- /dev/null
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html	
@@ -0,0 +1,1809 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 103 – Binary Tree Zigzag Level Order Traversal</title>
+
+        <!-- Google Fonts -->
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;600&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+
+        <!-- Tailwind CSS -->
+        <script src="https://cdn.tailwindcss.com"></script>
+
+        <!-- React 18 -->
+        <script src="https://unpkg.com/react@18/umd/react.development.js"></script>
+        <script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"></script>
+
+        <!-- Babel Standalone -->
+        <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
+
+        <!-- Prism.js -->
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css"
+        />
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.css"
+        />
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.css"
+        />
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-python.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/copy-to-clipboard/prism-copy-to-clipboard.min.js"></script>
+
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+
+            /* Prism toolbar */
+            .code-toolbar > .toolbar .toolbar-item a,
+            .code-toolbar > .toolbar .toolbar-item button,
+            .code-toolbar > .toolbar .toolbar-item span {
+                background: #10b981 !important;
+                color: white !important;
+                border-radius: 6px !important;
+                padding: 3px 10px !important;
+                font-size: 12px !important;
+                border: none !important;
+                cursor: pointer !important;
+            }
+
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+
+            @keyframes fadeInUp {
+                from {
+                    opacity: 0;
+                    transform: translateY(16px);
+                }
+                to {
+                    opacity: 1;
+                    transform: translateY(0);
+                }
+            }
+            .fade-in-up {
+                animation: fadeInUp 0.5s ease both;
+            }
+
+            @keyframes pulse-border {
+                0%,
+                100% {
+                    box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.4);
+                }
+                50% {
+                    box-shadow: 0 0 0 6px rgba(16, 185, 129, 0);
+                }
+            }
+            .active-step {
+                animation: pulse-border 1.8s ease infinite;
+            }
+        </style>
+    </head>
+
+    <body class="bg-[linear-gradient(135deg,#f0fdf4_0%,#e0f2fe_100%)] min-h-screen">
+        <div class="max-w-5xl mx-auto px-4 py-10">
+            <!-- ═══════════════════════════════════════════════════════════
+       HEADER
+  ══════════════════════════════════════════════════════════════ -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.12)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)] fade-in-up"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >LeetCode 103</span
+                    >
+                    <span
+                        class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Medium</span
+                    >
+                    <span
+                        class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >BFS</span
+                    >
+                </div>
+
+                <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Binary Tree Zigzag Level Order Traversal
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    BFS（幅優先探索）+ 偶奇反転で O(n) 実装
+                </p>
+
+                <p
+                    class="mt-3 text-base text-teal-800 bg-white/60 rounded-xl px-4 py-2 inline-block"
+                >
+                    💡 一言で言うと：「二分木を階層ごとに、偶数階層は左→右・奇数階層は右→左と
+                    <strong>交互にジグザグ</strong> で値を収集する問題」
+                </p>
+
+                <nav class="flex flex-wrap gap-3 mt-6">
+                    <a
+                        href="#overview"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       1. OVERVIEW
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow fade-in-up">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <!-- 一言要約 -->
+                <div class="mb-5 p-4 rounded-xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-semibold text-base">
+                        💡
+                        この問題を一言で言うと：「二分木を<strong>階層ごと</strong>に読み取り、1階層おきに読む向きを反転させる問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2 leading-6">
+                        木の各階層（レベル）をキュー（待ち行列）で順番に処理し、偶数番目の階層は左→右、奇数番目の階層は右→左の順で値を収集します。
+                        最終的に各階層の値リストを2次元配列として返します。
+                    </p>
+                </div>
+
+                <!-- なぜ難しいか -->
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-semibold text-sm mb-2">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-600 text-sm space-y-2 list-disc list-inside leading-6">
+                        <li>
+                            「木を階層ごとに読む（BFS）」は典型的な手法ですが、<strong>偶数・奇数階層で読む向きを変える</strong>という追加条件をどこで処理するかがポイントです。
+                        </li>
+                        <li>
+                            階層の境界を正確に管理しないと、「今の階層」と「次の階層」のノードが混在してしまいます。<code
+                                class="bg-amber-100 px-1 rounded mono text-xs"
+                                >level_size</code
+                            >
+                            を事前に固定するのが鍵です。
+                        </li>
+                        <li>
+                            Pythonでは <strong>キューの実装の選び方</strong>（<code
+                                class="bg-amber-100 px-1 rounded mono text-xs"
+                                >list</code
+                            >
+                            か
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">deque</code>
+                            か）がパフォーマンスに直結します。
+                        </li>
+                    </ul>
+                </div>
+
+                <!-- 指標カード -->
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-6">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-base font-mono">O(n)</div>
+                        <div class="text-xs mt-1">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-base font-mono">O(n)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            collections.deque
+                        </div>
+                        <div class="text-xs mt-1">キュー実装</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            0 ≤ n ≤ 2000
+                        </div>
+                        <div class="text-xs mt-1">ノード数制約</div>
+                    </div>
+                </div>
+
+                <!-- 入出力例 -->
+                <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-5">
+                    <!-- Example 1 -->
+                    <div class="rounded-xl border-2 border-emerald-200 p-4 bg-emerald-50">
+                        <p class="text-emerald-700 font-bold text-sm mb-2">例 1</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[3,9,20,null,null,15,7]</div>
+                            <div>出力：[[3],[20,9],[15,7]]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            階層0→[3]（左→右）、階層1→[20,9]（右→左に反転）、階層2→[15,7]（左→右）
+                        </p>
+                    </div>
+                    <!-- Example 2 -->
+                    <div class="rounded-xl border-2 border-sky-200 p-4 bg-sky-50">
+                        <p class="text-sky-700 font-bold text-sm mb-2">例 2</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[1]</div>
+                            <div>出力：[[1]]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            ノードが1つだけなので、そのまま[[1]]を返す。
+                        </p>
+                    </div>
+                    <!-- Example 3 -->
+                    <div class="rounded-xl border-2 border-slate-200 p-4 bg-slate-50">
+                        <p class="text-slate-600 font-bold text-sm mb-2">例 3</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[]（空ツリー）</div>
+                            <div>出力：[]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            ガード節（root is None）で即座に空リストを返す。
+                        </p>
+                    </div>
+                </div>
+
+                <!-- 制約 -->
+                <div
+                    class="p-4 rounded-xl bg-slate-50 border border-slate-200 text-sm text-slate-700"
+                >
+                    <p class="font-semibold mb-2 text-slate-600">📌 制約</p>
+                    <ul class="list-disc list-inside space-y-1 text-xs leading-6">
+                        <li>ノード数：0 以上 2000 以下</li>
+                        <li>ノードの値：−100 以上 100 以下</li>
+                        <li>
+                            <code class="bg-slate-200 px-1 rounded mono">root</code> は
+                            <code class="bg-slate-200 px-1 rounded mono">None</code>
+                            の場合あり（空ツリー）
+                        </li>
+                    </ul>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       2. STEPS (React)
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       3. CODE
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <!-- コードの骨格 -->
+                <div class="mb-4 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>
+                            空ツリーのガード節 —
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >root is None</code
+                            >
+                            なら即
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs">[]</code> を返す
+                        </li>
+                        <li>
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            にルートノードを入れてキューを初期化する
+                        </li>
+                        <li>
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >while queue:</code
+                            >
+                            で階層ループ —
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs">level_size</code>
+                            を固定してから内側ループへ
+                        </li>
+                        <li>
+                            内側ループで値を収集し、子ノードをキューに追加。ループ後に偶奇判定で逆順にして結果へ追加する
+                        </li>
+                    </ol>
+                </div>
+
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+from collections import deque
+
+if TYPE_CHECKING:
+    class TreeNode:
+        val: int
+        left: Optional[TreeNode]
+        right: Optional[TreeNode]
+        def __init__(self, val=0, left=None, right=None) -&gt; None: ...
+
+
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -&gt; list[list[int]]:
+        # ── ガード節 ──────────────────────────────────────────────
+        # root が None（空ツリー）なら即座に空リストを返す。
+        # 後続処理で node.val へアクセスして AttributeError が起きるのを防ぐ。
+        if root is None:
+            return []
+
+        result: list[list[int]] = []
+
+        # ── deque（両端キュー）の初期化 ───────────────────────────
+        # list.pop(0) は O(n)、deque.popleft() は O(1)。
+        # 全ノード分繰り返すと list では O(n²) になってしまう。
+        queue: deque[TreeNode] = deque([root])
+
+        # ── BFS メインループ ──────────────────────────────────────
+        while queue:
+            # 「今の階層のノード数」をここで固定する。
+            # ループ中に子ノードをキューへ追加するため、固定しないと
+            # 今の階層と次の階層の境界が崩れてしまう。
+            level_size: int = len(queue)
+            level_values: list[int] = []
+
+            for _ in range(level_size):
+                # deque の先頭から O(1) で取り出す
+                node: TreeNode = queue.popleft()
+                level_values.append(node.val)
+
+                if node.left is not None:
+                    queue.append(node.left)
+                if node.right is not None:
+                    queue.append(node.right)
+
+            # ── ジグザグ処理（偶奇による方向切り替え）──────────────
+            # len(result) == 「完了済み階層数」 == 「現在の階層番号」
+            #   偶数（0,2,4…）→ 左→右（そのまま追加）
+            #   奇数（1,3,5…）→ 右→左（in-place で逆順にする）
+            # list.reverse() は新しいリストを作らない in-place 操作なので
+            # [::-1] よりメモリ効率・速度ともに優れる。
+            if len(result) % 2 == 1:
+                level_values.reverse()
+
+            result.append(level_values)
+
+        return result</code></pre>
+
+                <!-- 動作トレース -->
+                <div class="mt-4 p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        ▶ 入力例 [3,9,20,null,null,15,7] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs mono leading-6 overflow-x-auto whitespace-pre"
+                    >
+初期状態:
+  queue  = deque([Node(3)])
+  result = []
+
+─ 階層 0（len(result)=0 → 偶数 → そのまま）─────────────────
+  level_size = 1
+  popleft() → Node(3) → level_values = [3]
+    └ Node(9) と Node(20) をキューへ追加
+  0 % 2 == 0 → reverse しない
+  result = [[3]]   queue = deque([Node(9), Node(20)])
+
+─ 階層 1（len(result)=1 → 奇数 → 逆順）──────────────────────
+  level_size = 2
+  popleft() → Node(9)  → level_values = [9]       （子なし）
+  popleft() → Node(20) → level_values = [9, 20]
+    └ Node(15) と Node(7) をキューへ追加
+  1 % 2 == 1 → reverse() → level_values = [20, 9]
+  result = [[3],[20,9]]   queue = deque([Node(15), Node(7)])
+
+─ 階層 2（len(result)=2 → 偶数 → そのまま）─────────────────
+  level_size = 2
+  popleft() → Node(15) → level_values = [15]      （子なし）
+  popleft() → Node(7)  → level_values = [15, 7]   （子なし）
+  2 % 2 == 0 → reverse しない
+  result = [[3],[20,9],[15,7]]   queue = deque([]) ← 空
+
+while queue: → False → ループ終了
+最終出力: [[3], [20, 9], [15, 7]] ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       4. DIAGRAM (Mermaid)
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <!-- 読み方 -->
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-semibold text-sm mb-3">
+                        🗺️ フローチャートの読み方
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700">
+                        <div class="flex items-center gap-2">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-full bg-emerald-100 border-2 border-emerald-500 text-[10px] text-emerald-800 font-bold whitespace-nowrap"
+                                >開始</span
+                            >
+                            <span>丸角（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-lg bg-sky-100 border-2 border-sky-400 text-[10px] text-sky-900 whitespace-nowrap"
+                                >処理</span
+                            >
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-lg bg-amber-100 border-2 border-amber-400 text-[10px] text-amber-900 whitespace-nowrap"
+                                >◆ 条件</span
+                            >
+                            <span>◆ 四角（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 flex-wrap gap-y-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500 mr-1"></span
+                            ><span class="mr-3">緑＝はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-400 mr-1"></span
+                            ><span>赤＝いいえ</span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- React-rendered CSS Flowchart -->
+                <div id="diagram-root-fc"></div>
+
+                <!-- フロー追跡 -->
+                <div class="mt-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-semibold text-sm mb-3">
+                        🔎 入力例 [3,9,20,null,null,15,7] でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-2 list-decimal list-inside leading-7">
+                        <li>① 開始 → root は None でないので ② の「いいえ」経路へ</li>
+                        <li>③ 初期化：result=[]、queue=deque([Node(3)]) をセット</li>
+                        <li>④ while queue → キューに Node(3) があるので「はい」へ</li>
+                        <li>⑤ level_size=1 に固定。level_values=[] を用意</li>
+                        <li>
+                            ⑥ for ループ：Node(3) を popleft → level_values=[3]。Node(9)・Node(20)
+                            をキューへ追加。ループ終了
+                        </li>
+                        <li>
+                            ⑧ len(result)=0（偶数）→「いいえ」→ reverse せずそのまま append →
+                            result=[[3]]。④ に戻る
+                        </li>
+                        <li>
+                            ④ while → Node(9)・Node(20) あり。⑤ level_size=2。⑥ 両ノード処理 →
+                            level_values=[9,20]。Node(15)・Node(7) をキューへ
+                        </li>
+                        <li>
+                            ⑧ len(result)=1（奇数）→「はい」→ reverse() → level_values=[20,9] →
+                            append → result=[[3],[20,9]]
+                        </li>
+                        <li>
+                            同様に階層2を処理：level_values=[15,7]、len(result)=2（偶数）→ そのまま
+                            append → result=[[3],[20,9],[15,7]]
+                        </li>
+                        <li>
+                            ④ while → キューが空 →「いいえ」→ ⑨
+                            <code class="bg-slate-200 px-1 rounded mono text-xs"
+                                >return [[3],[20,9],[15,7]]</code
+                            >
+                            ✅
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       5. COMPLEXITY
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <!-- Big-O 早見表 -->
+                <div class="mb-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-semibold text-sm mb-3">
+                        📖 Big-O 記法の読み方（入力サイズ n
+                        が大きくなるにつれて処理時間がどう増えるかの目安）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-2 text-xs">
+                        <div class="text-center p-3 rounded-lg bg-emerald-100 text-emerald-800">
+                            <div class="font-bold mono text-base mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-sky-100 text-sky-800">
+                            <div class="font-bold mono text-base mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-amber-100 text-amber-800">
+                            <div class="font-bold mono text-base mb-1">O(n log n)</div>
+                            <div class="leading-5">
+                                n より少し多い<br /><span class="text-amber-600"
+                                    >例：ソートアルゴリズム</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-red-100 text-red-800">
+                            <div class="font-bold mono text-base mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-red-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- 計算量テーブル -->
+                <div class="overflow-x-auto mb-5">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]">
+                                <th class="text-left p-3 rounded-tl-xl font-bold text-teal-800">
+                                    種別
+                                </th>
+                                <th class="text-left p-3 font-bold text-teal-800">計算量</th>
+                                <th class="text-left p-3 rounded-tr-xl font-bold text-teal-800">
+                                    理由
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-b border-slate-100">
+                                <td class="p-3 font-semibold text-slate-700">時間計算量</td>
+                                <td class="p-3">
+                                    <span
+                                        class="mono font-bold text-emerald-700 bg-emerald-50 px-2 py-1 rounded"
+                                        >O(n)</span
+                                    >
+                                </td>
+                                <td class="p-3 text-slate-600">
+                                    全ノードを一度だけ訪問する。<code
+                                        class="bg-slate-100 px-1 rounded mono text-xs"
+                                        >reverse()</code
+                                    >
+                                    は各階層サイズ k に対して O(k) だが、全階層を合計すると O(n)
+                                </td>
+                            </tr>
+                            <tr class="border-b border-slate-100 bg-slate-50/50">
+                                <td class="p-3 font-semibold text-slate-700">空間計算量</td>
+                                <td class="p-3">
+                                    <span
+                                        class="mono font-bold text-sky-700 bg-sky-50 px-2 py-1 rounded"
+                                        >O(n)</span
+                                    >
+                                </td>
+                                <td class="p-3 text-slate-600">
+                                    deque
+                                    は最大で最も幅の広い階層のノード数を格納する。完全二分木では最大
+                                    n/2 ノード。result リストも最終的に n ノード分を格納する
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <!-- in-place vs Pure 比較 -->
+                <div class="mb-5 overflow-x-auto">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-slate-100">
+                                <th class="text-left p-3 font-bold text-slate-700">操作</th>
+                                <th class="text-left p-3 font-bold text-slate-700">コード</th>
+                                <th class="text-left p-3 font-bold text-slate-700">追加メモリ</th>
+                                <th class="text-left p-3 font-bold text-slate-700">速度</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-b border-slate-100 bg-emerald-50">
+                                <td class="p-3 font-semibold text-emerald-700">
+                                    ✅ in-place（採用）
+                                </td>
+                                <td class="p-3 mono text-xs">level.reverse()</td>
+                                <td class="p-3 text-slate-600">O(1)（なし）</td>
+                                <td class="p-3 text-slate-600">高速（C実装）</td>
+                            </tr>
+                            <tr class="border-b border-slate-100">
+                                <td class="p-3 font-semibold text-slate-500">❌ Pure（不採用）</td>
+                                <td class="p-3 mono text-xs">level[::-1]</td>
+                                <td class="p-3 text-slate-600">O(k)（新リスト生成）</td>
+                                <td class="p-3 text-slate-600">やや低速</td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <!-- なぜこの計算量か -->
+                <div class="p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        🔍 なぜこの計算量になるのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        BFS
+                        では各ノードをキューから<strong>1回だけ取り出し</strong>、その値を収集して子ノードを追加します。
+                        ノード数を n とすると、popleft・append・level_values.append はすべて O(1)
+                        なので合計 O(n)。
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">reverse()</code>
+                        は各階層のサイズ k に対して O(k) ですが、
+                        すべての階層のサイズの合計はちょうど n になるため、全体でも O(n)
+                        に収まります。 空間については、deque
+                        に同時に入るノードは「最も幅の広い階層」だけなので最大 O(n/2) = O(n) です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       6. GLOSSARY
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたときに参照してください。
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> BFS（幅優先探索）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木やグラフを「階層ごと・横方向に」順番に訪問する探索手法。キュー（待ち行列）を使って実装する。<br />
+                            <span class="text-slate-500">例え話：</span
+                            >マンションの1階を全室確認してから2階へ、2階を全室確認してから3階へ……と進むイメージ。深さ優先（DFS）とは逆のアプローチ。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> deque（両端キュー）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            が提供するデータ構造。先頭・末尾への追加・取り出しがどちらも
+                            O(1)（一定時間）で行える。<br />
+                            通常の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list</code> で
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">pop(0)</code
+                            >（先頭取り出し）をすると O(n) かかるため、BFS キューには必ず deque
+                            を使う。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            ガード節（早期リターン）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数の先頭で特殊ケース（空の入力・不正な値など）をチェックし、その場で
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">return</code>
+                            する書き方。<br />
+                            後続の処理をネストさせずに済み、コードをシンプルに保てる。この問題では
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >if root is None: return []</code
+                            >
+                            がそれにあたる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> in-place 操作
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            新しいメモリを確保せず、元のデータを直接書き換える操作。<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >list.reverse()</code
+                            >
+                            がその代表例。<br />
+                            対比：<code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >list[::-1]</code
+                            >
+                            は新しいリストを生成する（Pure 操作）。in-place
+                            の方が追加メモリを消費しない分、効率的。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> 不変条件
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件のこと。<br />
+                            この問題では「while ループの先頭で queue
+                            に現在の階層のノードだけが格納されている」ことが不変条件。<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >level_size</code
+                            >
+                            の固定がこれを保証する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> 完全二分木
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            全ての葉（子を持たないノード）が同じ深さにある最もバランスの取れた二分木。最下層の幅（ノード数）は全ノード数
+                            n の約半分（n/2）になる。<br />
+                            この問題の空間計算量 O(n) を考えるときに参考になる最悪ケース。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> キュー（Queue）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            「先に入れたものを先に取り出す」データ構造（FIFO: First In First
+                            Out）。<br />
+                            <span class="text-slate-500">例え話：</span
+                            >コンビニのレジの行列と同じ。先に並んだ人が先に処理される。BFS
+                            では「次に訪問すべきノード」をキューで管理する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> ルートノード
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木の最上位にある起点ノード（頂点）。木全体の出発点で、親を持たない唯一のノード。<br />
+                            BFS ではルートノードをキューに入れることで探索を開始する。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <!-- Footer -->
+            <footer class="text-center text-slate-400 text-xs pb-10">
+                LeetCode 103 · Binary Tree Zigzag Level Order Traversal · BFS + 偶奇反転
+            </footer>
+        </div>
+        <!-- /max-w-5xl -->
+
+        <!-- ═══════════════════════════════════════════════════════════
+     REACT STEPS COMPONENT
+══════════════════════════════════════════════════════════════ -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空ツリーのガード節',
+                    desc:
+                        '関数の先頭で root が None かどうかを確認し、空ツリーなら即座に [] を返します。' +
+                        'なぜなら、後続の処理では node.val や node.left などのノード属性にアクセスするため、None のまま進むと AttributeError が発生してしまうからです。' +
+                        '例）root = None のとき → if root is None: return [] でここで処理が終わる。',
+                    visual: 'guard',
+                    queue: '—（処理なし）',
+                    result: '[]',
+                },
+                {
+                    step: 2,
+                    title: 'deque の初期化',
+                    desc:
+                        'collections.deque にルートノードを入れて BFS キューを初期化します。' +
+                        'list.pop(0) は O(n) コストがかかるのに対し、deque.popleft() は常に O(1) で取り出せるため、全ノード数 n 分繰り返すと速度差が大きくなります。' +
+                        '例）root = Node(3) → queue = deque([Node(3)])、result = []',
+                    visual: 'init',
+                    queue: 'deque([Node(3)])',
+                    result: '[]',
+                },
+                {
+                    step: 3,
+                    title: 'level_size を固定する',
+                    desc:
+                        'while ループの先頭で level_size = len(queue) と書き、今の階層にいるノード数を変数に保存します。' +
+                        'ループ中に子ノードをキューへ追加していくため、固定しないと len(queue) が増え続けて「今の階層」と「次の階層」が混在してしまいます。' +
+                        '例）queue = deque([Node(9), Node(20)]) のとき → level_size = 2 で固定。',
+                    visual: 'fix_size',
+                    queue: 'deque([Node(9), Node(20)])',
+                    result: '[[3]]',
+                },
+                {
+                    step: 4,
+                    title: 'popleft() で値を収集',
+                    desc:
+                        'for _ in range(level_size): のループ内で queue.popleft() を呼び、今の階層のノードを順番に取り出して値を収集します。' +
+                        '左・右の子ノードが存在する場合は queue.append() でキューの末尾に追加します（次の階層の処理のため）。' +
+                        '例）popleft() → Node(9)、level_values=[9]。子なし。popleft() → Node(20)、level_values=[9,20]。Node(15)・Node(7) を追加。',
+                    visual: 'collect',
+                    queue: 'deque([Node(15), Node(7)])',
+                    result: '[[3]]（処理中）',
+                },
+                {
+                    step: 5,
+                    title: '偶奇判定でジグザグ反転',
+                    desc:
+                        'len(result) % 2 が 1（奇数）なら level_values.reverse() を呼んで値リストを逆順にします。' +
+                        'len(result) は「すでに完了した階層数」＝「現在処理中の階層番号」と一致するため、別途カウンタ変数を用意する必要がありません。' +
+                        '例）len(result)=1 → 1%2==1 → reverse() → [9,20] が [20,9] に変わる。',
+                    visual: 'reverse',
+                    queue: 'deque([Node(15), Node(7)])',
+                    result: '[[3],[20,9]]',
+                },
+                {
+                    step: 6,
+                    title: 'result.append して次の階層へ',
+                    desc:
+                        '処理済みの level_values を result.append() で追加し、while ループの先頭に戻って次の階層を処理します。' +
+                        'queue が空になったとき（全ノードを処理し終えたとき）while ループを抜け、result を返して終了します。' +
+                        '例）全階層処理後 → result = [[3],[20,9],[15,7]] を return する。',
+                    visual: 'done',
+                    queue: 'deque([])',
+                    result: '[[3],[20,9],[15,7]]',
+                },
+            ];
+
+            // ── 各ステップのビジュアル ─────────────────────────────────────────
+            function StepVisualization({ visual, step }) {
+                const nodeStyle = (color) => ({
+                    display: 'inline-flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: 40,
+                    height: 40,
+                    borderRadius: '50%',
+                    background: color,
+                    color: 'white',
+                    fontWeight: 'bold',
+                    fontSize: 14,
+                    margin: '0 6px',
+                    boxShadow: '0 2px 8px rgba(0,0,0,0.15)',
+                });
+
+                const queueNodes = (labels, colors) => (
+                    <div
+                        style={{ display: 'flex', alignItems: 'center', flexWrap: 'wrap', gap: 4 }}
+                    >
+                        {labels.map((l, i) => (
+                            <div key={i} style={nodeStyle(colors[i] || '#94a3b8')}>
+                                {l}
+                            </div>
+                        ))}
+                        {labels.length === 0 && (
+                            <span style={{ color: '#94a3b8', fontSize: 13 }}>（空）</span>
+                        )}
+                    </div>
+                );
+
+                const panels = {
+                    guard: (
+                        <div>
+                            <svg viewBox="0 0 320 90" style={{ width: '100%', maxWidth: 320 }}>
+                                <rect
+                                    x="10"
+                                    y="10"
+                                    width="140"
+                                    height="70"
+                                    rx="10"
+                                    fill="#fee2e2"
+                                    stroke="#ef4444"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="80"
+                                    y="38"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="13"
+                                    fill="#991b1b"
+                                    fontWeight="bold"
+                                >
+                                    root = None
+                                </text>
+                                <text
+                                    x="80"
+                                    y="60"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#b91c1c"
+                                >
+                                    空ツリー
+                                </text>
+                                <line
+                                    x1="155"
+                                    y1="45"
+                                    x2="195"
+                                    y2="45"
+                                    stroke="#64748b"
+                                    strokeWidth="1.8"
+                                    markerEnd="url(#sv-arrow)"
+                                />
+                                <defs>
+                                    <marker
+                                        id="sv-arrow"
+                                        markerWidth="8"
+                                        markerHeight="8"
+                                        refX="7"
+                                        refY="3"
+                                        orient="auto"
+                                        markerUnits="strokeWidth"
+                                    >
+                                        <path d="M0,0 L0,6 L7,3 z" fill="#64748b" />
+                                    </marker>
+                                </defs>
+                                <rect
+                                    x="198"
+                                    y="25"
+                                    width="105"
+                                    height="40"
+                                    rx="8"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="250"
+                                    y="43"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#065f46"
+                                    fontWeight="bold"
+                                >
+                                    return []
+                                </text>
+                            </svg>
+                        </div>
+                    ),
+                    init: (
+                        <div>
+                            <svg viewBox="0 0 320 100" style={{ width: '100%', maxWidth: 320 }}>
+                                <rect
+                                    x="10"
+                                    y="15"
+                                    width="120"
+                                    height="70"
+                                    rx="10"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="70"
+                                    y="40"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#065f46"
+                                    fontWeight="bold"
+                                >
+                                    Node(3)
+                                </text>
+                                <text
+                                    x="70"
+                                    y="62"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="11"
+                                    fill="#047857"
+                                >
+                                    ルートノード
+                                </text>
+                                <line
+                                    x1="135"
+                                    y1="50"
+                                    x2="168"
+                                    y2="50"
+                                    stroke="#64748b"
+                                    strokeWidth="1.8"
+                                    markerEnd="url(#sv-arrow2)"
+                                />
+                                <defs>
+                                    <marker
+                                        id="sv-arrow2"
+                                        markerWidth="8"
+                                        markerHeight="8"
+                                        refX="7"
+                                        refY="3"
+                                        orient="auto"
+                                        markerUnits="strokeWidth"
+                                    >
+                                        <path d="M0,0 L0,6 L7,3 z" fill="#64748b" />
+                                    </marker>
+                                </defs>
+                                <rect
+                                    x="170"
+                                    y="15"
+                                    width="140"
+                                    height="70"
+                                    rx="10"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="240"
+                                    y="38"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#1e3a5f"
+                                    fontWeight="bold"
+                                >
+                                    deque
+                                </text>
+                                <text
+                                    x="240"
+                                    y="60"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="11"
+                                    fill="#1e40af"
+                                >
+                                    [Node(3)]
+                                </text>
+                            </svg>
+                        </div>
+                    ),
+                    fix_size: (
+                        <div>
+                            <div
+                                style={{
+                                    display: 'flex',
+                                    gap: 8,
+                                    flexWrap: 'wrap',
+                                    marginBottom: 8,
+                                }}
+                            >
+                                <span
+                                    style={{
+                                        background: '#e0f2fe',
+                                        color: '#0369a1',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 13,
+                                        fontWeight: 'bold',
+                                        fontFamily: 'monospace',
+                                    }}
+                                >
+                                    level_size = 2
+                                </span>
+                                <span
+                                    style={{
+                                        background: '#f1f5f9',
+                                        color: '#475569',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 13,
+                                        fontFamily: 'monospace',
+                                    }}
+                                >
+                                    level_values = []
+                                </span>
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+                                <span style={{ fontSize: 12, color: '#64748b' }}>queue:</span>
+                                {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                            </div>
+                        </div>
+                    ),
+                    collect: (
+                        <div>
+                            <div style={{ marginBottom: 6, fontSize: 12, color: '#475569' }}>
+                                popleft() 順に値を収集中…
+                            </div>
+                            <div
+                                style={{
+                                    display: 'flex',
+                                    alignItems: 'center',
+                                    gap: 6,
+                                    marginBottom: 6,
+                                }}
+                            >
+                                <span style={{ fontSize: 12, color: '#64748b' }}>
+                                    level_values:
+                                </span>
+                                {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+                                <span style={{ fontSize: 12, color: '#64748b' }}>次の階層:</span>
+                                {queueNodes([15, 7], ['#10b981', '#0ea5e9'])}
+                            </div>
+                        </div>
+                    ),
+                    reverse: (
+                        <div>
+                            <div style={{ marginBottom: 6 }}>
+                                <span
+                                    style={{
+                                        background: '#fef3c7',
+                                        color: '#92400e',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 12,
+                                        fontWeight: 'bold',
+                                    }}
+                                >
+                                    len(result) = 1 → 奇数 → reverse()
+                                </span>
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+                                <div style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
+                                    {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                                </div>
+                                <span style={{ fontSize: 18, color: '#10b981' }}>→</span>
+                                <div style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
+                                    {queueNodes([20, 9], ['#8b5cf6', '#f97316'])}
+                                </div>
+                            </div>
+                        </div>
+                    ),
+                    done: (
+                        <div>
+                            <div
+                                style={{
+                                    marginBottom: 6,
+                                    fontSize: 13,
+                                    color: '#065f46',
+                                    fontWeight: 'bold',
+                                }}
+                            >
+                                🎉 全ノード処理完了！
+                            </div>
+                            <div
+                                style={{
+                                    fontFamily: 'monospace',
+                                    fontSize: 12,
+                                    background: '#d1fae5',
+                                    borderRadius: 8,
+                                    padding: '8px 12px',
+                                    color: '#065f46',
+                                }}
+                            >
+                                result = [[3], [20, 9], [15, 7]]
+                            </div>
+                        </div>
+                    ),
+                };
+
+                const info = stepsData[step - 1];
+                return (
+                    <div className="mt-4">
+                        <div className="rounded-xl bg-white border border-emerald-200 p-4">
+                            {panels[visual] || (
+                                <div className="text-slate-400 text-sm">ビジュアルを準備中…</div>
+                            )}
+                        </div>
+                        {/* 変数の状態パネル */}
+                        <div className="mt-3 p-3 rounded-xl bg-slate-50 border border-slate-200 font-mono text-xs">
+                            <div className="text-slate-500 mb-2 font-sans text-xs font-semibold">
+                                🔍 現在の変数の状態
+                            </div>
+                            <div className="text-sky-700">queue = {info.queue}</div>
+                            <div className="text-emerald-700">result = {info.result}</div>
+                        </div>
+                    </div>
+                );
+            }
+
+            // ── メイン Steps コンポーネント ────────────────────────────────────
+            function StepsSection() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 2000);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                const currentStepData = stepsData[activeStep - 1];
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8 mt-2">
+                        {/* ステップ一覧 */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-xl font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-[0.95rem] rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)] active-step'
+                                                    : '',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                            aria-label={`ステップ${step.step}: ${step.title}`}
+                                            aria-current={isActive ? 'step' : undefined}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5 text-sm',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}：{step.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs leading-5">
+                                                {step.desc.substring(0, 48)}…
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* 詳細パネル */}
+                        <div className="my-auto">
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                    ← Step {activeStep - 1}（{stepsData[activeStep - 2].title}
+                                    ）の続き
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-6 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)]">
+                                <h3 className="mt-0 text-teal-800 text-lg font-bold">
+                                    Step {currentStepData.step}：{currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <StepVisualization visual={currentStepData.visual} step={activeStep} />
+
+                            {/* コントロール */}
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#10b981,#059669)] text-sm"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-slate-700 transition shadow hover:-translate-y-0.5 bg-white border-2 border-slate-200 text-sm"
+                                    onClick={() => {
+                                        setActiveStep(1);
+                                        setIsPlaying(false);
+                                    }}
+                                >
+                                    ↺ Reset
+                                </button>
+                            </div>
+
+                            {activeStep === stepsData.length && (
+                                <div className="mt-4 p-3 rounded-xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('steps-root')).render(<StepsSection />);
+        </script>
+
+        <script>
+            // Prism re-highlight after page load
+            document.addEventListener('DOMContentLoaded', () => {
+                if (window.Prism) Prism.highlightAll();
+            });
+            setTimeout(() => {
+                if (window.Prism) Prism.highlightAll();
+            }, 800);
+        </script>
+        <script type="text/babel">
+            // ─── Flowchart Component ───────────────────────────────────────────────────
+            const FC = {
+                terminal: {
+                    background: '#d1fae5',
+                    border: '2px solid #059669',
+                    borderRadius: 999,
+                    color: '#065f46',
+                    fontWeight: 'bold',
+                },
+                process: {
+                    background: '#e0f2fe',
+                    border: '2px solid #0284c7',
+                    borderRadius: 12,
+                    color: '#1e3a5f',
+                },
+                decision: {
+                    background: '#fef3c7',
+                    border: '2px solid #d97706',
+                    borderRadius: 12,
+                    color: '#78350f',
+                    fontWeight: '600',
+                },
+                reverse: {
+                    background: '#ede9fe',
+                    border: '2px solid #7c3aed',
+                    borderRadius: 12,
+                    color: '#4c1d95',
+                },
+            };
+
+            const BASE = {
+                padding: '10px 18px',
+                fontSize: 13,
+                textAlign: 'center',
+                lineHeight: 1.7,
+                boxSizing: 'border-box',
+                width: '100%',
+            };
+
+            function Node({ type, children }) {
+                return <div style={{ ...FC[type], ...BASE }}>{children}</div>;
+            }
+
+            function VArr({ label, color = '#64748b' }) {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            flexDirection: 'column',
+                            alignItems: 'center',
+                            margin: '3px 0',
+                        }}
+                    >
+                        {label && (
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color,
+                                    fontWeight: 'bold',
+                                    margin: '2px 0',
+                                    whiteSpace: 'nowrap',
+                                }}
+                            >
+                                {label}
+                            </div>
+                        )}
+                        <div style={{ width: 2, height: 18, background: color }} />
+                        <div
+                            style={{
+                                width: 0,
+                                height: 0,
+                                borderLeft: '6px solid transparent',
+                                borderRight: '6px solid transparent',
+                                borderTop: `8px solid ${color}`,
+                            }}
+                        />
+                    </div>
+                );
+            }
+
+            function HArr({ label, color = '#059669' }) {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            alignItems: 'center',
+                            flexShrink: 0,
+                            margin: '0 4px',
+                        }}
+                    >
+                        <div style={{ height: 2, width: 18, background: color }} />
+                        {label && (
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color,
+                                    fontWeight: 'bold',
+                                    padding: '0 4px',
+                                    whiteSpace: 'nowrap',
+                                }}
+                            >
+                                {label}
+                            </div>
+                        )}
+                        <div style={{ height: 2, width: 10, background: color }} />
+                        <div
+                            style={{
+                                width: 0,
+                                height: 0,
+                                borderTop: '5px solid transparent',
+                                borderBottom: '5px solid transparent',
+                                borderLeft: `7px solid ${color}`,
+                            }}
+                        />
+                    </div>
+                );
+            }
+
+            function FlowChart() {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            flexDirection: 'column',
+                            alignItems: 'center',
+                            padding: '28px 8px',
+                            gap: 0,
+                            fontFamily: "'Noto Sans JP', sans-serif",
+                        }}
+                    >
+                        {/* ① 開始 */}
+                        <div style={{ width: '100%', maxWidth: 280 }}>
+                            <Node type="terminal">① 開始</Node>
+                        </div>
+                        <VArr />
+
+                        {/* ② root is None? ──はい──> return [] */}
+                        <div
+                            style={{
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                width: '100%',
+                                maxWidth: 560,
+                                gap: 0,
+                            }}
+                        >
+                            <div style={{ flex: '0 0 auto', minWidth: 220, maxWidth: 300 }}>
+                                <Node type="decision">
+                                    ◆ ② <code style={{ fontSize: 12 }}>root is None</code>？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        空ツリーのチェック
+                                    </span>
+                                </Node>
+                            </div>
+                            <HArr label="はい" />
+                            <div style={{ flex: '0 0 auto', minWidth: 90, maxWidth: 130 }}>
+                                <Node type="terminal" style={{ borderRadius: 999 }}>
+                                    <code style={{ fontSize: 12 }}>return []</code>
+                                </Node>
+                            </div>
+                        </div>
+                        <VArr label="いいえ" color="#dc2626" />
+
+                        {/* ③ 初期化 */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="process">
+                                ③ 初期化
+                                <br />
+                                <code style={{ fontSize: 11 }}>result = []</code>
+                                <br />
+                                <code style={{ fontSize: 11 }}>queue = deque([root])</code>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ④ while queue? ──いいえ──> return result */}
+                        <div
+                            style={{
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                width: '100%',
+                                maxWidth: 560,
+                                gap: 0,
+                            }}
+                        >
+                            <div style={{ flex: '0 0 auto', minWidth: 220, maxWidth: 300 }}>
+                                <Node type="decision">
+                                    ◆ ④ <code style={{ fontSize: 12 }}>while queue</code>？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        未処理ノードあり？
+                                    </span>
+                                </Node>
+                            </div>
+                            <HArr label="いいえ" color="#dc2626" />
+                            <div style={{ flex: '0 0 auto', minWidth: 110, maxWidth: 160 }}>
+                                <Node type="terminal">
+                                    ⑨ <code style={{ fontSize: 12 }}>return result</code>
+                                </Node>
+                            </div>
+                        </div>
+                        <VArr label="はい" color="#059669" />
+
+                        {/* ⑤ */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="process">
+                                ⑤ 階層サイズを固定
+                                <br />
+                                <code style={{ fontSize: 11 }}>level_size = len(queue)</code>
+                                <br />
+                                <code style={{ fontSize: 11 }}>level_values = []</code>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ⑥⑦ 内側ループ */}
+                        <div
+                            style={{
+                                border: '2px dashed #a855f7',
+                                borderRadius: 14,
+                                background: '#faf5ff',
+                                padding: '14px 16px',
+                                display: 'flex',
+                                flexDirection: 'column',
+                                alignItems: 'center',
+                                gap: 0,
+                                width: '100%',
+                                maxWidth: 400,
+                                boxSizing: 'border-box',
+                            }}
+                        >
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color: '#7c3aed',
+                                    fontWeight: 'bold',
+                                    marginBottom: 10,
+                                }}
+                            >
+                                🔁 内側ループ（ノードを1つずつ処理）
+                            </div>
+                            <div style={{ width: '100%' }}>
+                                <Node type="decision">
+                                    ◆ ⑥{' '}
+                                    <code style={{ fontSize: 11 }}>for _ in range(level_size)</code>
+                                    ？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        今の階層にノードが残っている？
+                                    </span>
+                                </Node>
+                            </div>
+                            <VArr label="はい" color="#059669" />
+                            <div style={{ width: '100%' }}>
+                                <Node type="process">
+                                    ⑦ <code style={{ fontSize: 11 }}>node = queue.popleft()</code>
+                                    <br />
+                                    <code style={{ fontSize: 11 }}>
+                                        level_values.append(node.val)
+                                    </code>
+                                    <br />
+                                    <span style={{ fontSize: 11 }}>左・右の子を queue に追加</span>
+                                </Node>
+                            </div>
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color: '#a855f7',
+                                    fontWeight: 'bold',
+                                    marginTop: 8,
+                                }}
+                            >
+                                ↩ ⑥ に戻る
+                            </div>
+                        </div>
+                        <VArr label="いいえ（この階層を処理し終えた）" color="#dc2626" />
+
+                        {/* ⑧ */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="decision">
+                                ◆ ⑧ <code style={{ fontSize: 11 }}>len(result) % 2 == 1</code>？
+                                <br />
+                                <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                    奇数階層（右→左）？
+                                </span>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ⑧ 結果サマリ */}
+                        <div
+                            style={{
+                                background: '#f8fafc',
+                                border: '1px solid #e2e8f0',
+                                borderRadius: 10,
+                                padding: '10px 20px',
+                                fontSize: 12,
+                                color: '#475569',
+                                textAlign: 'center',
+                                lineHeight: 1.9,
+                                width: '100%',
+                                maxWidth: 400,
+                                boxSizing: 'border-box',
+                            }}
+                        >
+                            <span style={{ color: '#059669', fontWeight: 'bold' }}>はい</span>：
+                            <code
+                                style={{
+                                    background: '#ede9fe',
+                                    padding: '1px 6px',
+                                    borderRadius: 4,
+                                    fontSize: 11,
+                                    color: '#4c1d95',
+                                }}
+                            >
+                                level_values.reverse()
+                            </code>
+                            　右→左に反転
+                            <br />
+                            <span style={{ color: '#dc2626', fontWeight: 'bold' }}>いいえ</span>：
+                            そのまま（左→右で OK）
+                        </div>
+                        <VArr />
+
+                        {/* APPEND */}
+                        <div style={{ width: '100%', maxWidth: 320 }}>
+                            <Node type="process">
+                                <code style={{ fontSize: 12 }}>result.append(level_values)</code>
+                                <br />
+                                <span style={{ fontSize: 11 }}>この階層の結果を追記</span>
+                            </Node>
+                        </div>
+                        <div
+                            style={{
+                                fontSize: 11,
+                                color: '#a855f7',
+                                fontWeight: 'bold',
+                                margin: '8px 0',
+                            }}
+                        >
+                            ↩ ④ に戻る（while ループの先頭へ）
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('diagram-root-fc')).render(<FlowChart />);
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html b/public/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html
new file mode 100644
index 0000000..2bc4a17
--- /dev/null
+++ b/public/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html	
@@ -0,0 +1,1809 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 103 – Binary Tree Zigzag Level Order Traversal</title>
+
+        <!-- Google Fonts -->
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;600&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+
+        <!-- Tailwind CSS -->
+        <script src="/vendor/tailwindcss/script.js"></script>
+
+        <!-- React 18 -->
+        <script src="/vendor/react/react.development.js"></script>
+        <script src="/vendor/react-dom/react-dom.development.js"></script>
+
+        <!-- Babel Standalone -->
+        <script src="/vendor/babel/babel.min.js"></script>
+
+        <!-- Prism.js -->
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/themes/prism-tomorrow.css"
+        />
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.css"
+        />
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/plugins/toolbar/prism-toolbar.css"
+        />
+        <script src="/vendor/prismjs/prism.js"></script>
+        <script src="/vendor/prismjs/components/prism-python.min.js"></script>
+        <script src="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.js"></script>
+        <script src="/vendor/prismjs/plugins/toolbar/prism-toolbar.js"></script>
+        <script src="/vendor/prismjs/plugins/copy-to-clipboard/prism-copy-to-clipboard.js"></script>
+
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+
+            /* Prism toolbar */
+            .code-toolbar > .toolbar .toolbar-item a,
+            .code-toolbar > .toolbar .toolbar-item button,
+            .code-toolbar > .toolbar .toolbar-item span {
+                background: #10b981 !important;
+                color: white !important;
+                border-radius: 6px !important;
+                padding: 3px 10px !important;
+                font-size: 12px !important;
+                border: none !important;
+                cursor: pointer !important;
+            }
+
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+
+            @keyframes fadeInUp {
+                from {
+                    opacity: 0;
+                    transform: translateY(16px);
+                }
+                to {
+                    opacity: 1;
+                    transform: translateY(0);
+                }
+            }
+            .fade-in-up {
+                animation: fadeInUp 0.5s ease both;
+            }
+
+            @keyframes pulse-border {
+                0%,
+                100% {
+                    box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.4);
+                }
+                50% {
+                    box-shadow: 0 0 0 6px rgba(16, 185, 129, 0);
+                }
+            }
+            .active-step {
+                animation: pulse-border 1.8s ease infinite;
+            }
+        </style>
+    </head>
+
+    <body class="bg-[linear-gradient(135deg,#f0fdf4_0%,#e0f2fe_100%)] min-h-screen">
+        <div class="max-w-5xl mx-auto px-4 py-10">
+            <!-- ═══════════════════════════════════════════════════════════
+       HEADER
+  ══════════════════════════════════════════════════════════════ -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.12)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)] fade-in-up"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >LeetCode 103</span
+                    >
+                    <span
+                        class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Medium</span
+                    >
+                    <span
+                        class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >BFS</span
+                    >
+                </div>
+
+                <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Binary Tree Zigzag Level Order Traversal
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    BFS（幅優先探索）+ 偶奇反転で O(n) 実装
+                </p>
+
+                <p
+                    class="mt-3 text-base text-teal-800 bg-white/60 rounded-xl px-4 py-2 inline-block"
+                >
+                    💡 一言で言うと：「二分木を階層ごとに、偶数階層は左→右・奇数階層は右→左と
+                    <strong>交互にジグザグ</strong> で値を収集する問題」
+                </p>
+
+                <nav class="flex flex-wrap gap-3 mt-6">
+                    <a
+                        href="#overview"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       1. OVERVIEW
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow fade-in-up">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <!-- 一言要約 -->
+                <div class="mb-5 p-4 rounded-xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-semibold text-base">
+                        💡
+                        この問題を一言で言うと：「二分木を<strong>階層ごと</strong>に読み取り、1階層おきに読む向きを反転させる問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2 leading-6">
+                        木の各階層（レベル）をキュー（待ち行列）で順番に処理し、偶数番目の階層は左→右、奇数番目の階層は右→左の順で値を収集します。
+                        最終的に各階層の値リストを2次元配列として返します。
+                    </p>
+                </div>
+
+                <!-- なぜ難しいか -->
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-semibold text-sm mb-2">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-600 text-sm space-y-2 list-disc list-inside leading-6">
+                        <li>
+                            「木を階層ごとに読む（BFS）」は典型的な手法ですが、<strong>偶数・奇数階層で読む向きを変える</strong>という追加条件をどこで処理するかがポイントです。
+                        </li>
+                        <li>
+                            階層の境界を正確に管理しないと、「今の階層」と「次の階層」のノードが混在してしまいます。<code
+                                class="bg-amber-100 px-1 rounded mono text-xs"
+                                >level_size</code
+                            >
+                            を事前に固定するのが鍵です。
+                        </li>
+                        <li>
+                            Pythonでは <strong>キューの実装の選び方</strong>（<code
+                                class="bg-amber-100 px-1 rounded mono text-xs"
+                                >list</code
+                            >
+                            か
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">deque</code>
+                            か）がパフォーマンスに直結します。
+                        </li>
+                    </ul>
+                </div>
+
+                <!-- 指標カード -->
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-6">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-base font-mono">O(n)</div>
+                        <div class="text-xs mt-1">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-base font-mono">O(n)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            collections.deque
+                        </div>
+                        <div class="text-xs mt-1">キュー実装</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            0 ≤ n ≤ 2000
+                        </div>
+                        <div class="text-xs mt-1">ノード数制約</div>
+                    </div>
+                </div>
+
+                <!-- 入出力例 -->
+                <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-5">
+                    <!-- Example 1 -->
+                    <div class="rounded-xl border-2 border-emerald-200 p-4 bg-emerald-50">
+                        <p class="text-emerald-700 font-bold text-sm mb-2">例 1</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[3,9,20,null,null,15,7]</div>
+                            <div>出力：[[3],[20,9],[15,7]]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            階層0→[3]（左→右）、階層1→[20,9]（右→左に反転）、階層2→[15,7]（左→右）
+                        </p>
+                    </div>
+                    <!-- Example 2 -->
+                    <div class="rounded-xl border-2 border-sky-200 p-4 bg-sky-50">
+                        <p class="text-sky-700 font-bold text-sm mb-2">例 2</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[1]</div>
+                            <div>出力：[[1]]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            ノードが1つだけなので、そのまま[[1]]を返す。
+                        </p>
+                    </div>
+                    <!-- Example 3 -->
+                    <div class="rounded-xl border-2 border-slate-200 p-4 bg-slate-50">
+                        <p class="text-slate-600 font-bold text-sm mb-2">例 3</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[]（空ツリー）</div>
+                            <div>出力：[]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            ガード節（root is None）で即座に空リストを返す。
+                        </p>
+                    </div>
+                </div>
+
+                <!-- 制約 -->
+                <div
+                    class="p-4 rounded-xl bg-slate-50 border border-slate-200 text-sm text-slate-700"
+                >
+                    <p class="font-semibold mb-2 text-slate-600">📌 制約</p>
+                    <ul class="list-disc list-inside space-y-1 text-xs leading-6">
+                        <li>ノード数：0 以上 2000 以下</li>
+                        <li>ノードの値：−100 以上 100 以下</li>
+                        <li>
+                            <code class="bg-slate-200 px-1 rounded mono">root</code> は
+                            <code class="bg-slate-200 px-1 rounded mono">None</code>
+                            の場合あり（空ツリー）
+                        </li>
+                    </ul>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       2. STEPS (React)
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       3. CODE
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <!-- コードの骨格 -->
+                <div class="mb-4 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>
+                            空ツリーのガード節 —
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >root is None</code
+                            >
+                            なら即
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs">[]</code> を返す
+                        </li>
+                        <li>
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            にルートノードを入れてキューを初期化する
+                        </li>
+                        <li>
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >while queue:</code
+                            >
+                            で階層ループ —
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs">level_size</code>
+                            を固定してから内側ループへ
+                        </li>
+                        <li>
+                            内側ループで値を収集し、子ノードをキューに追加。ループ後に偶奇判定で逆順にして結果へ追加する
+                        </li>
+                    </ol>
+                </div>
+
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+from collections import deque
+
+if TYPE_CHECKING:
+    class TreeNode:
+        val: int
+        left: Optional[TreeNode]
+        right: Optional[TreeNode]
+        def __init__(self, val=0, left=None, right=None) -&gt; None: ...
+
+
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -&gt; list[list[int]]:
+        # ── ガード節 ──────────────────────────────────────────────
+        # root が None（空ツリー）なら即座に空リストを返す。
+        # 後続処理で node.val へアクセスして AttributeError が起きるのを防ぐ。
+        if root is None:
+            return []
+
+        result: list[list[int]] = []
+
+        # ── deque（両端キュー）の初期化 ───────────────────────────
+        # list.pop(0) は O(n)、deque.popleft() は O(1)。
+        # 全ノード分繰り返すと list では O(n²) になってしまう。
+        queue: deque[TreeNode] = deque([root])
+
+        # ── BFS メインループ ──────────────────────────────────────
+        while queue:
+            # 「今の階層のノード数」をここで固定する。
+            # ループ中に子ノードをキューへ追加するため、固定しないと
+            # 今の階層と次の階層の境界が崩れてしまう。
+            level_size: int = len(queue)
+            level_values: list[int] = []
+
+            for _ in range(level_size):
+                # deque の先頭から O(1) で取り出す
+                node: TreeNode = queue.popleft()
+                level_values.append(node.val)
+
+                if node.left is not None:
+                    queue.append(node.left)
+                if node.right is not None:
+                    queue.append(node.right)
+
+            # ── ジグザグ処理（偶奇による方向切り替え）──────────────
+            # len(result) == 「完了済み階層数」 == 「現在の階層番号」
+            #   偶数（0,2,4…）→ 左→右（そのまま追加）
+            #   奇数（1,3,5…）→ 右→左（in-place で逆順にする）
+            # list.reverse() は新しいリストを作らない in-place 操作なので
+            # [::-1] よりメモリ効率・速度ともに優れる。
+            if len(result) % 2 == 1:
+                level_values.reverse()
+
+            result.append(level_values)
+
+        return result</code></pre>
+
+                <!-- 動作トレース -->
+                <div class="mt-4 p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        ▶ 入力例 [3,9,20,null,null,15,7] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs mono leading-6 overflow-x-auto whitespace-pre"
+                    >
+初期状態:
+  queue  = deque([Node(3)])
+  result = []
+
+─ 階層 0（len(result)=0 → 偶数 → そのまま）─────────────────
+  level_size = 1
+  popleft() → Node(3) → level_values = [3]
+    └ Node(9) と Node(20) をキューへ追加
+  0 % 2 == 0 → reverse しない
+  result = [[3]]   queue = deque([Node(9), Node(20)])
+
+─ 階層 1（len(result)=1 → 奇数 → 逆順）──────────────────────
+  level_size = 2
+  popleft() → Node(9)  → level_values = [9]       （子なし）
+  popleft() → Node(20) → level_values = [9, 20]
+    └ Node(15) と Node(7) をキューへ追加
+  1 % 2 == 1 → reverse() → level_values = [20, 9]
+  result = [[3],[20,9]]   queue = deque([Node(15), Node(7)])
+
+─ 階層 2（len(result)=2 → 偶数 → そのまま）─────────────────
+  level_size = 2
+  popleft() → Node(15) → level_values = [15]      （子なし）
+  popleft() → Node(7)  → level_values = [15, 7]   （子なし）
+  2 % 2 == 0 → reverse しない
+  result = [[3],[20,9],[15,7]]   queue = deque([]) ← 空
+
+while queue: → False → ループ終了
+最終出力: [[3], [20, 9], [15, 7]] ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       4. DIAGRAM (Mermaid)
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <!-- 読み方 -->
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-semibold text-sm mb-3">
+                        🗺️ フローチャートの読み方
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700">
+                        <div class="flex items-center gap-2">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-full bg-emerald-100 border-2 border-emerald-500 text-[10px] text-emerald-800 font-bold whitespace-nowrap"
+                                >開始</span
+                            >
+                            <span>丸角（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-lg bg-sky-100 border-2 border-sky-400 text-[10px] text-sky-900 whitespace-nowrap"
+                                >処理</span
+                            >
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-lg bg-amber-100 border-2 border-amber-400 text-[10px] text-amber-900 whitespace-nowrap"
+                                >◆ 条件</span
+                            >
+                            <span>◆ 四角（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 flex-wrap gap-y-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500 mr-1"></span
+                            ><span class="mr-3">緑＝はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-400 mr-1"></span
+                            ><span>赤＝いいえ</span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- React-rendered CSS Flowchart -->
+                <div id="diagram-root-fc"></div>
+
+                <!-- フロー追跡 -->
+                <div class="mt-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-semibold text-sm mb-3">
+                        🔎 入力例 [3,9,20,null,null,15,7] でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-2 list-decimal list-inside leading-7">
+                        <li>① 開始 → root は None でないので ② の「いいえ」経路へ</li>
+                        <li>③ 初期化：result=[]、queue=deque([Node(3)]) をセット</li>
+                        <li>④ while queue → キューに Node(3) があるので「はい」へ</li>
+                        <li>⑤ level_size=1 に固定。level_values=[] を用意</li>
+                        <li>
+                            ⑥ for ループ：Node(3) を popleft → level_values=[3]。Node(9)・Node(20)
+                            をキューへ追加。ループ終了
+                        </li>
+                        <li>
+                            ⑧ len(result)=0（偶数）→「いいえ」→ reverse せずそのまま append →
+                            result=[[3]]。④ に戻る
+                        </li>
+                        <li>
+                            ④ while → Node(9)・Node(20) あり。⑤ level_size=2。⑥ 両ノード処理 →
+                            level_values=[9,20]。Node(15)・Node(7) をキューへ
+                        </li>
+                        <li>
+                            ⑧ len(result)=1（奇数）→「はい」→ reverse() → level_values=[20,9] →
+                            append → result=[[3],[20,9]]
+                        </li>
+                        <li>
+                            同様に階層2を処理：level_values=[15,7]、len(result)=2（偶数）→ そのまま
+                            append → result=[[3],[20,9],[15,7]]
+                        </li>
+                        <li>
+                            ④ while → キューが空 →「いいえ」→ ⑨
+                            <code class="bg-slate-200 px-1 rounded mono text-xs"
+                                >return [[3],[20,9],[15,7]]</code
+                            >
+                            ✅
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       5. COMPLEXITY
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <!-- Big-O 早見表 -->
+                <div class="mb-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-semibold text-sm mb-3">
+                        📖 Big-O 記法の読み方（入力サイズ n
+                        が大きくなるにつれて処理時間がどう増えるかの目安）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-2 text-xs">
+                        <div class="text-center p-3 rounded-lg bg-emerald-100 text-emerald-800">
+                            <div class="font-bold mono text-base mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-sky-100 text-sky-800">
+                            <div class="font-bold mono text-base mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-amber-100 text-amber-800">
+                            <div class="font-bold mono text-base mb-1">O(n log n)</div>
+                            <div class="leading-5">
+                                n より少し多い<br /><span class="text-amber-600"
+                                    >例：ソートアルゴリズム</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-red-100 text-red-800">
+                            <div class="font-bold mono text-base mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-red-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- 計算量テーブル -->
+                <div class="overflow-x-auto mb-5">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]">
+                                <th class="text-left p-3 rounded-tl-xl font-bold text-teal-800">
+                                    種別
+                                </th>
+                                <th class="text-left p-3 font-bold text-teal-800">計算量</th>
+                                <th class="text-left p-3 rounded-tr-xl font-bold text-teal-800">
+                                    理由
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-b border-slate-100">
+                                <td class="p-3 font-semibold text-slate-700">時間計算量</td>
+                                <td class="p-3">
+                                    <span
+                                        class="mono font-bold text-emerald-700 bg-emerald-50 px-2 py-1 rounded"
+                                        >O(n)</span
+                                    >
+                                </td>
+                                <td class="p-3 text-slate-600">
+                                    全ノードを一度だけ訪問する。<code
+                                        class="bg-slate-100 px-1 rounded mono text-xs"
+                                        >reverse()</code
+                                    >
+                                    は各階層サイズ k に対して O(k) だが、全階層を合計すると O(n)
+                                </td>
+                            </tr>
+                            <tr class="border-b border-slate-100 bg-slate-50/50">
+                                <td class="p-3 font-semibold text-slate-700">空間計算量</td>
+                                <td class="p-3">
+                                    <span
+                                        class="mono font-bold text-sky-700 bg-sky-50 px-2 py-1 rounded"
+                                        >O(n)</span
+                                    >
+                                </td>
+                                <td class="p-3 text-slate-600">
+                                    deque
+                                    は最大で最も幅の広い階層のノード数を格納する。完全二分木では最大
+                                    n/2 ノード。result リストも最終的に n ノード分を格納する
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <!-- in-place vs Pure 比較 -->
+                <div class="mb-5 overflow-x-auto">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-slate-100">
+                                <th class="text-left p-3 font-bold text-slate-700">操作</th>
+                                <th class="text-left p-3 font-bold text-slate-700">コード</th>
+                                <th class="text-left p-3 font-bold text-slate-700">追加メモリ</th>
+                                <th class="text-left p-3 font-bold text-slate-700">速度</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-b border-slate-100 bg-emerald-50">
+                                <td class="p-3 font-semibold text-emerald-700">
+                                    ✅ in-place（採用）
+                                </td>
+                                <td class="p-3 mono text-xs">level.reverse()</td>
+                                <td class="p-3 text-slate-600">O(1)（なし）</td>
+                                <td class="p-3 text-slate-600">高速（C実装）</td>
+                            </tr>
+                            <tr class="border-b border-slate-100">
+                                <td class="p-3 font-semibold text-slate-500">❌ Pure（不採用）</td>
+                                <td class="p-3 mono text-xs">level[::-1]</td>
+                                <td class="p-3 text-slate-600">O(k)（新リスト生成）</td>
+                                <td class="p-3 text-slate-600">やや低速</td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <!-- なぜこの計算量か -->
+                <div class="p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        🔍 なぜこの計算量になるのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        BFS
+                        では各ノードをキューから<strong>1回だけ取り出し</strong>、その値を収集して子ノードを追加します。
+                        ノード数を n とすると、popleft・append・level_values.append はすべて O(1)
+                        なので合計 O(n)。
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">reverse()</code>
+                        は各階層のサイズ k に対して O(k) ですが、
+                        すべての階層のサイズの合計はちょうど n になるため、全体でも O(n)
+                        に収まります。 空間については、deque
+                        に同時に入るノードは「最も幅の広い階層」だけなので最大 O(n/2) = O(n) です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       6. GLOSSARY
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたときに参照してください。
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> BFS（幅優先探索）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木やグラフを「階層ごと・横方向に」順番に訪問する探索手法。キュー（待ち行列）を使って実装する。<br />
+                            <span class="text-slate-500">例え話：</span
+                            >マンションの1階を全室確認してから2階へ、2階を全室確認してから3階へ……と進むイメージ。深さ優先（DFS）とは逆のアプローチ。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> deque（両端キュー）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            が提供するデータ構造。先頭・末尾への追加・取り出しがどちらも
+                            O(1)（一定時間）で行える。<br />
+                            通常の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list</code> で
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">pop(0)</code
+                            >（先頭取り出し）をすると O(n) かかるため、BFS キューには必ず deque
+                            を使う。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            ガード節（早期リターン）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数の先頭で特殊ケース（空の入力・不正な値など）をチェックし、その場で
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">return</code>
+                            する書き方。<br />
+                            後続の処理をネストさせずに済み、コードをシンプルに保てる。この問題では
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >if root is None: return []</code
+                            >
+                            がそれにあたる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> in-place 操作
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            新しいメモリを確保せず、元のデータを直接書き換える操作。<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >list.reverse()</code
+                            >
+                            がその代表例。<br />
+                            対比：<code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >list[::-1]</code
+                            >
+                            は新しいリストを生成する（Pure 操作）。in-place
+                            の方が追加メモリを消費しない分、効率的。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> 不変条件
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件のこと。<br />
+                            この問題では「while ループの先頭で queue
+                            に現在の階層のノードだけが格納されている」ことが不変条件。<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >level_size</code
+                            >
+                            の固定がこれを保証する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> 完全二分木
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            全ての葉（子を持たないノード）が同じ深さにある最もバランスの取れた二分木。最下層の幅（ノード数）は全ノード数
+                            n の約半分（n/2）になる。<br />
+                            この問題の空間計算量 O(n) を考えるときに参考になる最悪ケース。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> キュー（Queue）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            「先に入れたものを先に取り出す」データ構造（FIFO: First In First
+                            Out）。<br />
+                            <span class="text-slate-500">例え話：</span
+                            >コンビニのレジの行列と同じ。先に並んだ人が先に処理される。BFS
+                            では「次に訪問すべきノード」をキューで管理する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> ルートノード
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木の最上位にある起点ノード（頂点）。木全体の出発点で、親を持たない唯一のノード。<br />
+                            BFS ではルートノードをキューに入れることで探索を開始する。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <!-- Footer -->
+            <footer class="text-center text-slate-400 text-xs pb-10">
+                LeetCode 103 · Binary Tree Zigzag Level Order Traversal · BFS + 偶奇反転
+            </footer>
+        </div>
+        <!-- /max-w-5xl -->
+
+        <!-- ═══════════════════════════════════════════════════════════
+     REACT STEPS COMPONENT
+══════════════════════════════════════════════════════════════ -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空ツリーのガード節',
+                    desc:
+                        '関数の先頭で root が None かどうかを確認し、空ツリーなら即座に [] を返します。' +
+                        'なぜなら、後続の処理では node.val や node.left などのノード属性にアクセスするため、None のまま進むと AttributeError が発生してしまうからです。' +
+                        '例）root = None のとき → if root is None: return [] でここで処理が終わる。',
+                    visual: 'guard',
+                    queue: '—（処理なし）',
+                    result: '[]',
+                },
+                {
+                    step: 2,
+                    title: 'deque の初期化',
+                    desc:
+                        'collections.deque にルートノードを入れて BFS キューを初期化します。' +
+                        'list.pop(0) は O(n) コストがかかるのに対し、deque.popleft() は常に O(1) で取り出せるため、全ノード数 n 分繰り返すと速度差が大きくなります。' +
+                        '例）root = Node(3) → queue = deque([Node(3)])、result = []',
+                    visual: 'init',
+                    queue: 'deque([Node(3)])',
+                    result: '[]',
+                },
+                {
+                    step: 3,
+                    title: 'level_size を固定する',
+                    desc:
+                        'while ループの先頭で level_size = len(queue) と書き、今の階層にいるノード数を変数に保存します。' +
+                        'ループ中に子ノードをキューへ追加していくため、固定しないと len(queue) が増え続けて「今の階層」と「次の階層」が混在してしまいます。' +
+                        '例）queue = deque([Node(9), Node(20)]) のとき → level_size = 2 で固定。',
+                    visual: 'fix_size',
+                    queue: 'deque([Node(9), Node(20)])',
+                    result: '[[3]]',
+                },
+                {
+                    step: 4,
+                    title: 'popleft() で値を収集',
+                    desc:
+                        'for _ in range(level_size): のループ内で queue.popleft() を呼び、今の階層のノードを順番に取り出して値を収集します。' +
+                        '左・右の子ノードが存在する場合は queue.append() でキューの末尾に追加します（次の階層の処理のため）。' +
+                        '例）popleft() → Node(9)、level_values=[9]。子なし。popleft() → Node(20)、level_values=[9,20]。Node(15)・Node(7) を追加。',
+                    visual: 'collect',
+                    queue: 'deque([Node(15), Node(7)])',
+                    result: '[[3]]（処理中）',
+                },
+                {
+                    step: 5,
+                    title: '偶奇判定でジグザグ反転',
+                    desc:
+                        'len(result) % 2 が 1（奇数）なら level_values.reverse() を呼んで値リストを逆順にします。' +
+                        'len(result) は「すでに完了した階層数」＝「現在処理中の階層番号」と一致するため、別途カウンタ変数を用意する必要がありません。' +
+                        '例）len(result)=1 → 1%2==1 → reverse() → [9,20] が [20,9] に変わる。',
+                    visual: 'reverse',
+                    queue: 'deque([Node(15), Node(7)])',
+                    result: '[[3],[20,9]]',
+                },
+                {
+                    step: 6,
+                    title: 'result.append して次の階層へ',
+                    desc:
+                        '処理済みの level_values を result.append() で追加し、while ループの先頭に戻って次の階層を処理します。' +
+                        'queue が空になったとき（全ノードを処理し終えたとき）while ループを抜け、result を返して終了します。' +
+                        '例）全階層処理後 → result = [[3],[20,9],[15,7]] を return する。',
+                    visual: 'done',
+                    queue: 'deque([])',
+                    result: '[[3],[20,9],[15,7]]',
+                },
+            ];
+
+            // ── 各ステップのビジュアル ─────────────────────────────────────────
+            function StepVisualization({ visual, step }) {
+                const nodeStyle = (color) => ({
+                    display: 'inline-flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: 40,
+                    height: 40,
+                    borderRadius: '50%',
+                    background: color,
+                    color: 'white',
+                    fontWeight: 'bold',
+                    fontSize: 14,
+                    margin: '0 6px',
+                    boxShadow: '0 2px 8px rgba(0,0,0,0.15)',
+                });
+
+                const queueNodes = (labels, colors) => (
+                    <div
+                        style={{ display: 'flex', alignItems: 'center', flexWrap: 'wrap', gap: 4 }}
+                    >
+                        {labels.map((l, i) => (
+                            <div key={i} style={nodeStyle(colors[i] || '#94a3b8')}>
+                                {l}
+                            </div>
+                        ))}
+                        {labels.length === 0 && (
+                            <span style={{ color: '#94a3b8', fontSize: 13 }}>（空）</span>
+                        )}
+                    </div>
+                );
+
+                const panels = {
+                    guard: (
+                        <div>
+                            <svg viewBox="0 0 320 90" style={{ width: '100%', maxWidth: 320 }}>
+                                <rect
+                                    x="10"
+                                    y="10"
+                                    width="140"
+                                    height="70"
+                                    rx="10"
+                                    fill="#fee2e2"
+                                    stroke="#ef4444"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="80"
+                                    y="38"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="13"
+                                    fill="#991b1b"
+                                    fontWeight="bold"
+                                >
+                                    root = None
+                                </text>
+                                <text
+                                    x="80"
+                                    y="60"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#b91c1c"
+                                >
+                                    空ツリー
+                                </text>
+                                <line
+                                    x1="155"
+                                    y1="45"
+                                    x2="195"
+                                    y2="45"
+                                    stroke="#64748b"
+                                    strokeWidth="1.8"
+                                    markerEnd="url(#sv-arrow)"
+                                />
+                                <defs>
+                                    <marker
+                                        id="sv-arrow"
+                                        markerWidth="8"
+                                        markerHeight="8"
+                                        refX="7"
+                                        refY="3"
+                                        orient="auto"
+                                        markerUnits="strokeWidth"
+                                    >
+                                        <path d="M0,0 L0,6 L7,3 z" fill="#64748b" />
+                                    </marker>
+                                </defs>
+                                <rect
+                                    x="198"
+                                    y="25"
+                                    width="105"
+                                    height="40"
+                                    rx="8"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="250"
+                                    y="43"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#065f46"
+                                    fontWeight="bold"
+                                >
+                                    return []
+                                </text>
+                            </svg>
+                        </div>
+                    ),
+                    init: (
+                        <div>
+                            <svg viewBox="0 0 320 100" style={{ width: '100%', maxWidth: 320 }}>
+                                <rect
+                                    x="10"
+                                    y="15"
+                                    width="120"
+                                    height="70"
+                                    rx="10"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="70"
+                                    y="40"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#065f46"
+                                    fontWeight="bold"
+                                >
+                                    Node(3)
+                                </text>
+                                <text
+                                    x="70"
+                                    y="62"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="11"
+                                    fill="#047857"
+                                >
+                                    ルートノード
+                                </text>
+                                <line
+                                    x1="135"
+                                    y1="50"
+                                    x2="168"
+                                    y2="50"
+                                    stroke="#64748b"
+                                    strokeWidth="1.8"
+                                    markerEnd="url(#sv-arrow2)"
+                                />
+                                <defs>
+                                    <marker
+                                        id="sv-arrow2"
+                                        markerWidth="8"
+                                        markerHeight="8"
+                                        refX="7"
+                                        refY="3"
+                                        orient="auto"
+                                        markerUnits="strokeWidth"
+                                    >
+                                        <path d="M0,0 L0,6 L7,3 z" fill="#64748b" />
+                                    </marker>
+                                </defs>
+                                <rect
+                                    x="170"
+                                    y="15"
+                                    width="140"
+                                    height="70"
+                                    rx="10"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="240"
+                                    y="38"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#1e3a5f"
+                                    fontWeight="bold"
+                                >
+                                    deque
+                                </text>
+                                <text
+                                    x="240"
+                                    y="60"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="11"
+                                    fill="#1e40af"
+                                >
+                                    [Node(3)]
+                                </text>
+                            </svg>
+                        </div>
+                    ),
+                    fix_size: (
+                        <div>
+                            <div
+                                style={{
+                                    display: 'flex',
+                                    gap: 8,
+                                    flexWrap: 'wrap',
+                                    marginBottom: 8,
+                                }}
+                            >
+                                <span
+                                    style={{
+                                        background: '#e0f2fe',
+                                        color: '#0369a1',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 13,
+                                        fontWeight: 'bold',
+                                        fontFamily: 'monospace',
+                                    }}
+                                >
+                                    level_size = 2
+                                </span>
+                                <span
+                                    style={{
+                                        background: '#f1f5f9',
+                                        color: '#475569',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 13,
+                                        fontFamily: 'monospace',
+                                    }}
+                                >
+                                    level_values = []
+                                </span>
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+                                <span style={{ fontSize: 12, color: '#64748b' }}>queue:</span>
+                                {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                            </div>
+                        </div>
+                    ),
+                    collect: (
+                        <div>
+                            <div style={{ marginBottom: 6, fontSize: 12, color: '#475569' }}>
+                                popleft() 順に値を収集中…
+                            </div>
+                            <div
+                                style={{
+                                    display: 'flex',
+                                    alignItems: 'center',
+                                    gap: 6,
+                                    marginBottom: 6,
+                                }}
+                            >
+                                <span style={{ fontSize: 12, color: '#64748b' }}>
+                                    level_values:
+                                </span>
+                                {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+                                <span style={{ fontSize: 12, color: '#64748b' }}>次の階層:</span>
+                                {queueNodes([15, 7], ['#10b981', '#0ea5e9'])}
+                            </div>
+                        </div>
+                    ),
+                    reverse: (
+                        <div>
+                            <div style={{ marginBottom: 6 }}>
+                                <span
+                                    style={{
+                                        background: '#fef3c7',
+                                        color: '#92400e',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 12,
+                                        fontWeight: 'bold',
+                                    }}
+                                >
+                                    len(result) = 1 → 奇数 → reverse()
+                                </span>
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+                                <div style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
+                                    {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                                </div>
+                                <span style={{ fontSize: 18, color: '#10b981' }}>→</span>
+                                <div style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
+                                    {queueNodes([20, 9], ['#8b5cf6', '#f97316'])}
+                                </div>
+                            </div>
+                        </div>
+                    ),
+                    done: (
+                        <div>
+                            <div
+                                style={{
+                                    marginBottom: 6,
+                                    fontSize: 13,
+                                    color: '#065f46',
+                                    fontWeight: 'bold',
+                                }}
+                            >
+                                🎉 全ノード処理完了！
+                            </div>
+                            <div
+                                style={{
+                                    fontFamily: 'monospace',
+                                    fontSize: 12,
+                                    background: '#d1fae5',
+                                    borderRadius: 8,
+                                    padding: '8px 12px',
+                                    color: '#065f46',
+                                }}
+                            >
+                                result = [[3], [20, 9], [15, 7]]
+                            </div>
+                        </div>
+                    ),
+                };
+
+                const info = stepsData[step - 1];
+                return (
+                    <div className="mt-4">
+                        <div className="rounded-xl bg-white border border-emerald-200 p-4">
+                            {panels[visual] || (
+                                <div className="text-slate-400 text-sm">ビジュアルを準備中…</div>
+                            )}
+                        </div>
+                        {/* 変数の状態パネル */}
+                        <div className="mt-3 p-3 rounded-xl bg-slate-50 border border-slate-200 font-mono text-xs">
+                            <div className="text-slate-500 mb-2 font-sans text-xs font-semibold">
+                                🔍 現在の変数の状態
+                            </div>
+                            <div className="text-sky-700">queue = {info.queue}</div>
+                            <div className="text-emerald-700">result = {info.result}</div>
+                        </div>
+                    </div>
+                );
+            }
+
+            // ── メイン Steps コンポーネント ────────────────────────────────────
+            function StepsSection() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 2000);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                const currentStepData = stepsData[activeStep - 1];
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8 mt-2">
+                        {/* ステップ一覧 */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-xl font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-[0.95rem] rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)] active-step'
+                                                    : '',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                            aria-label={`ステップ${step.step}: ${step.title}`}
+                                            aria-current={isActive ? 'step' : undefined}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5 text-sm',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}：{step.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs leading-5">
+                                                {step.desc.substring(0, 48)}…
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* 詳細パネル */}
+                        <div className="my-auto">
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                    ← Step {activeStep - 1}（{stepsData[activeStep - 2].title}
+                                    ）の続き
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-6 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)]">
+                                <h3 className="mt-0 text-teal-800 text-lg font-bold">
+                                    Step {currentStepData.step}：{currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <StepVisualization visual={currentStepData.visual} step={activeStep} />
+
+                            {/* コントロール */}
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#10b981,#059669)] text-sm"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-slate-700 transition shadow hover:-translate-y-0.5 bg-white border-2 border-slate-200 text-sm"
+                                    onClick={() => {
+                                        setActiveStep(1);
+                                        setIsPlaying(false);
+                                    }}
+                                >
+                                    ↺ Reset
+                                </button>
+                            </div>
+
+                            {activeStep === stepsData.length && (
+                                <div className="mt-4 p-3 rounded-xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('steps-root')).render(<StepsSection />);
+        </script>
+
+        <script>
+            // Prism re-highlight after page load
+            document.addEventListener('DOMContentLoaded', () => {
+                if (window.Prism) Prism.highlightAll();
+            });
+            setTimeout(() => {
+                if (window.Prism) Prism.highlightAll();
+            }, 800);
+        </script>
+        <script type="text/babel">
+            // ─── Flowchart Component ───────────────────────────────────────────────────
+            const FC = {
+                terminal: {
+                    background: '#d1fae5',
+                    border: '2px solid #059669',
+                    borderRadius: 999,
+                    color: '#065f46',
+                    fontWeight: 'bold',
+                },
+                process: {
+                    background: '#e0f2fe',
+                    border: '2px solid #0284c7',
+                    borderRadius: 12,
+                    color: '#1e3a5f',
+                },
+                decision: {
+                    background: '#fef3c7',
+                    border: '2px solid #d97706',
+                    borderRadius: 12,
+                    color: '#78350f',
+                    fontWeight: '600',
+                },
+                reverse: {
+                    background: '#ede9fe',
+                    border: '2px solid #7c3aed',
+                    borderRadius: 12,
+                    color: '#4c1d95',
+                },
+            };
+
+            const BASE = {
+                padding: '10px 18px',
+                fontSize: 13,
+                textAlign: 'center',
+                lineHeight: 1.7,
+                boxSizing: 'border-box',
+                width: '100%',
+            };
+
+            function Node({ type, children }) {
+                return <div style={{ ...FC[type], ...BASE }}>{children}</div>;
+            }
+
+            function VArr({ label, color = '#64748b' }) {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            flexDirection: 'column',
+                            alignItems: 'center',
+                            margin: '3px 0',
+                        }}
+                    >
+                        {label && (
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color,
+                                    fontWeight: 'bold',
+                                    margin: '2px 0',
+                                    whiteSpace: 'nowrap',
+                                }}
+                            >
+                                {label}
+                            </div>
+                        )}
+                        <div style={{ width: 2, height: 18, background: color }} />
+                        <div
+                            style={{
+                                width: 0,
+                                height: 0,
+                                borderLeft: '6px solid transparent',
+                                borderRight: '6px solid transparent',
+                                borderTop: `8px solid ${color}`,
+                            }}
+                        />
+                    </div>
+                );
+            }
+
+            function HArr({ label, color = '#059669' }) {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            alignItems: 'center',
+                            flexShrink: 0,
+                            margin: '0 4px',
+                        }}
+                    >
+                        <div style={{ height: 2, width: 18, background: color }} />
+                        {label && (
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color,
+                                    fontWeight: 'bold',
+                                    padding: '0 4px',
+                                    whiteSpace: 'nowrap',
+                                }}
+                            >
+                                {label}
+                            </div>
+                        )}
+                        <div style={{ height: 2, width: 10, background: color }} />
+                        <div
+                            style={{
+                                width: 0,
+                                height: 0,
+                                borderTop: '5px solid transparent',
+                                borderBottom: '5px solid transparent',
+                                borderLeft: `7px solid ${color}`,
+                            }}
+                        />
+                    </div>
+                );
+            }
+
+            function FlowChart() {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            flexDirection: 'column',
+                            alignItems: 'center',
+                            padding: '28px 8px',
+                            gap: 0,
+                            fontFamily: "'Noto Sans JP', sans-serif",
+                        }}
+                    >
+                        {/* ① 開始 */}
+                        <div style={{ width: '100%', maxWidth: 280 }}>
+                            <Node type="terminal">① 開始</Node>
+                        </div>
+                        <VArr />
+
+                        {/* ② root is None? ──はい──> return [] */}
+                        <div
+                            style={{
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                width: '100%',
+                                maxWidth: 560,
+                                gap: 0,
+                            }}
+                        >
+                            <div style={{ flex: '0 0 auto', minWidth: 220, maxWidth: 300 }}>
+                                <Node type="decision">
+                                    ◆ ② <code style={{ fontSize: 12 }}>root is None</code>？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        空ツリーのチェック
+                                    </span>
+                                </Node>
+                            </div>
+                            <HArr label="はい" />
+                            <div style={{ flex: '0 0 auto', minWidth: 90, maxWidth: 130 }}>
+                                <Node type="terminal" style={{ borderRadius: 999 }}>
+                                    <code style={{ fontSize: 12 }}>return []</code>
+                                </Node>
+                            </div>
+                        </div>
+                        <VArr label="いいえ" color="#dc2626" />
+
+                        {/* ③ 初期化 */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="process">
+                                ③ 初期化
+                                <br />
+                                <code style={{ fontSize: 11 }}>result = []</code>
+                                <br />
+                                <code style={{ fontSize: 11 }}>queue = deque([root])</code>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ④ while queue? ──いいえ──> return result */}
+                        <div
+                            style={{
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                width: '100%',
+                                maxWidth: 560,
+                                gap: 0,
+                            }}
+                        >
+                            <div style={{ flex: '0 0 auto', minWidth: 220, maxWidth: 300 }}>
+                                <Node type="decision">
+                                    ◆ ④ <code style={{ fontSize: 12 }}>while queue</code>？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        未処理ノードあり？
+                                    </span>
+                                </Node>
+                            </div>
+                            <HArr label="いいえ" color="#dc2626" />
+                            <div style={{ flex: '0 0 auto', minWidth: 110, maxWidth: 160 }}>
+                                <Node type="terminal">
+                                    ⑨ <code style={{ fontSize: 12 }}>return result</code>
+                                </Node>
+                            </div>
+                        </div>
+                        <VArr label="はい" color="#059669" />
+
+                        {/* ⑤ */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="process">
+                                ⑤ 階層サイズを固定
+                                <br />
+                                <code style={{ fontSize: 11 }}>level_size = len(queue)</code>
+                                <br />
+                                <code style={{ fontSize: 11 }}>level_values = []</code>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ⑥⑦ 内側ループ */}
+                        <div
+                            style={{
+                                border: '2px dashed #a855f7',
+                                borderRadius: 14,
+                                background: '#faf5ff',
+                                padding: '14px 16px',
+                                display: 'flex',
+                                flexDirection: 'column',
+                                alignItems: 'center',
+                                gap: 0,
+                                width: '100%',
+                                maxWidth: 400,
+                                boxSizing: 'border-box',
+                            }}
+                        >
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color: '#7c3aed',
+                                    fontWeight: 'bold',
+                                    marginBottom: 10,
+                                }}
+                            >
+                                🔁 内側ループ（ノードを1つずつ処理）
+                            </div>
+                            <div style={{ width: '100%' }}>
+                                <Node type="decision">
+                                    ◆ ⑥{' '}
+                                    <code style={{ fontSize: 11 }}>for _ in range(level_size)</code>
+                                    ？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        今の階層にノードが残っている？
+                                    </span>
+                                </Node>
+                            </div>
+                            <VArr label="はい" color="#059669" />
+                            <div style={{ width: '100%' }}>
+                                <Node type="process">
+                                    ⑦ <code style={{ fontSize: 11 }}>node = queue.popleft()</code>
+                                    <br />
+                                    <code style={{ fontSize: 11 }}>
+                                        level_values.append(node.val)
+                                    </code>
+                                    <br />
+                                    <span style={{ fontSize: 11 }}>左・右の子を queue に追加</span>
+                                </Node>
+                            </div>
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color: '#a855f7',
+                                    fontWeight: 'bold',
+                                    marginTop: 8,
+                                }}
+                            >
+                                ↩ ⑥ に戻る
+                            </div>
+                        </div>
+                        <VArr label="いいえ（この階層を処理し終えた）" color="#dc2626" />
+
+                        {/* ⑧ */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="decision">
+                                ◆ ⑧ <code style={{ fontSize: 11 }}>len(result) % 2 == 1</code>？
+                                <br />
+                                <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                    奇数階層（右→左）？
+                                </span>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ⑧ 結果サマリ */}
+                        <div
+                            style={{
+                                background: '#f8fafc',
+                                border: '1px solid #e2e8f0',
+                                borderRadius: 10,
+                                padding: '10px 20px',
+                                fontSize: 12,
+                                color: '#475569',
+                                textAlign: 'center',
+                                lineHeight: 1.9,
+                                width: '100%',
+                                maxWidth: 400,
+                                boxSizing: 'border-box',
+                            }}
+                        >
+                            <span style={{ color: '#059669', fontWeight: 'bold' }}>はい</span>：
+                            <code
+                                style={{
+                                    background: '#ede9fe',
+                                    padding: '1px 6px',
+                                    borderRadius: 4,
+                                    fontSize: 11,
+                                    color: '#4c1d95',
+                                }}
+                            >
+                                level_values.reverse()
+                            </code>
+                            　右→左に反転
+                            <br />
+                            <span style={{ color: '#dc2626', fontWeight: 'bold' }}>いいえ</span>：
+                            そのまま（左→右で OK）
+                        </div>
+                        <VArr />
+
+                        {/* APPEND */}
+                        <div style={{ width: '100%', maxWidth: 320 }}>
+                            <Node type="process">
+                                <code style={{ fontSize: 12 }}>result.append(level_values)</code>
+                                <br />
+                                <span style={{ fontSize: 11 }}>この階層の結果を追記</span>
+                            </Node>
+                        </div>
+                        <div
+                            style={{
+                                fontSize: 11,
+                                color: '#a855f7',
+                                fontWeight: 'bold',
+                                margin: '8px 0',
+                            }}
+                        >
+                            ↩ ④ に戻る（while ループの先頭へ）
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('diagram-root-fc')).render(<FlowChart />);
+        </script>
+    </body>
+</html>
diff --git a/public/index.html b/public/index.html
index 55b6be0..0881b39 100644
--- a/public/index.html
+++ b/public/index.html
@@ -416,7 +416,7 @@ <h1 class="site-title">
             🧪 Algorithm Study
             <span class="title-accent">Index</span>
         </h1>
-        <p class="site-subtitle">169 interactive lessons across 6 domains</p>
+        <p class="site-subtitle">170 interactive lessons across 6 domains</p>
     </header>
 
     <div class="search-container">
@@ -431,9 +431,9 @@ <h1 class="site-title">
 
     <div class="tabs" id="categoryTabs">
         <button class="tab-button active" data-category="all" data-tab-target="All">
-            <span class="tab-icon">🌍</span> All <span class="tab-count">169</span>
+            <span class="tab-icon">🌍</span> All <span class="tab-count">170</span>
         </button>
-        <button type="button" class="tab-button" data-category="algorithm" data-tab-target="Algorithm"><span class="tab-icon">🧩</span> Algorithm <span class="tab-count">91</span></button>
+        <button type="button" class="tab-button" data-category="algorithm" data-tab-target="Algorithm"><span class="tab-icon">🧩</span> Algorithm <span class="tab-count">92</span></button>
 <button type="button" class="tab-button" data-category="concurrency" data-tab-target="Concurrency"><span class="tab-icon">⚡</span> Concurrency <span class="tab-count">6</span></button>
 <button type="button" class="tab-button" data-category="datastructures" data-tab-target="DataStructures"><span class="tab-icon">🏗️</span> DataStructures <span class="tab-count">36</span></button>
 <button type="button" class="tab-button" data-category="javascript" data-tab-target="JavaScript"><span class="tab-icon">📜</span> JavaScript <span class="tab-count">14</span></button>
@@ -468,6 +468,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/83.%20Remove%20Duplicates%20from%20Sorted%20List/Claude%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode #83 - Remove Duplicates from Sorted List</span></span><span class="file-path">Algorithm/Other/leetcode/83. Remove Duplicates from Sorted List/Claude 4.6 extended/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/100.%20Same%20Tree/claude%20sonnet%204.6%20extended/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 100 — Same Tree | 再帰DFS解説</span></span><span class="file-path">Algorithm/Other/leetcode/100. Same Tree/claude sonnet 4.6 extended/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/102.%20Binary%20Tree%20Level%20Order%20Traversal/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 102 · Binary Tree Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/103.%20Binary%20Tree%20Zigzag%20Level%20Order%20Traversal/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 103 – Binary Tree Zigzag Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/ExpandAroundCenter/leetcode/5.%20Longest%20Palindromic%20Substring/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 5: Longest Palindromic Substring - 中心展開法</span></span><span class="file-path">Algorithm/ExpandAroundCenter/leetcode/5. Longest Palindromic Substring/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/66.%20Plus%20One/Claude%20Sonnet%204.5/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 66: Plus One - 右から左への繰り上がり処理</span></span><span class="file-path">Algorithm/Other/leetcode/66. Plus One/Claude Sonnet 4.5/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/TwoPointers/leetcode/67.%20Add%20Binary/Claude/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 67: Add Binary - 二進数加算</span></span><span class="file-path">Algorithm/TwoPointers/leetcode/67. Add Binary/Claude/README_react.html</span></a></li>
@@ -644,6 +645,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/83.%20Remove%20Duplicates%20from%20Sorted%20List/Claude%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode #83 - Remove Duplicates from Sorted List</span></span><span class="file-path">Algorithm/Other/leetcode/83. Remove Duplicates from Sorted List/Claude 4.6 extended/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/100.%20Same%20Tree/claude%20sonnet%204.6%20extended/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 100 — Same Tree | 再帰DFS解説</span></span><span class="file-path">Algorithm/Other/leetcode/100. Same Tree/claude sonnet 4.6 extended/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/102.%20Binary%20Tree%20Level%20Order%20Traversal/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 102 · Binary Tree Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/103.%20Binary%20Tree%20Zigzag%20Level%20Order%20Traversal/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 103 – Binary Tree Zigzag Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/ExpandAroundCenter/leetcode/5.%20Longest%20Palindromic%20Substring/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 5: Longest Palindromic Substring - 中心展開法</span></span><span class="file-path">Algorithm/ExpandAroundCenter/leetcode/5. Longest Palindromic Substring/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/66.%20Plus%20One/Claude%20Sonnet%204.5/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 66: Plus One - 右から左への繰り上がり処理</span></span><span class="file-path">Algorithm/Other/leetcode/66. Plus One/Claude Sonnet 4.5/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/TwoPointers/leetcode/67.%20Add%20Binary/Claude/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 67: Add Binary - 二進数加算</span></span><span class="file-path">Algorithm/TwoPointers/leetcode/67. Add Binary/Claude/README_react.html</span></a></li>
@@ -821,7 +823,7 @@ <h1 class="site-title">
 
     <footer>
         <span class="footer-icon">🧪</span>
-        Generated on 2026-04-11
+        Generated on 2026-04-12
     </footer>
 
     <script>