From 2d504a542eae287bfd07a3c8d06a446a178e35ea Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sat, 11 Apr 2026 02:48:23 +0900
Subject: [PATCH 1/4] feat: add TypeScript, Rust, and Python solutions for
 LeetCode 102 Binary Tree Level Order Traversal

---
 .gitignore                                    |   2 +
 ...inary_Tree_Level_Order_Traversal_Python.md |   0
 .../Binary_Tree_Level_Order_Traversal_Rust.md | 352 ++++++++++++++++++
 ...y_Tree_Level_Order_Traversal_Typescript.md | 292 +++++++++++++++
 public/index.html                             |   2 +-
 5 files changed, 647 insertions(+), 1 deletion(-)
 create mode 100644 Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md
 create mode 100644 Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Rust.md
 create mode 100644 Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md

diff --git a/.gitignore b/.gitignore
index 214f93db..cde77481 100644
--- a/.gitignore
+++ b/.gitignore
@@ -102,3 +102,5 @@ credentials.json
 # Node.js関連
 node_modules/
 package-lock.json
+
+.claude/skills
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md
new file mode 100644
index 00000000..e69de29b
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Rust.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Rust.md
new file mode 100644
index 00000000..191d4eff
--- /dev/null
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Rust.md	
@@ -0,0 +1,352 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Rust
+> 適用ルールセット: 共通5ルール + Rust固有5ルール
+> 参照ファイル: references/common.md + references/rust.md
+
+---
+
+# LeetCode 102 · Binary Tree Level Order Traversal — Rust版
+
+---
+
+## 1. 問題の分析
+
+> 💡 **この問題は一言で言うと「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」です。**
+
+```
+        3          ← 深さ0: [3]
+       / \
+      9  20        ← 深さ1: [9, 20]
+         / \
+        15   7     ← 深さ2: [15, 7]
+
+出力: [[3], [9, 20], [15, 7]]
+```
+
+**Rustで解く際に特に気をつけるべき点：**
+LeetCode の Rust 環境では、ツリーノードは `Option<Rc<RefCell<TreeNode>>>` という複合型で表現されています。`Rc<T>`（＝参照カウント型の共有ポインタ）と `RefCell<T>`（＝実行時に借用チェックを行う内部可変性コンテナ）の組み合わせで「1つのノードを複数の親から共有できる」構造を表現しています。この型を安全に扱うパターンを正確に押さえることが、この問題のRust実装の核心です。
+
+---
+
+### 競技プログラミング視点での分析
+
+- ノード数は最大 2000 なので O(n) 単一パスで十分
+- キュー（`VecDeque<T>`、＝両端から追加・取り出しができるキュー）を使い、各ノードをちょうど1回だけ処理する
+- `Rc::clone()` は参照カウントのインクリメントのみで、データのコピーは行わないためオーバーヘッドは小さい
+
+### 業務開発視点での分析
+
+- `Option<Rc<RefCell<TreeNode>>>` は「値がある/ない」を型で安全に表現する。Javaの `null` と異なり、取り出す前に `None` チェックが強制されるためNullPointerException相当のバグが起きない
+- `borrow()` の呼び出しで実行時借用チェックが行われ、同時ミュータブルアクセスが自動的に防止される
+
+### Rust特有の考慮点
+
+- **所有権の移動（move）を避ける**: `Rc::clone(&node)` は所有権を移さず参照カウントをインクリメントするだけ。`node.clone()` と書いても同じ意味だが `Rc::clone()` と書くことでRustの慣習では「安価なクローン」であることを明示できる
+- **`borrow()` vs `borrow_mut()`**: 今回は読み取りのみなので `borrow()`（共有参照）を使う。`borrow_mut()`（排他参照）は不要
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`Rc<T>`**：Reference Counted。参照カウント（＝何箇所から参照されているかを数える）によって、1つの値を複数の場所から所有できるスマートポインタ。スレッドをまたぐ場合は `Arc<T>` を使う
+> - **`RefCell<T>`**：通常はコンパイル時に行う借用チェックを実行時に行うコンテナ。これにより「コンパイル時には分からない条件分岐に応じた可変借用」を安全に実現できる
+> - **内部可変性**：外から見ると不変（`&T`）なのに、内部だけ変更できる仕組み。`RefCell` がその代表例
+> - **参照カウント**：ある値を指しているポインタの数を記録し、0になったら自動的にメモリを解放する仕組み
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+> 💡 同じ問題でも解き方は複数あります。「速さ（時間計算量）」「メモリ」「Rustの所有権モデルとの相性」を合わせて比べます。
+
+| アプローチ           | 時間計算量 | 空間計算量 | Rust実装コスト | 安全性 | 可読性 | 備考                                             |
+| -------------------- | ---------- | ---------- | -------------- | ------ | ------ | ------------------------------------------------ |
+| **BFS + `VecDeque`** | O(n)       | O(n)       | 低             | 高     | 高     | ✅ 今回の選択                                    |
+| DFS（再帰）          | O(n)       | O(n)       | 中             | 高     | 中     | スタックオーバーフローリスク、深さ管理が必要     |
+| DFS（反復）          | O(n)       | O(n)       | 中             | 高     | 中     | `Vec` をスタックとして使う。深さ情報の追跡が必要 |
+
+**Rust固有の観点**:
+
+- BFS + `VecDeque` は「今の階のノード数分だけ `pop_front()` する」パターンで自然に階層分けができ、Rcの借用スコープも短く済む
+- DFS再帰版は `Rc::clone` の呼び出し回数は同じだが、再帰の深さがツリーの高さに比例してスタックを消費するため、バランスの悪い木では不利
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`VecDeque<T>`**：`std::collections::VecDeque`。両端キュー（＝前からも後ろからも要素を追加・取り出しできるデータ構造）。`Vec<T>` の先頭への挿入は O(n) だが `VecDeque` は O(1) でできる
+> - **スタックオーバーフロー**：再帰が深くなりすぎてプログラムが使えるスタックメモリを使い尽くしてしまうエラー
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**: **BFS（幅優先探索）+ `VecDeque`**
+- **理由**:
+    - **DFS再帰を選ばなかった理由**: 深さ情報を引数として持ち回る設計が必要になり、`Rc::clone` のスコープが広がって借用チェッカーとの格闘が増える
+    - **DFS反復を選ばなかった理由**: `Vec` をスタックとして使うと「今の階」の境界を別途追跡しなければならず、コードの見通しが悪くなる
+    - **BFSを選んだ理由**: `VecDeque` の長さを「今の階のサイズ」として使うことで、深さ情報を持ち回らずに階層分けが自然に実現できる
+
+- **Rust特有の最適化ポイント**:
+    - `Rc::clone(&node)` は参照カウントのインクリメントのみ。ヒープアロケーション（＝ヒープ上に新しくメモリを確保する操作）は発生しない
+    - `borrow()` の返す `Ref<T>`（＝`RefCell` の共有借用ガード）はスコープを出ると自動的に解放されるため、借用の管理が明確
+
+> 📖 **このセクションで登場した用語**
+>
+> - **ゼロコスト抽象化**：便利な高レベルな書き方をしても、手書きの低レベルコードと同じ速さになるRustの特性
+> - **`Ref<T>`**：`RefCell<T>` の `borrow()` が返す型。スコープを抜けると自動的に借用が解放されるRAIIガード
+
+---
+
+## 4. 実装コード
+
+> 💡 **コードの大まかな骨格**
+>
+> 1. `root` が `None` なら空 `Vec` を即返す
+> 2. `VecDeque` にルートを積んで BFS 開始
+> 3. ループ毎に「今の階のサイズ」を `len()` で固定し、その分だけ `pop_front()`
+> 4. 各ノードの値を今の階の配列に追加し、`left`/`right` の子があれば次の階としてキューに積む
+> 5. 階ごとの配列を `result` に追加して返す
+
+```rust
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+// LeetCode が提供する TreeNode 定義（提出時はそのまま使う）
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+
+impl Solution {
+    pub fn level_order(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
+        // ───────────────────────────────────────────────────────────────
+        // ① root が None（木が空）の場合は空ベクタを返す
+        //    Option<T> を「中身があるかないかが分かる箱」として扱う。
+        //    Javaの null と異なり、None チェックを忘れるとコンパイルエラーになるため
+        //    ここで弾き忘れることが構造上ありえない。
+        // ───────────────────────────────────────────────────────────────
+        let root = match root {
+            None => return vec![],   // None なら即終了
+            Some(node) => node,      // Some なら中身（Rc<RefCell<TreeNode>>）を取り出す
+        };
+
+        // ───────────────────────────────────────────────────────────────
+        // ② 最終的な結果を格納する2次元ベクタ
+        //    result[0] = 深さ0のノード値の配列、result[1] = 深さ1 ... となる
+        // ───────────────────────────────────────────────────────────────
+        let mut result: Vec<Vec<i32>> = Vec::new();
+
+        // ───────────────────────────────────────────────────────────────
+        // ③ 両端キュー（VecDeque）を用意し、ルートノードを入れる
+        //    VecDeque を使う理由：Vec の先頭取り出しは O(n) だが
+        //    VecDeque の pop_front() は O(1) で済むため、キューとして最適
+        // ───────────────────────────────────────────────────────────────
+        let mut queue: VecDeque<Rc<RefCell<TreeNode>>> = VecDeque::new();
+        queue.push_back(root); // ルートをキューに追加
+
+        // ───────────────────────────────────────────────────────────────
+        // ④ キューが空になるまでループ（= 全ノードを処理し終えるまで）
+        // ───────────────────────────────────────────────────────────────
+        while !queue.is_empty() {
+            // 今この瞬間のキューの長さ = 「現在の階のノード数」
+            // この値を先に固定するのが BFS の核心。
+            // ループ中に queue.len() は変化するため、変数に保存しておく。
+            let level_size = queue.len();
+
+            // 今の階のノード値を格納する一時ベクタ
+            let mut level_values: Vec<i32> = Vec::with_capacity(level_size);
+            // with_capacity(n) は「n個分のメモリを事前に確保」する。
+            // push のたびに再アロケーションが起きるのを防ぐため。
+
+            // 今の階のノードを「level_size 個分」だけ取り出す
+            for _ in 0..level_size {
+                // pop_front() でキューの先頭からノードを O(1) で取り出す
+                // while !is_empty() のループ内なので必ず Some になるが、
+                // 安全のため unwrap() ではなく if let で受け取る
+                let node_rc = queue.pop_front().unwrap();
+                // unwrap() を使う根拠：直上の is_empty() チェックにより
+                // pop_front() が None を返すことはこのスコープでありえない
+
+                // ──────────────────────────────────────────────────────
+                // ⑤ RefCell の borrow() で共有参照を取得する
+                //    borrow() は「読み取り専用の貸し出し」を意味する。
+                //    borrow_mut() は「書き込み可能な貸し出し」で、同時に
+                //    1つしか存在できない（実行時に panic する）。
+                //    今回は読み取りのみなので borrow() で十分。
+                // ──────────────────────────────────────────────────────
+                let node = node_rc.borrow();
+                // node は Ref<TreeNode> 型。スコープを抜けると自動解放される。
+
+                // ノードの値を今の階の配列に追加
+                level_values.push(node.val);
+
+                // ──────────────────────────────────────────────────────
+                // ⑥ 子ノードをキューに追加する（次の階の準備）
+                //    Rc::clone(&child) は所有権を移さず参照カウントを増やすだけ。
+                //    「clone」という名前だがヒープ上のデータはコピーされない（安価）。
+                //    JavaやPythonでの参照コピーと同じ感覚で使える。
+                // ──────────────────────────────────────────────────────
+                if let Some(left) = &node.left {
+                    queue.push_back(Rc::clone(left));
+                }
+                if let Some(right) = &node.right {
+                    queue.push_back(Rc::clone(right));
+                }
+                // node（Ref<TreeNode>）はここでスコープを抜け、borrow が解放される
+            }
+
+            // 今の階の値配列を結果に追加
+            result.push(level_values);
+        }
+
+        result
+    }
+}
+```
+
+---
+
+### 🔍 動作トレース（`root = [3, 9, 20, null, null, 15, 7]`）
+
+```
+ツリー:
+    3
+   / \
+  9  20
+     / \
+    15   7
+
+初期状態:
+  queue  = [Node(3)]
+  result = []
+
+━━━━━━━━━━ while ループ 1回目（深さ0） ━━━━━━━━━━
+  level_size   = 1
+  level_values = []
+
+  i=0: pop_front() → node_rc = Rc<Node(3)>   queue = []
+       node = node_rc.borrow() → val=3
+       level_values.push(3)   → [3]
+       left  = Some(Node(9))  → Rc::clone → queue.push_back   queue = [Node(9)]
+       right = Some(Node(20)) → Rc::clone → queue.push_back   queue = [Node(9), Node(20)]
+       node（Ref）スコープ終了 → borrow 解放
+
+  result.push([3]) → result = [[3]]
+
+━━━━━━━━━━ while ループ 2回目（深さ1） ━━━━━━━━━━
+  level_size   = 2
+  level_values = []
+
+  i=0: pop_front() → node_rc = Rc<Node(9)>    queue = [Node(20)]
+       node.val = 9   level_values = [9]
+       left = None  → スキップ
+       right= None  → スキップ
+
+  i=1: pop_front() → node_rc = Rc<Node(20)]   queue = []
+       node.val = 20  level_values = [9, 20]
+       left  = Some(Node(15)) → queue = [Node(15)]
+       right = Some(Node(7))  → queue = [Node(15), Node(7)]
+
+  result.push([9,20]) → result = [[3], [9, 20]]
+
+━━━━━━━━━━ while ループ 3回目（深さ2） ━━━━━━━━━━
+  level_size   = 2
+  level_values = []
+
+  i=0: pop_front() → Node(15)   queue = [Node(7)]
+       node.val = 15  level_values = [15]
+       left = None, right = None → スキップ
+
+  i=1: pop_front() → Node(7)    queue = []
+       node.val = 7   level_values = [15, 7]
+       left = None, right = None → スキップ
+
+  result.push([15,7]) → result = [[3], [9, 20], [15, 7]]
+
+━━━━━━━━━━ queue が空 → ループ終了 ━━━━━━━━━━
+戻り値: [[3], [9, 20], [15, 7]] ✅
+```
+
+---
+
+### 💡 `Rc::clone()` の動きを図で理解する
+
+```
+Rc::clone(&node) を呼ぶ前：
+  Rc<Node(20)> ← 参照カウント = 1（queue が所持）
+
+Rc::clone(&node.left) 後：
+  Rc<Node(9)> ← 参照カウント = 2（旧 queue + 新 queue が所持）
+
+pop_front() で旧 queue から取り出され、スコープ終了時：
+  Rc<Node(9)> ← 参照カウント = 1（新 queue のみ）
+  → カウントが 0 にならない限りメモリは解放されない
+  → カウントが 0 になったとき初めて Drop（メモリ解放）が呼ばれる
+```
+
+---
+
+### ✅ LeetCode 提出フォーマット（そのままコピー可）
+
+```rust
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 2.39 MB
+// Beats 87.85%
+
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+impl Solution {
+    pub fn 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 = node_rc.borrow();
+                level_values.push(node.val);
+
+                if let Some(left) = &node.left {
+                    queue.push_back(Rc::clone(left));
+                }
+                if let Some(right) = &node.right {
+                    queue.push_back(Rc::clone(right));
+                }
+            }
+
+            result.push(level_values);
+        }
+
+        result
+    }
+}
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`VecDeque::pop_front()`**：キューの先頭要素を O(1) で取り出し、`Option<T>` で返すメソッド。`Vec::remove(0)` は O(n) なので絶対に使わない
+> - **`Vec::with_capacity(n)`**：n 個分のメモリを事前確保してベクタを作る。後から `push` しても再アロケーションが発生しない
+> - **`Ref<T>`**：`RefCell<T>::borrow()` が返す型。RAII（＝スコープを抜けると自動でリソースを解放する仕組み）により、スコープ終了時に借用ガードが自動解放される
+> - **`if let Some(x) = &opt`**：`Option` が `Some` のときだけ中身を取り出してブロックを実行するパターンマッチの省略形。`match` の代替として読みやすい
+> - **RAII**：Resource Acquisition Is Initialization。変数のスコープと資源（メモリ・ファイル・ロックなど）の有効期間を一致させるRustの根本的な設計思想
+
+---
+
+## 5. 計算量まとめ
+
+| 項目           | 値   | 理由                                                                            |
+| -------------- | ---- | ------------------------------------------------------------------------------- |
+| **時間計算量** | O(n) | 各ノードをキューへの追加・取り出しで1回ずつ処理。`Rc::clone` は O(1)            |
+| **空間計算量** | O(n) | キューに最大で「最も広い階のノード数」が入る。最悪 n/2 個（完全二分木の最下層） |
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md
new file mode 100644
index 00000000..138f85ee
--- /dev/null
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md	
@@ -0,0 +1,292 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: TypeScript
+> 適用ルールセット: 共通5ルール + TS固有5ルール
+> 参照ファイル: references/common.md + references/typescript.md
+
+---
+
+# LeetCode 102 · Binary Tree Level Order Traversal
+
+---
+
+## 1. 問題の分析
+
+> 💡 **この問題は一言で言うと「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」です。**
+> 木の「同じ深さ（階層）」にあるすべての値をひとつの配列にまとめ、その配列を深さ順に並べた2次元配列を返します。
+
+---
+
+### 🌳 問題が要求していること（視覚的確認）
+
+```
+        3          ← 深さ0: [3]
+       / \
+      9  20        ← 深さ1: [9, 20]
+         / \
+        15   7     ← 深さ2: [15, 7]
+
+出力: [[3], [9, 20], [15, 7]]
+```
+
+---
+
+### 競技プログラミング視点での分析
+
+- ノード数は最大 2000 なので、O(n) のアルゴリズムで十分に余裕がある
+- 各ノードを **ちょうど1回だけ** 訪問する手法が理想
+- 追加メモリは出力配列のみに抑えたい
+
+### 業務開発視点での分析
+
+- `TreeNode | null` という **Union型（＝複数の型のうちどれかを表す型）** を安全に扱う必要がある
+- `null` チェックを怠ると実行時エラーになるため、型ガード（＝実行時に型を絞り込む条件分岐）が必須
+- 結果配列はイミュータブル（＝変更不可）に構築して副作用を防ぐ
+
+### TypeScript特有の考慮点
+
+- `TreeNode | null` の null 安全性を TypeScript のコンパイラに保証させる
+- キュー（後述）の要素型を明示することで、取り出した要素が必ず `TreeNode` 型であると保証できる
+
+> 📖 **このセクションで登場した用語**
+>
+> - **Union型**：`A | B` のように「AまたはB」を表す TypeScript の型
+> - **null安全性**：`null` や `undefined` によるクラッシュをコンパイル時に防ぐ仕組み
+> - **型ガード**：`if (node !== null)` のような条件で、その後のコードブロック内の型を自動的に絞り込む仕組み
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+> 💡 同じ問題でも解き方は複数あります。「速さ（時間計算量）」と「メモリの使い方（空間計算量）」を比べて最適なものを選びます。
+
+| アプローチ                 | 時間計算量 | 空間計算量 | TS実装コスト | 型安全性 | 可読性 | 備考                             |
+| -------------------------- | ---------- | ---------- | ------------ | -------- | ------ | -------------------------------- |
+| **BFS（幅優先探索）**      | O(n)       | O(n)       | 低           | 高       | 高     | ✅ 今回の選択                    |
+| DFS（深さ優先探索）        | O(n)       | O(n)       | 中           | 高       | 中     | 再帰でも実装可能だが直感的でない |
+| 総当たり（各深さでループ） | O(n²)      | O(n)       | 高           | 中       | 低     | 非推奨                           |
+
+> 💡 **BFS（幅優先探索）を例え話で理解する**
+> BFS は「同じ階のすべての部屋を開けてから、次の階に進むエレベーター」のようなものです。
+> 木でいえば「同じ深さのノードをすべて処理してから、次の深さへ進む」動き方です。
+> これを実現するのが **キュー（＝先に入れたものを先に出す「行列」のデータ構造）** です。
+
+> 📖 **このセクションで登場した用語**
+>
+> - **BFS（幅優先探索）**：グラフや木を「横方向に広がりながら」探索する方法
+> - **DFS（深さ優先探索）**：グラフや木を「縦方向に深く潜りながら」探索する方法
+> - **キュー**：先に入れたものを先に出す（FIFO: First In, First Out）データ構造。銀行の窓口の行列と同じ
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**: **BFS（幅優先探索）+ キュー**
+- **理由**:
+    - **DFS を選ばなかった理由**: DFS は縦に深く潜るため、「同じ階のノードをまとめる」処理と相性が悪く、深さ情報を別途管理する手間が増える
+    - **総当たりを選ばなかった理由**: ノードを重複して走査するため O(n²) になり、ノード数 2000 でも無駄が大きい
+    - **BFS を選んだ理由**: キューから「今の階のノード数分だけ」取り出すことで、自然に「1階ぶんのグループ」が作れる
+
+- **TypeScript特有の最適化ポイント**:
+    - キューの型を `TreeNode[]` と明示することで、取り出した要素が必ず `TreeNode` 型になりコンパイル時に安全を保証
+    - `node.left` / `node.right` は `TreeNode | null` なので、`!== null` チェックで null を排除してからキューに追加する
+
+> 📖 **このセクションで登場した用語**
+>
+> - **コンパイル時保証**：TypeScript がコードを変換する段階でエラーを検出すること。実行前にバグを防げる
+> - **FIFO**：First In, First Out。最初に入れたものを最初に取り出す順序
+
+---
+
+## 4. 実装コード
+
+> 💡 **コードの大まかな骨格**（コードを読む前にこの構造を頭に入れてください）
+>
+> 1. `root` が `null` なら即座に空配列 `[]` を返す
+> 2. `root` をキューに入れて探索開始
+> 3. キューが空になるまで繰り返す
+>     - 今の階のノード数（`levelSize`）を記録する
+>     - ちょうど `levelSize` 個のノードを取り出し、その値を今の階の配列に追加
+>     - 取り出したノードの左・右の子があればキューに追加（次の階の準備）
+> 4. 各階の配列を `result` に追加して返す
+
+```typescript
+// Runtime 2 ms
+// Beats 39.72%
+// Memory 60.20 MB
+// Beats 57.23%
+
+function levelOrder(root: TreeNode | null): number[][] {
+    // ─────────────────────────────────────────────────────────
+    // ① root が null（木が空）の場合は空配列を返す
+    //    後続でキューにアクセスするため、ここで弾かないと
+    //    null に対して .left などへアクセスしてクラッシュする
+    // ─────────────────────────────────────────────────────────
+    if (root === null) return [];
+
+    // ─────────────────────────────────────────────────────────
+    // ② 結果を格納する2次元配列を用意する
+    //    result[0] = 深さ0のノード値の配列、
+    //    result[1] = 深さ1のノード値の配列、... となる
+    // ─────────────────────────────────────────────────────────
+    const result: number[][] = [];
+
+    // ─────────────────────────────────────────────────────────
+    // ③ キュー（行列）を用意し、root を最初の要素として入れる
+    //    型を TreeNode[] と明示することで、取り出した要素が
+    //    null でないことをコンパイラが保証してくれる
+    //    （null をキューに入れないよう、後続の追加時にチェックする）
+    // ─────────────────────────────────────────────────────────
+    const queue: TreeNode[] = [root];
+
+    // ─────────────────────────────────────────────────────────
+    // ④ キューが空になるまでループ（= 全ノードを処理し終えるまで）
+    // ─────────────────────────────────────────────────────────
+    while (queue.length > 0) {
+        // ── 今この瞬間のキューの長さ = 「現在の階のノード数」 ──
+        // この値を先に固定するのが BFS の核心。
+        // ループ中に queue.length は変化するため、
+        // 先に変数に保存しておかないと「今の階」の範囲がズレる。
+        const levelSize: number = queue.length;
+
+        // 今の階のノード値を格納する一時配列
+        const levelValues: number[] = [];
+
+        // 今の階のノードを「levelSize 個分」だけ取り出す
+        for (let i = 0; i < levelSize; i++) {
+            // shift() でキューの先頭からノードを取り出す（FIFO）
+            // queue の要素は TreeNode[] なので null にならない（③で保証）
+            const node = queue.shift()!; // ! は「nullでないことをここで断言」
+
+            // 取り出したノードの値を今の階の配列に追加
+            levelValues.push(node.val);
+
+            // ── 次の階の準備：子ノードをキューの末尾に追加する ──
+            // null でない場合だけ追加する（null をキューに入れないルール）
+            if (node.left !== null) {
+                queue.push(node.left);
+            }
+            if (node.right !== null) {
+                queue.push(node.right);
+            }
+        }
+
+        // 今の階分の値配列を結果に追加
+        result.push(levelValues);
+    }
+
+    return result;
+}
+```
+
+---
+
+### 🔍 動作トレース（具体的な入力例での変数変化）
+
+**入力**: `root = [3, 9, 20, null, null, 15, 7]`（ツリー構造は下記）
+
+```
+    3
+   / \
+  9  20
+     / \
+    15   7
+```
+
+```
+初期状態:
+  queue   = [Node(3)]
+  result  = []
+
+━━━━━━━━━━ while ループ 1回目（深さ0） ━━━━━━━━━━
+  levelSize  = 1          ← 今の階のノード数は1
+  levelValues = []
+
+  i=0: node = queue.shift() → Node(3)  queue = []
+       levelValues.push(3)  → [3]
+       node.left  = Node(9)  → queue.push(Node(9))   queue = [Node(9)]
+       node.right = Node(20) → queue.push(Node(20))  queue = [Node(9), Node(20)]
+
+  result.push([3]) → result = [[3]]
+
+━━━━━━━━━━ while ループ 2回目（深さ1） ━━━━━━━━━━
+  levelSize  = 2          ← 今の階のノード数は2
+  levelValues = []
+
+  i=0: node = queue.shift() → Node(9)   queue = [Node(20)]
+       levelValues.push(9)  → [9]
+       node.left  = null → スキップ
+       node.right = null → スキップ
+
+  i=1: node = queue.shift() → Node(20)  queue = []
+       levelValues.push(20) → [9, 20]
+       node.left  = Node(15) → queue.push(Node(15))  queue = [Node(15)]
+       node.right = Node(7)  → queue.push(Node(7))   queue = [Node(15), Node(7)]
+
+  result.push([9,20]) → result = [[3], [9, 20]]
+
+━━━━━━━━━━ while ループ 3回目（深さ2） ━━━━━━━━━━
+  levelSize  = 2          ← 今の階のノード数は2
+  levelValues = []
+
+  i=0: node = queue.shift() → Node(15)  queue = [Node(7)]
+       levelValues.push(15) → [15]
+       node.left  = null → スキップ
+       node.right = null → スキップ
+
+  i=1: node = queue.shift() → Node(7)   queue = []
+       levelValues.push(7)  → [15, 7]
+       node.left  = null → スキップ
+       node.right = null → スキップ
+
+  result.push([15,7]) → result = [[3], [9, 20], [15, 7]]
+
+━━━━━━━━━━ queue が空 → ループ終了 ━━━━━━━━━━
+戻り値: [[3], [9, 20], [15, 7]] ✅
+```
+
+---
+
+### ✅ LeetCode 提出フォーマット（そのままコピー可）
+
+```typescript
+function levelOrder(root: TreeNode | null): number[][] {
+    if (root === null) return [];
+
+    const result: number[][] = [];
+    const queue: TreeNode[] = [root];
+
+    while (queue.length > 0) {
+        const levelSize: number = queue.length;
+        const levelValues: number[] = [];
+
+        for (let i = 0; i < levelSize; i++) {
+            const node = queue.shift()!;
+            levelValues.push(node.val);
+
+            if (node.left !== null) queue.push(node.left);
+            if (node.right !== null) queue.push(node.right);
+        }
+
+        result.push(levelValues);
+    }
+
+    return result;
+}
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`shift()`**：配列の先頭要素を取り出して返すメソッド。キューの「取り出し」操作に使う
+> - **`push()`**：配列の末尾に要素を追加するメソッド。キューの「追加」操作に使う
+> - **`!`（非null断言）**：TypeScriptに「この値は絶対 null でない」と伝える記号。型チェックを強制的に通す代わりに、間違えると実行時エラーになるため、確信がある箇所にのみ使う
+> - **FIFO**：First In First Out。先に入れたものを先に取り出す順序。キューはこの性質を持つ
+> - **`readonly`（今回不使用だが参考）**：変数を変更不可にする TypeScript の修飾子。JavaScript には存在せず、コンパイル時の書き換えを防ぐために使う
+
+---
+
+## 5. 計算量まとめ
+
+| 項目           | 値   | 理由                                                                              |
+| -------------- | ---- | --------------------------------------------------------------------------------- |
+| **時間計算量** | O(n) | 各ノードをキューへの追加・取り出しでちょうど1回ずつ処理するため                   |
+| **空間計算量** | O(n) | キューに最大で「木の最も広い階のノード数」が入る。最悪ケースは全ノード数 n に比例 |
diff --git a/public/index.html b/public/index.html
index 03bb0e76..0bae42ab 100644
--- a/public/index.html
+++ b/public/index.html
@@ -819,7 +819,7 @@ <h1 class="site-title">
 
     <footer>
         <span class="footer-icon">🧪</span>
-        Generated on 2026-03-20
+        Generated on 2026-04-10
     </footer>
 
     <script>

From e868f02aba0f44dede61565b885b9c476119b9db Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sat, 11 Apr 2026 09:50:46 +0900
Subject: [PATCH 2/4] fix(Trees): fix zero val bug in Python solution and add
 READMEs for 102. Binary Tree Level Order Traversal

---
 ...inary_Tree_Level_Order_Traversal_Python.md |  341 +++++
 ...y_Tree_Level_Order_Traversal_Typescript.md |    1 -
 .../README.md                                 |  759 ++++++++++
 .../README_react.html                         | 1341 +++++++++++++++++
 .../README_react.html                         | 1341 +++++++++++++++++
 public/index.html                             |   10 +-
 6 files changed, 3788 insertions(+), 5 deletions(-)
 create mode 100644 Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md
 create mode 100644 Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html
 create mode 100644 public/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html

diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md
index e69de29b..a42bc9ff 100644
--- a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md	
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md	
@@ -0,0 +1,341 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Python
+> 適用ルールセット: 共通5ルール + Python固有5ルール
+> 参照ファイル: references/common.md + references/python.md
+
+---
+
+# LeetCode 102 · Binary Tree Level Order Traversal — Python版（訂正済み完全版）
+
+---
+
+## 1. 問題分析結果
+
+> 💡 **この問題は一言で言うと「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」です。**
+
+```
+        3          ← 深さ0: [3]
+       / \
+      9  20        ← 深さ1: [9, 20]
+         / \
+        15   7     ← 深さ2: [15, 7]
+
+出力: [[3], [9, 20], [15, 7]]
+```
+
+**Pythonで解く際のCPython特有の注意点：**
+キューの実装には `list.pop(0)` ではなく **`collections.deque` の `popleft()`** を使うことが必須です。`list.pop(0)` は先頭要素を取り出した後、残り全要素を1つずつ前にずらす O(n) 操作ですが、`deque.popleft()` はC言語実装の双方向連結リスト（＝各要素が「前の要素」と「次の要素」へのポインタを持つ構造）のため O(1) で済みます。また今回の訂正の核心として、**`val` が `0` のとき `or` トリックが壊れる**という落とし穴があります。制約が `-1000 <= val <= 1000` なので `0` は普通に登場し、前回の競技版はこれで Wrong Answer になっていました。
+
+---
+
+### 競技プログラミング視点
+
+- 入力サイズ ≤ 2000 なので O(n) あれば十分
+- `deque` + BFS が最速・最シンプル
+- **`val = 0` を含む制約**を必ず確認してから実装テクニックを選ぶ
+
+### 業務開発視点
+
+- `Optional[TreeNode]` で「ノードがあるかないか」を型で明示し、`None` 参照エラーを事前に防ぐ
+- pylance（型チェッカー）がエラーを検出できるよう、戻り値の型まで明示する
+- `is not None` を使うことでPEP8（＝Pythonの公式コーディング規約）に準拠した書き方になる
+
+### Python特有分析
+
+- `collections.deque`：C言語実装の双方向キュー。`popleft()` が O(1) で動く
+- `vals.append(node.val)`：`append()` もC実装のため高速。`0` を含む全整数を正しく扱える
+- `if node.left:` による子ノードの存在確認：`None` は falsy なので自然に弾ける
+
+> 📖 **このセクションで登場した用語**
+>
+> - **CPython**：最も広く使われるPythonの実装。C言語で書かれており `deque` などもC実装のため高速
+> - **falsy（フォールシー）**：Pythonで `if` の条件式が `False` 相当と見なされる値。`0`, `None`, `[]`, `""` などが該当する
+> - **BFS（幅優先探索）**：グラフや木を「横方向に広がりながら」探索する方法
+> - **PEP8**：Pythonの公式スタイルガイド。`== None` より `is None` / `is not None` を推奨している
+
+---
+
+## 2. 採用アルゴリズムと根拠
+
+> 💡 同じ問題でも解き方は複数あります。Pythonでは「どのデータ構造がC実装で速いか」と「制約に `0` が含まれるか」が重要な選択基準です。
+
+| アプローチ          | 時間計算量 | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用  | CPython最適化        | 備考                       |
+| ------------------- | ---------- | ---------- | ---------------- | ------ | ------------------- | -------------------- | -------------------------- |
+| **BFS + `deque`**   | O(n)       | O(n)       | 低               | ★★★    | `collections.deque` | ✅ 適                | ✅ 今回の選択              |
+| DFS（再帰）         | O(n)       | O(n)       | 中               | ★★☆    | なし                | △ 再帰オーバーヘッド | 深さ情報の引数管理が必要   |
+| BFS + `list.pop(0)` | O(n²)      | O(n)       | 低               | ★★★    | なし                | ❌ 不適              | 先頭削除が O(n) になる     |
+| BFS + `or` トリック | O(n)       | O(n)       | 低               | ★☆☆    | `collections.deque` | ✅ 適                | ❌ `val=0` で Wrong Answer |
+
+**選択理由：**
+`or` トリックを選ばなかった理由は、`0 or 式` は左辺が `0`（falsy）のとき右辺の `extend()` が評価され、その戻り値 `None` がリストに入ってしまうからです。`list.pop(0)` を選ばなかった理由は先頭削除が O(n) になるからです。**シンプルな `for` ループ + `append()` の組み合わせが最も安全かつ高速です。**
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`or` トリック**：`A or B` で「A が falsy なら B を評価する」性質を副作用のある処理に悪用するテクニック。`val=0` のような falsy な値が来ると壊れる
+> - **`extend()`**：イテラブルの全要素をまとめて `deque` や `list` の末尾に追加するメソッド。戻り値は `None`
+> - **O(n²)**：入力が2倍になると処理が約4倍になること。`list.pop(0)` をループの中で呼ぶと発生する
+
+---
+
+## 3. 実装パターン
+
+> 💡 **コードの大まかな骨格**
+>
+> 1. `root` が `None` なら空リストを即返す
+> 2. `deque` にルートを入れてBFS開始
+> 3. ループ毎に「今の階のサイズ」を `len(queue)` で**変数に保存して固定**
+> 4. その数だけ `popleft()` し、値を収集・子をキューに積む
+> 5. 今の階の配列を結果リストに追加
+
+---
+
+### 【業務開発版を使う場面】
+
+チームで長期間メンテナンスするプロダクションコードに向きます。型ヒントとエラーハンドリングを充実させることで、後から読んだ人が意図を理解しやすい構造になっています。pylanceによる静的解析が有効に機能します。
+
+```python
+from __future__ import annotations
+from collections import deque
+from typing import Optional
+
+
+# LeetCode が提供する TreeNode 定義（提出時はそのまま使う）
+# class TreeNode:
+#     def __init__(
+#         self,
+#         val: int = 0,
+#         left: Optional[TreeNode] = None,
+#         right: Optional[TreeNode] = None,
+#     ) -> None:
+#         self.val = val
+#         self.left = left
+#         self.right = right
+
+
+class Solution:
+    """
+    Binary Tree Level Order Traversal (LeetCode #102)
+
+    BFS（幅優先探索）+ collections.deque を使って
+    木を上から下へ階層ごとにグループ化して返す。
+    """
+
+    def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        """
+        二分木のレベル順トラバーサルを返す（業務開発版）
+
+        Args:
+            root: 二分木のルートノード（None の場合は空ツリー）
+
+        Returns:
+            各階層の値を格納した2次元リスト。
+            空ツリーの場合は空リスト []。
+
+        Complexity:
+            Time:  O(n) — 各ノードを1回だけ処理する
+            Space: O(n) — キューに最大で最下層のノード数が入る
+        """
+        # ────────────────────────────────────────────────────────────
+        # ① root が None（空ツリー）のとき、即座に空リストを返す。
+        #    Optional[TreeNode] 型のため、root に対して直接 .val 等を
+        #    呼ぶと pylance がエラーを検出する。ここで None を弾くことで
+        #    以降は TreeNode として扱える（型の絞り込み）。
+        # ────────────────────────────────────────────────────────────
+        if root is None:
+            return []
+
+        # ────────────────────────────────────────────────────────────
+        # ② 結果を格納する2次元リスト
+        #    result[0] = 深さ0の値リスト、result[1] = 深さ1の値リスト、...
+        # ────────────────────────────────────────────────────────────
+        result: list[list[int]] = []
+
+        # ────────────────────────────────────────────────────────────
+        # ③ collections.deque をキューとして使う。
+        #    list.pop(0) は O(n) だが deque.popleft() は O(1)。
+        #    deque はC言語で実装された双方向キューで
+        #    先頭・末尾への追加・削除が常に高速。
+        # ────────────────────────────────────────────────────────────
+        queue: deque[TreeNode] = deque([root])
+
+        # ────────────────────────────────────────────────────────────
+        # ④ キューが空になるまでループ（= 全ノードを処理し終えるまで）
+        # ────────────────────────────────────────────────────────────
+        while queue:
+            # 今この瞬間のキューの長さ = 「現在の階のノード数」。
+            # ループ中に queue の長さは変化するため、変数に保存して固定する。
+            # これが BFS で「1階ぶんをまとめて処理する」核心の1行。
+            level_size: int = len(queue)
+
+            # 今の階のノード値を格納する一時リスト
+            level_values: list[int] = []
+
+            for _ in range(level_size):
+                # popleft() でキューの先頭ノードを O(1) で取り出す
+                node: TreeNode = queue.popleft()
+
+                # 取り出したノードの値を今の階の配列に追加する。
+                # append() はC実装のため高速。
+                # val が 0 の場合も正しく追加される（or を使わない理由）。
+                level_values.append(node.val)
+
+                # ── 次の階の準備：子ノードをキューの末尾に追加 ──
+                # None チェックをしてから追加することで、
+                # キューの中身が常に TreeNode 型であることを保証する。
+                # これにより pylance の型エラーも防げる。
+                if node.left is not None:
+                    queue.append(node.left)
+                if node.right is not None:
+                    queue.append(node.right)
+
+            # 今の階の値リストを結果に追加
+            result.append(level_values)
+
+        return result
+```
+
+---
+
+### 【競技プログラミング版を使う場面】
+
+LeetCode などで制限時間内に正解を出すことが目的のコードに向きます。型ヒントの最小化とコードの短縮を優先しつつ、**前回の `or` トリックによるバグを完全に排除**しています。`val = 0` を含む全テストケースで正しく動作します。
+
+```python
+# Runtime 0 ms
+# Beats 100.00%
+# Memory 19.92 MB
+# Beats 70.45%
+
+from collections import deque
+from typing import Optional
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        # root が None または存在しない場合は即座に空リストを返す。
+        # `not root` は `root is None` と同等。
+        # TreeNode の __bool__ は定義されていないため None チェックとして機能する。
+        if not root:
+            return []
+
+        result: list[list[int]] = []
+
+        # C実装の deque でキューを初期化。
+        # popleft() が O(1) のためキューとして最適。
+        queue: deque[TreeNode] = deque([root])
+
+        while queue:
+            # ── 今の階のサイズをループ前に固定する ──
+            # ここが競技版でも絶対に省略できない核心部分。
+            # ループ内で popleft()/append() が起きると queue の長さが変化するため、
+            # 先に変数へ保存しておかないと「今の階」の範囲がずれる。
+            level_size = len(queue)
+            vals: list[int] = []
+
+            for _ in range(level_size):
+                # 先頭ノードを O(1) で取得
+                node = queue.popleft()
+
+                # val を直接 append する。
+                # 前回の `node.val or extend(...)` トリックは
+                # val=0 のとき 0（falsy）と判定されて壊れるため使わない。
+                vals.append(node.val)
+
+                # 子が存在する場合のみキューへ追加（None は falsy なので自然に弾ける）
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+
+            result.append(vals)
+
+        return result
+```
+
+---
+
+### 🔍 動作トレース（`root = [3, 9, 20, null, null, 15, 7]`）
+
+```
+ツリー:
+    3
+   / \
+  9  20
+     / \
+    15   7
+
+初期状態:
+  queue  = deque([Node(3)])
+  result = []
+
+━━━━━━━━━━ while ループ 1回目（深さ0） ━━━━━━━━━━
+  level_size = 1   ← ここで固定。以降 queue が変わっても影響しない
+  vals = []
+
+  i=0: node = queue.popleft() → Node(3)   queue = deque([])
+       vals.append(3)  → [3]       ← val が 0 でも正しく追加される
+       node.left  = Node(9)  → queue.append → queue = deque([Node(9)])
+       node.right = Node(20) → queue.append → queue = deque([Node(9), Node(20)])
+
+  result.append([3]) → result = [[3]]
+
+━━━━━━━━━━ while ループ 2回目（深さ1） ━━━━━━━━━━
+  level_size = 2   ← len(queue)=2 をここで固定
+  vals = []
+
+  i=0: node = queue.popleft() → Node(9)    queue = deque([Node(20)])
+       vals.append(9)   → [9]
+       node.left  = None → スキップ
+       node.right = None → スキップ
+
+  i=1: node = queue.popleft() → Node(20)   queue = deque([])
+       vals.append(20)  → [9, 20]
+       node.left  = Node(15) → queue.append → queue = deque([Node(15)])
+       node.right = Node(7)  → queue.append → queue = deque([Node(15), Node(7)])
+
+  result.append([9, 20]) → result = [[3], [9, 20]]
+
+━━━━━━━━━━ while ループ 3回目（深さ2） ━━━━━━━━━━
+  level_size = 2
+  vals = []
+
+  i=0: node = queue.popleft() → Node(15)   queue = deque([Node(7)])
+       vals.append(15)  → [15]
+       node.left  = None → スキップ, node.right = None → スキップ
+
+  i=1: node = queue.popleft() → Node(7)    queue = deque([])
+       vals.append(7)   → [15, 7]
+       node.left  = None → スキップ, node.right = None → スキップ
+
+  result.append([15, 7]) → result = [[3], [9, 20], [15, 7]]
+
+━━━━━━━━━━ queue が空 → ループ終了 ━━━━━━━━━━
+戻り値: [[3], [9, 20], [15, 7]] ✅
+```
+
+---
+
+## 4. 前回バグの総括
+
+| 項目             | 前回の競技版（❌ Wrong Answer）             | 今回の訂正版（✅ Accepted）                 |
+| ---------------- | ------------------------------------------- | ------------------------------------------- |
+| `val = 0` のとき | `0 or extend(...)` → `None` がリストに混入  | `vals.append(node.val)` → 正しく `0` を追加 |
+| 階のサイズ固定   | `or` トリックで子の追加と混在し計算がずれる | `level_size = len(queue)` を先に変数へ保存  |
+| `type: ignore`   | 型の問題を強引に無視していた                | 不要なトリックを排除したので不要            |
+| pylance 対応     | `type: ignore` を使っており型安全でない     | 全型ヒントが正しく解決される                |
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`deque([root])`**：`deque` を初期値ありで生成する書き方。`deque()` を作ってから `append()` するより1行で書ける
+> - **`popleft()`**：`deque` の先頭要素を O(1) で取り出すメソッド。`list.pop(0)` の O(n) と必ず区別すること
+> - **`is not None`**：`None` かどうかの比較は `== None` ではなく `is not None` と書くのがPythonの慣習（PEP8準拠）
+> - **型の絞り込み（Type Narrowing）**：`if root is None: return []` の後、pylance が `root` を `TreeNode` 型と自動判断する機能
+
+---
+
+## 5. 計算量まとめ
+
+| 項目           | 値   | 理由                                                                          |
+| -------------- | ---- | ----------------------------------------------------------------------------- |
+| **時間計算量** | O(n) | 各ノードをキューへの追加・取り出しでちょうど1回ずつ処理する                   |
+| **空間計算量** | O(n) | キューに最大で「最も広い階のノード数」が入る。完全二分木の最下層は最大 n/2 個 |
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md
index 138f85ee..7f1f6ff2 100644
--- a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md	
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md	
@@ -69,7 +69,6 @@
 > BFS は「同じ階のすべての部屋を開けてから、次の階に進むエレベーター」のようなものです。
 > 木でいえば「同じ深さのノードをすべて処理してから、次の深さへ進む」動き方です。
 > これを実現するのが **キュー（＝先に入れたものを先に出す「行列」のデータ構造）** です。
-
 > 📖 **このセクションで登場した用語**
 >
 > - **BFS（幅優先探索）**：グラフや木を「横方向に広がりながら」探索する方法
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md
new file mode 100644
index 00000000..e4d16f5e
--- /dev/null
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md	
@@ -0,0 +1,759 @@
+# Binary Tree Level Order Traversal - 木を階層ごとにグループ化する
+
+---
+
+## 目次（Table of Contents）
+
+- [概要](#overview)
+- [アルゴリズム要点 TL;DR](#tldr)
+- [図解](#figures)
+- [正しさのスケッチ](#correctness)
+- [計算量](#complexity)
+- [Python 実装](#impl)
+- [CPython 最適化ポイント](#cpython)
+- [エッジケースと検証観点](#edgecases)
+- [FAQ](#faq)
+
+---
+
+<h2 id="overview">概要</h2>
+
+> 💡 **この問題は一言で言うと「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」です。**
+
+与えられた二分木（＝各ノードが最大2つの子を持つ木構造のデータ）のノードを、
+**深さ（根からの距離）が同じものをひとつの配列にまとめ**、深さ順に並べた2次元配列を返します。
+
+```
+        3          ← 深さ0 → [3]
+       / \
+      9  20        ← 深さ1 → [9, 20]
+         / \
+        15   7     ← 深さ2 → [15, 7]
+
+出力: [[3], [9, 20], [15, 7]]
+```
+
+**なぜこの問題が難しいのか：**
+木構造を「縦（深さ方向）」に探索するのは直感的ですが、この問題は「横（同じ深さ）」の単位でまとめる必要があります。
+そのため、**同じ深さにあるノードをすべて処理し終えてから次の深さへ進む**BFS（幅優先探索）という手法を使う必要があり、
+その実現に `collections.deque` というデータ構造が鍵を握ります。
+
+**制約：**
+
+| 項目       | 範囲                                             |
+| ---------- | ------------------------------------------------ |
+| ノード数   | 0 以上 2000 以下                                 |
+| ノードの値 | -1000 以上 1000 以下（**0 が含まれる点に注意**） |
+
+> 📖 **この章で登場した用語**
+>
+> - **二分木**：各ノードが左の子・右の子の最大2つを持つ木構造のデータ
+> - **深さ**：根ノードからそのノードまでの辺の数。根の深さは 0
+> - **BFS（幅優先探索）**：グラフや木を「横方向に広がりながら」探索する方法
+> - **制約**：入力として与えられる値の範囲や条件のこと
+
+---
+
+<h2 id="tldr">アルゴリズム要点（TL;DR）</h2>
+
+> 💡 **TL;DR（Too Long; Didn't Read）** とは「長くて読めない人向けの要約」という意味です。
+> ここではアルゴリズム全体の戦略をざっくり把握するための章です。
+> 詳細は後の章で説明するので、**「なんとなくこういう手順で解くんだな」というイメージを掴む**ことを目的にしています。
+
+- **手法：BFS（幅優先探索）**
+  木を「同じ深さのノードをすべて処理してから次の深さへ進む」順番で探索する。
+  これが今回の「階層ごとのグループ化」と自然に一致するため選ぶ。
+
+- **データ構造：`collections.deque`（両端キュー）**
+  先頭からの取り出しが O(1) で行えるため、キュー（行列）として最適。
+  `list.pop(0)` を使うと先頭取り出しが O(n) になり全体が O(n²) へ悪化するため使わない。
+
+- **核心テクニック：`level_size = len(queue)` をループ前に固定する**
+  ループ中にキューへの追加・取り出しが同時に起きるため、「今の階のサイズ」を先に変数へ保存しないとズレが生じる。
+
+- **時間計算量：O(n)** 各ノードをちょうど1回だけ処理する。
+
+- **空間計算量：O(n)** キューに最大で最下層のノード数（最大 n/2 個）が入る。
+
+- **`val = 0` への注意**
+  ノードの値が `-1000 〜 1000` のため `0` は普通に登場する。
+  `0 or 式` のような `or` トリックは `val=0` のとき `0`（falsy）と判定されて壊れるため**絶対に使わない**。
+
+> 📖 **この章で登場した用語**
+>
+> - **TL;DR**：「長くて読めない人向けの要約」を意味する略語
+> - **キュー**：先に入れたものを先に取り出す（FIFO）データ構造。銀行の窓口の行列と同じ仕組み
+> - **falsy（フォールシー）**：Pythonで `if` の条件式が `False` 相当と見なされる値。`0`, `None`, `[]`, `""` などが該当する
+
+---
+
+<h2 id="figures">図解</h2>
+
+> 💡 **Mermaid フローチャートの読み方：**
+>
+> - **長方形 `[]`** は「処理ステップ」を表します。
+> - **ひし形 `{}`** は「条件分岐」を表します。Yes/No の矢印でどちらへ進むかが決まります。
+> - 矢印は処理の流れを示し、上から下（または左から右）へ読み進めます。
+
+---
+
+### フローチャート
+
+この図は `levelOrder` 関数全体の処理の流れを表しています。
+上から下へ読み進めることで、BFS がどのように「階層ごと」に処理するかを確認できます。
+
+```mermaid
+flowchart TD
+  Start[Start levelOrder root] --> IsNone{root is None}
+  IsNone -- Yes --> RetEmpty[Return empty list]
+  IsNone -- No --> Init[Init result and queue with root]
+  Init --> WhileLoop{queue is not empty}
+  WhileLoop -- No --> RetResult[Return result]
+  WhileLoop -- Yes --> FixSize[level_size = len queue]
+  FixSize --> InitVals[vals = empty list]
+  InitVals --> ForLoop{i less than level_size}
+  ForLoop -- No --> AppendLevel[result.append vals]
+  AppendLevel --> WhileLoop
+  ForLoop -- Yes --> PopNode[node = queue.popleft]
+  PopNode --> AppendVal[vals.append node.val]
+  AppendVal --> CheckLeft{node.left exists}
+  CheckLeft -- Yes --> PushLeft[queue.append node.left]
+  CheckLeft -- No --> CheckRight{node.right exists}
+  PushLeft --> CheckRight
+  CheckRight -- Yes --> PushRight[queue.append node.right]
+  CheckRight -- No --> NextI[i plus 1]
+  PushRight --> NextI
+  NextI --> ForLoop
+```
+
+**各ノードの意味：**
+
+- `Start`：関数の入り口。`root` を引数として受け取る
+- `IsNone`（ひし形）：`root` が `None`（空ツリー）かどうかを判定する
+- `RetEmpty`：空ツリーなら空リストを即返す
+- `Init`：`result = []` と `queue = deque([root])` を初期化する
+- `WhileLoop`（ひし形）：キューが空でない間ループを続ける判定
+- `FixSize`：**今の階のサイズを変数に固定する**（BFS の核心）
+- `InitVals`：今の階の値を格納する一時リストを作る
+- `ForLoop`（ひし形）：`level_size` 個分のノードを処理するループ判定
+- `PopNode`：`popleft()` でキューの先頭ノードを O(1) で取り出す
+- `AppendVal`：ノードの値を今の階のリストに追加する（`val=0` も正しく追加される）
+- `CheckLeft` / `CheckRight`（ひし形）：子が存在するかどうかを判定する
+- `PushLeft` / `PushRight`：子をキューの末尾に追加する（次の階として処理待ちにする）
+- `AppendLevel`：今の階の値リストを結果に追加する
+
+---
+
+### データフロー図
+
+この図は入力ツリーがどのようにキューを経由して結果配列へ変換されるかのデータの流れを表しています。
+
+```mermaid
+graph LR
+  subgraph Input
+    Root[root TreeNode]
+  end
+  subgraph BFS_Core
+    Root --> Q[deque queue]
+    Q --> Pop[popleft O1]
+    Pop --> Val[node.val]
+    Pop --> Kids[left and right children]
+    Kids --> Q
+  end
+  subgraph Output
+    Val --> LV[level_values list]
+    LV --> Res[result 2D list]
+  end
+```
+
+**主要な流れの説明：**
+
+- `root → deque`：ルートノードをキューに入れてBFS開始
+- `popleft() → node.val`：先頭ノードを取り出してその値を今の階のリストへ追加
+- `left/right → deque`：子ノードをキューの末尾へ追加（次の階として登録）
+- `level_values → result`：今の階の値リストを結果の2次元配列へ追加
+
+---
+
+> 💡 **代表例でのトレース：`root = [3, 9, 20, null, null, 15, 7]`**
+
+```
+ツリー:
+    3
+   / \
+  9  20
+     / \
+    15   7
+
+Step 1: Start → root = Node(3)
+Step 2: IsNone → No（rootは存在する）
+Step 3: Init → result=[], queue=deque([Node(3)])
+
+━━ while ループ 1回目（深さ0） ━━
+Step 4: FixSize → level_size = len(queue) = 1（ここで固定）
+Step 5: InitVals → vals = []
+Step 6: ForLoop i=0:
+        PopNode  → node = Node(3)   queue = deque([])
+        AppendVal → vals = [3]      （val=3 を正しく追加）
+        CheckLeft → Node(9) あり    → queue = deque([Node(9)])
+        CheckRight → Node(20) あり  → queue = deque([Node(9), Node(20)])
+Step 7: AppendLevel → result = [[3]]
+
+━━ while ループ 2回目（深さ1） ━━
+Step 8: FixSize → level_size = 2（ここで固定。以降 queue が変わっても影響しない）
+Step 9: ForLoop i=0:
+        PopNode  → node = Node(9)   queue = deque([Node(20)])
+        AppendVal → vals = [9]
+        left=None, right=None → スキップ
+        ForLoop i=1:
+        PopNode  → node = Node(20)  queue = deque([])
+        AppendVal → vals = [9, 20]
+        left=Node(15) → queue = deque([Node(15)])
+        right=Node(7) → queue = deque([Node(15), Node(7)])
+Step 10: AppendLevel → result = [[3], [9, 20]]
+
+━━ while ループ 3回目（深さ2） ━━
+Step 11: FixSize → level_size = 2
+         i=0: Node(15) → vals=[15]  子なし
+         i=1: Node(7)  → vals=[15,7] 子なし
+Step 12: AppendLevel → result = [[3], [9, 20], [15, 7]]
+
+Step 13: WhileLoop → queue が空 → ループ終了
+Step 14: RetResult → [[3], [9, 20], [15, 7]] ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **フローチャート**：処理の手順を図形と矢印で表したもの。ひし形=条件分岐、長方形=処理
+> - **データフロー図**：データがどのように変換・移動するかを示す図
+> - **サブグラフ**：フローチャートの中で関連する処理をグループ化したもの
+> - **FIFO**：First In First Out。最初に入れたものを最初に取り出す順序。キューはこの性質を持つ
+
+---
+
+<h2 id="correctness">正しさのスケッチ</h2>
+
+> 💡 **「正しさのスケッチ」** とは、アルゴリズムが**常に正しい答えを返せる根拠**を整理したものです。
+> 数学的な厳密な証明ではなく「なぜ正しいと言えるか」の説明です。
+
+---
+
+### 1. 不変条件（＝アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件）
+
+**「while ループの各反復の開始時点で、`queue` には現在の階のノードだけが入っている」**
+
+- ループ開始時：`level_size = len(queue)` で今の階のサイズを固定する
+- `level_size` 回だけ `popleft()` することで今の階のノードを全部取り出す
+- その間に追加された子ノードは「次の階」としてキューの末尾に積まれるだけで、今の階のカウントには影響しない
+- ループ終了時：キューには次の階のノードだけが残り、次の反復の開始時にも不変条件が保たれる
+
+### 2. 網羅性（＝すべてのケースをもれなく処理できているという保証）
+
+- 全ノードは「キューに積まれる」→「`popleft()` で取り出される」の2ステップを必ずたどる
+- ルートはループ前にキューに積まれる
+- 各ノードの左・右の子は「そのノードを処理するとき」に `None` チェックをしてからキューに積まれる
+- したがって、存在するすべてのノードがちょうど1回だけ処理される
+
+### 3. 基底条件（＝再帰の終了条件に相当する、処理を打ち切る条件）
+
+- `root is None`：ツリーが空の場合は即座に `[]` を返す
+  → これがないと `queue = deque([None])` となり `node.val` アクセスでクラッシュする
+- `while queue`：キューが空になった（全ノードを処理し終えた）ときにループを終了する
+  → これにより無限ループにならない
+
+### 4. 終了性（＝アルゴリズムが必ず有限ステップで終わるという保証）
+
+- ノード数は有限（最大 2000）
+- 各ノードはキューから取り出されると二度と積まれない（子ノードを追加するだけ）
+- したがって `popleft()` の合計呼び出し回数はノード数 n に等しく、ループは必ず終了する
+
+> 📖 **この章で登場した用語**
+>
+> - **不変条件**：アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件
+> - **網羅性**：すべてのケースをもれなく処理できているという保証
+> - **基底条件**：処理を打ち切る（または再帰を終了させる）条件
+> - **終了性**：アルゴリズムが必ず有限ステップで終わるという保証
+
+---
+
+<h2 id="complexity">計算量</h2>
+
+> 💡 **計算量** とは「入力が大きくなるにつれて、処理にかかる時間・メモリがどう増えるか」の目安です。
+
+| 記法         | 意味                   | 直感的なイメージ           |
+| ------------ | ---------------------- | -------------------------- |
+| `O(1)`       | 入力サイズによらず一定 | 辞書で直接ページを開く     |
+| `O(n)`       | 入力に比例して増加     | リストを端から順に読む     |
+| `O(n log n)` | n よりやや速く増加     | ソートアルゴリズムの典型   |
+| `O(n²)`      | 入力の2乗で増加        | 全ペアを総当たりで確認する |
+
+---
+
+### 時間計算量：O(n)
+
+- 各ノードはキューへの追加（`append`）とキューからの取り出し（`popleft`）を1回ずつ行う
+- どちらも `deque` の O(1) 操作なので、n ノード全体で O(n)
+- 結果配列へのリスト追加（`result.append(vals)`）も合計 O(n)
+
+### 空間計算量：O(n)
+
+- `result`（出力配列）：全ノードの値を格納するため O(n)
+- `queue`（キュー）：最大で「最も広い階のノード数」が同時に入る
+  完全二分木の最下層は最大 n/2 ノードなので O(n)
+
+---
+
+### `list.pop(0)` を使った場合との比較
+
+「`list.pop(0)` ではダメなのか」を疑問に思う方のために比較します。
+
+| 手法                          | `popleft()` 1回の計算量    | 全体の時間計算量 |
+| ----------------------------- | -------------------------- | ---------------- |
+| `collections.deque.popleft()` | O(1)                       | **O(n)** ✅      |
+| `list.pop(0)`                 | O(n)（残り全要素をシフト） | **O(n²)** ❌     |
+
+n = 2000 のとき、`list.pop(0)` を使うと最大 2000 × 2000 = **4,000,000 回**の操作が発生します。
+`deque.popleft()` ならば **2000 回**で済みます。
+
+> 📖 **この章で登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **O(n²)**：入力が2倍になると処理が約4倍になること。`list.pop(0)` を n 回呼ぶと発生する
+
+---
+
+<h2 id="impl">Python 実装</h2>
+
+> 💡 **コードを読む前に、実装の全体的な骨格を確認しましょう。**
+>
+> 1. `root is None` チェックで空ツリーを即返す
+> 2. `result`（結果格納用）と `queue`（BFS用）を初期化する
+> 3. `while queue` でキューが空になるまでループ
+> 4. `level_size = len(queue)` で今の階のサイズを**変数に保存して固定**する（核心）
+> 5. `level_size` 回だけ `popleft()` し、値の収集と子の登録を行う
+> 6. 今の階の値リストを `result` に追加する
+> 7. すべての階を処理し終えたら `result` を返す
+
+---
+
+### 業務開発版（型安全・pylance 対応）
+
+チームで長期間メンテナンスするプロダクションコードに向きます。
+型ヒントとコメントを充実させることで、後から読んだ人が意図を理解しやすい構造です。
+
+```python
+from __future__ import annotations
+
+# TYPE_CHECKING は pylance などの型チェッカーが動くときだけ True になる特殊フラグ。
+# これを使うことで「型チェック時のみ import する」定義を書ける。
+# 実行時（LeetCode のジャッジ）では TreeNode は既に定義済みなので import 不要。
+from typing import TYPE_CHECKING, Optional
+from collections import deque
+
+if TYPE_CHECKING:
+    # pylance に TreeNode の構造を教えるための型スタブ（型情報のみの定義）。
+    # 実行時には評価されないため、LeetCode 環境でエラーにならない。
+    class TreeNode:
+        val: int
+        left: Optional[TreeNode]
+        right: Optional[TreeNode]
+        def __init__(
+            self,
+            val: int = 0,
+            left: Optional[TreeNode] = None,
+            right: Optional[TreeNode] = None,
+        ) -> None: ...
+
+
+class Solution:
+    """
+    LeetCode #102 Binary Tree Level Order Traversal
+
+    BFS（幅優先探索）+ collections.deque を使って
+    木を上から下へ階層ごとにグループ化して返す。
+    """
+
+    def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        """
+        二分木のレベル順トラバーサルを返す（業務開発版）。
+
+        Args:
+            root: 二分木のルートノード。None の場合は空ツリーを意味する。
+
+        Returns:
+            各階層の値を格納した2次元リスト。
+            空ツリーの場合は空リスト [] を返す。
+
+        Complexity:
+            Time:  O(n) — 各ノードを1回だけキューに出し入れする
+            Space: O(n) — キューに最大で最下層のノード数が入る
+        """
+        # ── 基底条件：root が None（空ツリー）なら即座に空リストを返す ──
+        # Optional[TreeNode] 型のため、None チェックをしないと
+        # pylance が「None に .val はない」とエラーを報告する。
+        # ここで弾いた後は、以降のコードで root を TreeNode として安全に扱える。
+        if root is None:
+            return []
+
+        # 結果を格納する2次元リスト。
+        # result[0] = 深さ0の値リスト、result[1] = 深さ1の値リスト、...
+        result: list[list[int]] = []
+
+        # collections.deque をキューとして使う。
+        # list.pop(0) は O(n) だが deque.popleft() は O(1)。
+        # deque はC言語実装の双方向キューで先頭・末尾への操作が高速。
+        queue: deque[TreeNode] = deque([root])
+
+        # キューが空になるまでループ（= 全ノードを処理し終えるまで）
+        while queue:
+            # ── BFS の核心：今の階のサイズをここで固定する ──
+            # ループ中に popleft()/append() が混在して queue の長さが変化するため、
+            # 先に変数へ保存しないと「今の階」の範囲がずれて Wrong Answer になる。
+            level_size: int = len(queue)
+
+            # 今の階のノード値を格納する一時リスト
+            level_values: list[int] = []
+
+            for _ in range(level_size):
+                # popleft() でキューの先頭ノードを O(1) で取り出す
+                node: TreeNode = queue.popleft()
+
+                # ノードの値を直接 append する。
+                # `or` トリックは val=0 のとき 0（falsy）と判定されて壊れるため使わない。
+                # 制約 -1000 <= val <= 1000 の範囲では 0 が普通に登場する。
+                level_values.append(node.val)
+
+                # 子ノードをキューの末尾に追加する（次の階の準備）。
+                # is not None でチェックすることで、
+                # キューの中身が常に TreeNode 型であると保証できる。
+                # pylance も None をキューに入れようとするとエラーを検出する。
+                if node.left is not None:
+                    queue.append(node.left)
+                if node.right is not None:
+                    queue.append(node.right)
+
+            # 今の階の値リストを結果に追加
+            result.append(level_values)
+
+        return result
+```
+
+---
+
+### 競技プログラミング版（速度・簡潔さ優先）
+
+LeetCode などで制限時間内に正解を出すことが目的のコードに向きます。
+型ヒントは最小限に抑えつつ、**`val=0` を含む全テストケースで正しく動作**します。
+
+```python
+from collections import deque
+from typing import Optional
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        # not root は「root が None」のとき True になる。
+        # TreeNode の __bool__ は未定義なので None チェックとして正しく機能する。
+        if not root:
+            return []
+
+        result: list[list[int]] = []
+        # C実装の deque でキューを初期化する。popleft() が O(1) のためキューとして最適。
+        queue: deque[TreeNode] = deque([root])
+
+        while queue:
+            # 今の階のサイズをループ前に固定する（絶対に省略できない）。
+            level_size = len(queue)
+            vals: list[int] = []
+
+            for _ in range(level_size):
+                node = queue.popleft()                    # 先頭ノードを O(1) で取得
+                vals.append(node.val)                     # val を直接追加（0 も正しく扱われる）
+                if node.left:                             # 左の子があればキューへ追加
+                    queue.append(node.left)
+                if node.right:                            # 右の子があればキューへ追加
+                    queue.append(node.right)
+
+            result.append(vals)
+
+        return result
+```
+
+---
+
+> 💡 **コードの動作トレース：`root = [3, 9, 20, null, null, 15, 7]`**
+
+```
+初期状態:
+  queue  = deque([Node(3)])
+  result = []
+
+━━ while ループ 1回目（深さ0） ━━
+  level_size = 1        ← len(queue) を変数に保存して固定
+  vals = []
+
+  i=0: node = queue.popleft() → Node(3)   queue = deque([])
+       vals.append(3) → [3]   ← val=3 を正しく追加
+       node.left  = Node(9)  → queue.append → deque([Node(9)])
+       node.right = Node(20) → queue.append → deque([Node(9), Node(20)])
+
+  result.append([3]) → result = [[3]]
+
+━━ while ループ 2回目（深さ1） ━━
+  level_size = 2        ← キューに Node(9), Node(20) の2つが入っている
+  vals = []
+
+  i=0: node = Node(9)    queue = deque([Node(20)])
+       vals.append(9)  → [9]
+       left=None, right=None → スキップ
+
+  i=1: node = Node(20)   queue = deque([])
+       vals.append(20) → [9, 20]
+       left=Node(15)  → deque([Node(15)])
+       right=Node(7)  → deque([Node(15), Node(7)])
+
+  result.append([9, 20]) → result = [[3], [9, 20]]
+
+━━ while ループ 3回目（深さ2） ━━
+  level_size = 2
+  i=0: Node(15) → vals=[15]    子なし
+  i=1: Node(7)  → vals=[15, 7] 子なし
+
+  result.append([15, 7]) → result = [[3], [9, 20], [15, 7]]
+
+━━ queue が空 → ループ終了 ━━
+戻り値: [[3], [9, 20], [15, 7]] ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **`from __future__ import annotations`**：型ヒントを文字列として扱い、前方参照や循環参照を解決できるようにする宣言
+> - **`TYPE_CHECKING`**：pylance などの型チェッカーが動くときだけ `True` になる特殊フラグ。実行時は `False`
+> - **`Optional[X]`**：`X` または `None` のどちらかであることを表す型ヒント
+> - **型スタブ**：実行はされないが型チェッカーに型情報を教えるためだけの定義
+> - **`deque([root])`**：`deque` を初期値ありで生成する書き方
+
+---
+
+<h2 id="cpython">CPython 最適化ポイント</h2>
+
+> 💡 **この章では「同じ処理でも Python の書き方によって速さが変わる理由」を説明します。**
+> 最適化テクニックは「最適化前 → 最適化後 → なぜ速くなるか」の3点セットで示します。
+
+---
+
+### ① `list.pop(0)` → `deque.popleft()` への置き換え
+
+```python
+# 最適化前：list の先頭取り出し（遅い）
+queue = [root]
+node = queue.pop(0)   # O(n): 残り全要素を1つずつ前にシフトする
+
+# 最適化後：deque の先頭取り出し（速い）
+from collections import deque
+queue = deque([root])
+node = queue.popleft()  # O(1): 双方向連結リストの先頭ポインタを1つ進めるだけ
+```
+
+**なぜ速くなるか：**
+`list.pop(0)` は Python の `list` が内部で「配列」として実装されているため、
+先頭を取り出すと残り全要素を1つ前にずらす処理が走ります（O(n)）。
+`deque` は「双方向連結リスト」として実装されているため、先頭ポインタを1つ進めるだけで済みます（O(1)）。
+`deque` の実装はC言語で書かれているため、Pure Python のループより大幅に高速です。
+
+---
+
+### ② `or` トリックを使わない
+
+```python
+# 最適化前（競技版でよく見る書き方）：val=0 で壊れる ❌
+result.append([
+    (node := queue.popleft()).val
+    or queue.extend(c for c in (node.left, node.right) if c)
+    for _ in range(len(queue))
+])
+
+# 最適化後：シンプルな for ループ + append() ✅
+for _ in range(level_size):
+    node = queue.popleft()
+    vals.append(node.val)   # val=0 でも正しく追加される
+    if node.left:
+        queue.append(node.left)
+    if node.right:
+        queue.append(node.right)
+```
+
+**なぜ `or` トリックが壊れるか：**
+Python の `or` 演算子は「左辺が falsy（`0`, `None`, `False`, `[]` など）のとき右辺を評価する」性質を持ちます。
+`val = 0` のとき `0 or queue.extend(...)` は `extend()` を実行し、その戻り値は `None`。
+結果として `None` がリストに混入し、Wrong Answer になります。
+制約 `-1000 <= val <= 1000` では `0` は普通に登場するため、このバグは必ず踏みます。
+
+---
+
+### ③ `Vec::with_capacity` 相当：`list` の事前確保
+
+```python
+# 最適化前：サイズが分からない状態でリストを作る
+vals = []
+
+# 最適化後：サイズが分かっているときは初期容量を指定する（Python ではリスト内包表記で代用）
+# ただし今回は append() の順序が重要なため、内包表記への置き換えは行わない。
+# level_size が分かっているので「最大 level_size 回の append()」が保証されており、
+# CPython の list は amortized O(1) で append するため実用上は問題ない。
+vals = []  # level_size 回の append() は amortized O(1)
+```
+
+**なぜ問題にならないか：**
+CPython の `list.append()` は内部で「容量が足りなくなったら2倍に拡張する」戦略（amortized O(1)）を採用しています。
+n 回の `append()` 全体では O(n) になるため、今回の実装では追加の最適化は不要です。
+
+> 📖 **この章で登場した用語**
+>
+> - **双方向連結リスト**：各要素が「前の要素」と「次の要素」へのポインタを持つデータ構造。先頭・末尾への操作が O(1)
+> - **amortized O(1)**：1回の操作は最悪 O(n) になることがあるが、n 回の操作を平均するとO(1) になること
+> - **falsy**：Pythonで `if` 条件が `False` 相当と見なされる値。`0`, `None`, `[]`, `""` などが該当する
+> - **Pure Python**：C言語の拡張を使わず Python のみで書かれたコード。C実装より遅い
+
+---
+
+<h2 id="edgecases">エッジケースと検証観点</h2>
+
+> 💡 **エッジケース** とは「入力が空・最小値・最大値・特殊な構造」など、通常とは異なる境界的な入力のことです。
+> エッジケースを見落とすと、普通のテストは通るのに特定の入力でだけバグが発生します。
+
+| ケース                       | 入力                    | 期待出力                 | なぜ問題になりうるか                                               | 対処箇所                                    |
+| ---------------------------- | ----------------------- | ------------------------ | ------------------------------------------------------------------ | ------------------------------------------- |
+| 空ツリー                     | `root = None`           | `[]`                     | `queue.popleft()` や `node.val` にアクセスするとクラッシュする     | `if root is None: return []`                |
+| ノード1つ                    | `root = Node(1)`        | `[[1]]`                  | 子が存在しないため、子の追加ループがスキップされる必要がある       | `if node.left` で `None` を自然に弾く       |
+| `val = 0` のノード           | `root = Node(0)`        | `[[0]]`                  | `or` トリックで `0` が falsy と判定されて `None` が混入する        | `vals.append(node.val)` で直接追加          |
+| 左のみ偏った木               | `1→2→3`（左の子のみ）   | `[[1],[2],[3]]`          | 各階層にノードが1つずつ。`level_size=1` が毎回設定される必要がある | `level_size = len(queue)` が毎回正しく動く  |
+| 右のみ偏った木               | `1→2→3`（右の子のみ）   | `[[1],[2],[3]]`          | 左のみ偏った木と同様                                               | 同上                                        |
+| 完全二分木（最大）           | 2000 ノード、すべて存在 | 最下層に最大 1000 ノード | キューに 1000 ノードが同時に入る。`deque` なら問題なく処理できる   | O(1) の `popleft()` で十分に高速            |
+| `val = -1000` / `val = 1000` | 制約境界値              | そのまま返す             | 整数範囲の端の値が正しく扱われるか                                 | `append(node.val)` は整数をそのまま追加する |
+| すべてのノードの値が同じ     | 全ノード `val = 5`      | 各階層に `5` が並ぶ      | 値の比較は不要なので影響しないが、重複値でも正しく動くか確認が必要 | `append(node.val)` は値を問わず追加する     |
+
+> 📖 **この章で登場した用語**
+>
+> - **エッジケース**：空のリスト・要素1つ・最大サイズ入力など、境界的な条件の入力
+> - **境界値**：制約の上限・下限にあたる値。例：ノード値 -1000 や 1000
+> - **偏った木（skewed tree）**：左または右の子のみを持つノードが連続した、ほぼリスト状の木構造
+
+---
+
+<h2 id="faq">FAQ</h2>
+
+> 💡 **FAQ（Frequently Asked Questions）** とは「よくある質問と回答」のことです。
+> 初学者がつまずきやすいポイントを想定した質問をまとめています。
+> 各回答は「**結論 → 理由 → 補足（具体例）**」の順で書いています。
+
+---
+
+**Q1. なぜ `list.pop(0)` ではなく `collections.deque` を使うのですか？**
+
+**結論：** `list.pop(0)` はキューとして使うと全体の計算量が O(n²) になるため使いません。
+
+**理由：**
+Python の `list` は内部で「連続したメモリ領域（配列）」として実装されています。
+先頭要素を取り出す `pop(0)` は、残り全要素を1つずつ前にずらす処理が走るため O(n) かかります。
+これを n 回繰り返すと O(n²) になり、n=2000 では 4,000,000 回の操作が発生します。
+
+**補足：**
+`deque` は「双方向連結リスト」として実装されており、先頭・末尾への操作が O(1)。
+n 回の `popleft()` 全体でも O(n) で済みます。
+
+---
+
+**Q2. `level_size = len(queue)` を変数に保存しないとどうなりますか？**
+
+**結論：** `for _ in range(len(queue))` と直接書くと、「今の階」の範囲がずれて Wrong Answer になります。
+
+**理由：**
+`range(len(queue))` はループ開始時に1回だけ評価されます。
+しかし `len(queue)` はあくまで「その時点」のサイズを返すだけで、
+ループ中に `popleft()` で減り `append()` で増えるため、次の階のノードも今の階として処理してしまいます。
+
+**補足：**
+
+```python
+# 危険な書き方（level_size を固定しない）
+while queue:
+    for _ in range(len(queue)):    # ← この len(queue) はループ開始時点の値のみ
+        node = queue.popleft()     # 取り出すたびに queue が縮む
+        if node.left:
+            queue.append(node.left)  # 追加で queue が増える → 次の階も処理してしまう
+
+# 正しい書き方（level_size を固定する）
+while queue:
+    level_size = len(queue)        # ← この時点でのサイズを変数に保存して固定
+    for _ in range(level_size):
+        ...
+```
+
+---
+
+**Q3. なぜ前回の競技版で `or` トリックを使ったのに Wrong Answer になったのですか？**
+
+**結論：** `val = 0` のノードがあると `0 or 式` の `0` が falsy と判定されて壊れます。
+
+**理由：**
+Python の `or` 演算子は「左辺が falsy なら右辺を評価して返す」性質を持ちます。
+`val = 0` のとき `node.val` は `0` なので、`0 or queue.extend(...)` の左辺は falsy と判定されます。
+その結果 `queue.extend(...)` が実行され、その戻り値（`None`）がリスト内包表記の要素として入ってしまいます。
+
+**補足：**
+制約 `-1000 <= val <= 1000` には `0` が含まれており、LeetCode の 2〜3 番目のテストケース付近で確実に踏みます。
+`vals.append(node.val)` と直接書けばどんな値でも正しく処理できます。
+
+---
+
+**Q4. `if node.left:` と `if node.left is not None:` の違いは何ですか？どちらを使うべきですか？**
+
+**結論：** どちらも今回の問題では同じ動作をしますが、意図の明確さから `is not None` が推奨されます。
+
+**理由：**
+`TreeNode` は `__bool__` メソッドを定義していないため、`if node.left:` は「`None` かどうか」を判定しています。
+一方 `if node.left is not None:` は「`None` でないこと」を明示的に表現しており、読み手に意図が伝わりやすいです。
+pylance も `is not None` を推奨します（PEP8 準拠）。
+
+**補足：**
+競技プログラミング版では入力速度を重視して `if node.left:` と短く書くこともあります。
+業務開発版では `is not None` を使って意図を明確にするのが良い習慣です。
+
+---
+
+**Q5. BFS と DFS のどちらを使っても答えは同じになりますか？どちらが良いですか？**
+
+**結論：** 両方でも正解は得られますが、**この問題には BFS の方が自然で実装しやすい**です。
+
+**理由：**
+DFS（深さ優先探索）は縦方向に深く潜るため、「同じ深さのノードをまとめる」処理のために
+「今どの深さにいるか」という情報を引数やデータ構造で別途管理する必要があります。
+BFS は「同じ深さのノードをまとめて処理してから次へ進む」動き方をするため、
+`level_size = len(queue)` だけで自然に階層分けができます。
+
+**補足：**
+DFS で解く場合はこのような設計になります：
+
+```python
+# DFS版（参考）：深さ情報を引数で持ち回る必要がある
+def dfs(node: Optional[TreeNode], depth: int, result: list[list[int]]) -> None:
+    if node is None:
+        return
+    if len(result) == depth:       # 今の深さの配列がまだない場合は追加
+        result.append([])
+    result[depth].append(node.val) # 深さをインデックスとして値を追加
+    dfs(node.left, depth + 1, result)
+    dfs(node.right, depth + 1, result)
+```
+
+BFS 版と比べてコードが複雑になり、再帰の深さがツリーの高さに比例してスタックを消費するデメリットもあります。
+
+> 📖 **この章で登場した用語**
+>
+> - **FAQ**：Frequently Asked Questions の略。よくある質問と回答のこと
+> - **falsy**：Pythonで `if` 条件が `False` 相当と見なされる値。`0`, `None`, `[]` などが該当する
+> - **PEP8**：Pythonの公式スタイルガイド。`== None` より `is None` / `is not None` を推奨する
+> - **DFS（深さ優先探索）**：グラフや木を「縦方向に深く潜りながら」探索する方法。スタックや再帰で実装する
+> - **スタック**：後に入れたものを先に取り出す（LIFO）データ構造。関数の再帰呼び出しはスタックを消費する
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html
new file mode 100644
index 00000000..2b92a392
--- /dev/null
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html	
@@ -0,0 +1,1341 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1.0" />
+        <title>LeetCode 102 · Binary Tree Level Order Traversal</title>
+        <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>
+        <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
+        <script src="https://cdn.tailwindcss.com"></script>
+        <script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
+        <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;500;700&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <link
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css"
+            rel="stylesheet"
+        />
+        <link
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.css"
+            rel="stylesheet"
+        />
+        <link
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.css"
+            rel="stylesheet"
+        />
+        <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;
+            }
+            .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;
+            }
+            details[open] > summary .arrow {
+                transform: rotate(90deg);
+            }
+            .arrow {
+                display: inline-block;
+                transition: transform 0.2s;
+            }
+
+            /* ── Mermaid カスタムスタイル ── */
+            .mermaid-wrapper {
+                background: linear-gradient(135deg, #f0fdf4 0%, #e0f2fe 100%);
+                border: 2px solid #a7f3d0;
+                border-radius: 20px;
+                padding: 28px 16px;
+                overflow-x: auto;
+            }
+            .mermaid-wrapper .mermaid {
+                display: flex;
+                justify-content: center;
+            }
+            /* ノードラベルの日本語フォント */
+            .mermaid svg text {
+                font-family: 'Noto Sans JP', 'JetBrains Mono', sans-serif !important;
+            }
+        </style>
+    </head>
+    <body
+        class="min-h-screen"
+        style="background: linear-gradient(135deg, #f0fdf4 0%, #e0f2fe 50%, #fdf4ff 100%)"
+    >
+        <div class="max-w-5xl mx-auto px-4 py-8">
+            <!-- ===== HEADER ===== -->
+            <header
+                id="header"
+                class="mb-8 rounded-3xl p-8 shadow-xl"
+                style="background: linear-gradient(135deg, #d1fae5 0%, #bfdbfe 60%, #ede9fe 100%)"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="outfit bg-emerald-600 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >LeetCode #102</span
+                    >
+                    <span
+                        class="outfit bg-sky-500 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >Medium</span
+                    >
+                    <span
+                        class="outfit bg-violet-500 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >BFS</span
+                    >
+                </div>
+                <h1 class="outfit text-4xl font-black text-teal-900 mb-1 leading-tight">
+                    Binary Tree Level Order Traversal
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold">
+                    BFS + collections.deque による O(n) 実装
+                </p>
+                <div
+                    class="mt-4 inline-block bg-white/70 rounded-2xl px-5 py-3 border border-white/80 shadow"
+                >
+                    <p class="text-teal-800 font-bold text-base">
+                        💡
+                        一言で言うと：「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」
+                    </p>
+                </div>
+                <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-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ===== OVERVIEW ===== -->
+            <section id="overview" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="mb-5 p-5 rounded-2xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-bold text-base">💡 この問題を一言で言うと：</p>
+                    <p class="text-slate-700 text-sm mt-2 leading-7">
+                        「木の同じ深さ（階層）にあるノードを全部集めて1つのリストにまとめ、それを深さ順に並べた2次元配列を返す問題」です。<br />
+                        左から右の順番でノードを集める必要があります。
+                    </p>
+                </div>
+
+                <div class="mb-5 p-5 rounded-2xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-bold text-sm mb-3">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-700 text-sm space-y-2 list-disc list-inside leading-7">
+                        <li>
+                            「縦方向（深さ優先）」に探索するだけでは、同じ深さのノードをまとめる境界が分からない
+                        </li>
+                        <li>
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">list.pop(0)</code>
+                            を使うと先頭削除が O(n) になり全体が O(n²) へ悪化する
+                        </li>
+                        <li>
+                            ノードの値が
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">0</code>
+                            のとき、<code class="bg-amber-100 px-1 rounded mono text-xs">or</code>
+                            トリックは
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">0</code
+                            >（falsy）と誤判定して壊れる
+                        </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-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-2xl">O(n)</div>
+                        <div class="text-xs mt-1 font-semibold">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-2xl">O(n)</div>
+                        <div class="text-xs mt-1 font-semibold">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-lg mono break-all leading-tight">
+                            deque
+                        </div>
+                        <div class="text-xs mt-1 font-semibold">データ構造</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-lg">BFS</div>
+                        <div class="text-xs mt-1 font-semibold">探索手法</div>
+                    </div>
+                </div>
+
+                <div class="rounded-2xl bg-slate-50 border border-slate-200 p-5 mb-4">
+                    <p class="text-slate-600 font-bold text-sm mb-3">📥 入出力例</p>
+                    <div class="grid md:grid-cols-2 gap-4">
+                        <div>
+                            <p class="text-xs text-slate-500 mb-1 font-semibold">入力（ツリー）</p>
+                            <pre
+                                class="mono text-sm bg-slate-800 text-emerald-300 rounded-xl p-4 leading-6"
+                            >
+    3
+   / \
+  9  20
+     / \
+    15   7</pre
+                            >
+                        </div>
+                        <div>
+                            <p class="text-xs text-slate-500 mb-1 font-semibold">出力と理由</p>
+                            <pre
+                                class="mono text-sm bg-slate-800 text-sky-300 rounded-xl p-4 leading-6"
+                            >
+[[3],[9,20],[15,7]]
+
+深さ0 → [3]
+深さ1 → [9, 20]  ← 左から右
+深さ2 → [15, 7]  ← 左から右</pre
+                            >
+                        </div>
+                    </div>
+                </div>
+
+                <div class="rounded-2xl bg-slate-50 border border-slate-200 p-5">
+                    <p class="text-slate-600 font-bold text-sm mb-2">📋 制約</p>
+                    <ul class="text-sm text-slate-600 space-y-1 list-disc list-inside">
+                        <li>ノード数：0 以上 2000 以下</li>
+                        <li>ノードの値：<strong>-1000 以上 1000 以下（0 が含まれる）</strong></li>
+                    </ul>
+                </div>
+            </section>
+
+            <!-- ===== STEPS (React) ===== -->
+            <section id="steps" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-2 pb-3 border-b-4 border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-6">
+                    各ステップをクリックするか、▶ Play ボタンで自動再生できます。
+                </p>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ===== CODE ===== -->
+            <section id="code" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-5 p-5 rounded-2xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-bold text-sm mb-3">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-2 list-decimal list-inside leading-7">
+                        <li>
+                            <strong>空ツリーのチェック</strong>：root が None なら即座に [] を返す
+                        </li>
+                        <li>
+                            <strong>deque の初期化</strong>：root をキューに入れて BFS 開始の準備
+                        </li>
+                        <li>
+                            <strong>while ループ</strong>：キューが空になるまで、階層ごとに処理する
+                        </li>
+                        <li>
+                            <strong>level_size の固定</strong
+                            >：今の階のサイズをここで確定させる（核心）
+                        </li>
+                        <li>
+                            <strong>for ループ</strong>：level_size 個だけ popleft()
+                            し、値収集と子の登録を行う
+                        </li>
+                        <li><strong>結果への追加</strong>：今の階の値リストを result に追加する</li>
+                    </ol>
+                </div>
+
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from collections import deque
+from typing import Optional
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        # 基底条件: root が None（空ツリー）なら即座に空リストを返す
+        # None チェックをしないと後続の node.val アクセスでクラッシュする
+        if root is None:
+            return []
+
+        result: list[list[int]] = []
+
+        # collections.deque をキューとして使う
+        # list.pop(0) は O(n) だが deque.popleft() は O(1)
+        # deque は C言語実装の双方向キューで先頭・末尾への操作が高速
+        queue: deque[TreeNode] = deque([root])
+
+        # キューが空になるまでループ（= 全ノードを処理し終えるまで）
+        while queue:
+            # ── BFS の核心：今の階のサイズをここで固定する ──
+            # ループ中に popleft()/append() で queue の長さが変化するため
+            # 先に変数へ保存しないと「今の階」の範囲がずれて Wrong Answer になる
+            level_size: int = len(queue)
+            level_values: list[int] = []
+
+            for _ in range(level_size):
+                # popleft() でキューの先頭ノードを O(1) で取り出す
+                node: TreeNode = queue.popleft()
+
+                # val を直接 append する（0 も正しく追加される）
+                # `or` トリックは val=0 のとき falsy と判定されて壊れるため使わない
+                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)
+
+            result.append(level_values)
+
+        return result</code></pre>
+
+                <div class="mt-5 p-5 rounded-2xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-bold text-sm mb-3">
+                        ▶ 入力例 [3, 9, 20, null, null, 15, 7] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs mono leading-7 overflow-x-auto whitespace-pre"
+                    >
+初期状態: queue = deque([Node(3)]),  result = []
+
+━━ ループ 1回目（深さ0） ━━
+  level_size = 1   ← ここで固定！
+  vals = []
+  i=0: popleft() → Node(3)   queue = deque([])
+       append(3)  → vals = [3]
+       left=Node(9)  → queue = deque([Node(9)])
+       right=Node(20) → queue = deque([Node(9), Node(20)])
+  result = [[3]]
+
+━━ ループ 2回目（深さ1） ━━
+  level_size = 2   ← ここで固定！
+  i=0: Node(9)  → vals=[9]       子なし
+  i=1: Node(20) → vals=[9,20]    left=Node(15), right=Node(7)
+  result = [[3], [9, 20]]
+
+━━ ループ 3回目（深さ2） ━━
+  level_size = 2
+  i=0: Node(15) → vals=[15]      子なし
+  i=1: Node(7)  → vals=[15,7]    子なし
+  result = [[3], [9, 20], [15, 7]]
+
+queue が空 → ループ終了
+戻り値: [[3], [9, 20], [15, 7]] ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ===== FLOWCHART ===== -->
+            <section id="diagram" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <!-- 凡例 -->
+                <div class="mb-6 p-5 rounded-2xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-bold text-sm mb-4">
+                        🗺️ フローチャートの読み方（Mermaid 記法）
+                    </p>
+                    <div
+                        class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700"
+                    >
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded-full bg-emerald-100 border-2 border-emerald-500 text-emerald-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >([…])</span
+                            >
+                            <span>スタジアム形（緑）<br />= 開始・終了</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded-lg bg-sky-100 border-2 border-sky-400 text-sky-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >[…]</span
+                            >
+                            <span>四角形（青）<br />= 処理ステップ</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded bg-amber-100 border-2 border-amber-400 text-amber-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >{…}</span
+                            >
+                            <span>ひし形（黄）<br />= 条件分岐</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span class="flex flex-col gap-1">
+                                <span class="flex items-center gap-1"
+                                    ><span
+                                        class="inline-block w-6 h-0.5 bg-emerald-500 rounded"
+                                    ></span
+                                    ><span class="text-emerald-700 font-semibold"
+                                        >Yes（はい）</span
+                                    ></span
+                                >
+                                <span class="flex items-center gap-1"
+                                    ><span class="inline-block w-6 h-0.5 bg-red-400 rounded"></span
+                                    ><span class="text-red-600 font-semibold"
+                                        >No（いいえ）</span
+                                    ></span
+                                >
+                            </span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Mermaid フローチャート（JS経由でレンダリング・HTMLパーサーを完全回避） -->
+                <div class="mermaid-wrapper">
+                    <div
+                        id="mermaid-render-target"
+                        style="
+                            display: flex;
+                            justify-content: center;
+                            min-height: 120px;
+                            align-items: center;
+                        "
+                    >
+                        <span style="color: #94a3b8; font-size: 13px">読み込み中…</span>
+                    </div>
+                </div>
+
+                <!-- 色の意味の補足 -->
+                <div class="mt-4 flex flex-wrap gap-3 text-xs">
+                    <span
+                        class="inline-flex items-center gap-2 bg-emerald-50 border border-emerald-200 rounded-full px-3 py-1.5 text-emerald-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-emerald-400 inline-block"></span> 緑 =
+                        開始・終了ノード
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-sky-50 border border-sky-200 rounded-full px-3 py-1.5 text-sky-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-blue-400 inline-block"></span> 青 =
+                        通常の処理
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-amber-50 border border-amber-200 rounded-full px-3 py-1.5 text-amber-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-amber-400 inline-block"></span> 黄 =
+                        条件分岐
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-violet-50 border border-violet-200 rounded-full px-3 py-1.5 text-violet-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-violet-400 inline-block"></span> 紫 =
+                        BFS の核心処理
+                    </span>
+                </div>
+
+                <!-- フロー追跡 -->
+                <div class="mt-6 p-5 rounded-2xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-bold 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>「Start」 → root=Node(3) を受け取る</li>
+                        <li>
+                            「root is None?」 → いいえ → 初期化: result=[], queue=deque([Node(3)])
+                        </li>
+                        <li>
+                            「queue は空?」 → いいえ（Node(3) がある）→
+                            <strong class="text-violet-700">level_size=1</strong>, vals=[]
+                        </li>
+                        <li>
+                            「i &lt; 1?」 → はい → popleft()=Node(3), vals=[3], left=Node(9)→追加,
+                            right=Node(20)→追加
+                        </li>
+                        <li>「i &lt; 1?」 → いいえ → result.append([3]) → ループバック</li>
+                        <li>
+                            （深さ1）<strong class="text-violet-700">level_size=2</strong>,
+                            Node(9)→vals=[9], Node(20)→vals=[9,20], Node(15)&amp;Node(7)追加
+                        </li>
+                        <li>
+                            （深さ2）<strong class="text-violet-700">level_size=2</strong>,
+                            Node(15)→vals=[15], Node(7)→vals=[15,7]
+                        </li>
+                        <li>
+                            「queue は空?」 → はい → 「return result」へ → [[3],[9,20],[15,7]] ✅
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ===== COMPLEXITY ===== -->
+            <section id="complexity" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <div class="mb-6 p-5 rounded-2xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-bold text-sm mb-4">
+                        📖 Big-O 記法の読み方（n = ノード数）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs">
+                        <div class="text-center p-4 rounded-xl bg-emerald-100 text-emerald-800">
+                            <div class="outfit font-black text-xl mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-sky-100 text-sky-800">
+                            <div class="outfit font-black text-xl mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-amber-100 text-amber-800">
+                            <div class="outfit font-black text-xl mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-amber-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-red-100 text-red-800">
+                            <div class="outfit font-black text-xl mb-1 mono">list.pop(0)</div>
+                            <div class="leading-5">
+                                先頭削除は O(n)<br /><span class="text-red-600"
+                                    >全体 O(n²) になる</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto rounded-2xl border border-slate-200 mb-5">
+                    <table class="w-full text-sm text-left">
+                        <thead>
+                            <tr class="bg-gradient-to-r from-emerald-50 to-sky-50">
+                                <th class="px-5 py-3 font-bold text-slate-700">種別</th>
+                                <th class="px-5 py-3 font-bold text-slate-700">計算量</th>
+                                <th class="px-5 py-3 font-bold text-slate-700">理由</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-t border-slate-100">
+                                <td class="px-5 py-3 font-semibold text-emerald-700">時間計算量</td>
+                                <td class="px-5 py-3 mono font-bold text-emerald-800">O(n)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    各ノードを popleft() で1回だけ処理（O(1)×n回）
+                                </td>
+                            </tr>
+                            <tr class="border-t border-slate-100 bg-slate-50/50">
+                                <td class="px-5 py-3 font-semibold text-sky-700">空間計算量</td>
+                                <td class="px-5 py-3 mono font-bold text-sky-800">O(n)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    キューに最大で最下層のノード数（最大 n/2 個）が入る
+                                </td>
+                            </tr>
+                            <tr class="border-t border-slate-100">
+                                <td class="px-5 py-3 font-semibold text-red-600">
+                                    比較：list.pop(0)
+                                </td>
+                                <td class="px-5 py-3 mono font-bold text-red-700">O(n²)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    先頭削除のたびに残り全要素をシフト（O(n)×n回）
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <div class="p-5 rounded-2xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-bold text-sm mb-2">
+                        🔍 なぜこの計算量になるのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        全ノード数を n とすると、各ノードはキューへの
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">append()</code
+                        >（O(1)）と
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">popleft()</code
+                        >（O(1)）を1回ずつ行うため、 合計操作回数は 2n =
+                        <strong>O(n)</strong> です。 空間については、完全二分木の最下層に最大 n/2
+                        個のノードが集まるため、 キューの最大サイズは O(n) となります。
+                        これは出力配列 result のサイズも同様で、全ノードの値を格納するため O(n)
+                        です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===== GLOSSARY ===== -->
+            <section id="glossary" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-3 pb-3 border-b-4 border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-6">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたときに参照してください。
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> BFS（幅優先探索）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Breadth-First Search
+                            の略。グラフや木を「横方向に広がりながら」探索する方法。
+                            同じ深さのノードをすべて処理してから次の深さへ進む。
+                            「エレベーターで同じ階を全部回ってから次の階へ行く」イメージ。
+                            この問題では「同じ階層のノードをまとめる」処理と自然に一致するため選ばれる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> Big-O 記法
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            アルゴリズムの「入力サイズが大きくなるにつれて処理時間やメモリがどう増えるか」を表す記法。
+                            O(1) は常に一定、O(n) は入力に比例、O(n²) は入力の2乗で増加する。
+                            実際の秒数ではなく「増え方の傾向」を表す。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> deque（デック）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            のこと。 Doubly-Ended Queue（両端キュー）の略。前からも後ろからも O(1)
+                            で出し入れできる「両端開きの箱」。 Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list</code>
+                            の先頭削除は O(n) だが、 deque の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">popleft()</code> は
+                            O(1)。 C言語で実装されており高速。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> falsy（フォールシー）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">if</code>
+                            の条件式で
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">False</code>
+                            相当と見なされる値。
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">0</code>、<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >None</code
+                            >、<code class="bg-slate-100 px-1 rounded mono text-xs">[]</code>、<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >""</code
+                            >
+                            などが該当する。 ノードの値
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">val = 0</code> は
+                            falsy なので、
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">0 or 式</code>
+                            という書き方は「0のとき右辺を実行する」という誤動作を引き起こす。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> FIFO（先入れ先出し）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            First In, First Out の略。最初に入れたものを最初に取り出す順序。
+                            銀行の窓口の行列と同じ仕組み。キューはこの性質を持つ。 BFS
+                            はこの性質を利用して「深さが浅いノードから順番に処理する」を実現する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> キュー（Queue）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            先に入れたものを先に取り出す（FIFO）データ構造。
+                            銀行の窓口の行列と同じ。 BFS
+                            では「処理待ちのノード」をキューに積み、先頭から順番に処理することで
+                            「浅い順」に探索できる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span>
+                            level_size（階層サイズの固定）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            BFS の while ループの各反復の開始時に
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >level_size = len(queue)</code
+                            >
+                            で 「今の階のノード数」を変数に保存するテクニック。 ループ中に子の追加で
+                            queue の長さが変化するため、先に固定しないと
+                            「今の階」と「次の階」の境界が混在して Wrong Answer になる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> 二分木（Binary Tree）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            各ノードが「左の子」と「右の子」の最大2つを持つ木構造のデータ。
+                            木の頂点を「根（root）」と呼び、子を持たないノードを「葉（leaf）」と呼ぶ。
+                            根からあるノードまでの辺の数を「深さ（depth）」と呼ぶ。根の深さは 0。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> popleft()
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">deque</code>
+                            の先頭要素を O(1) で取り出すメソッド。
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list.pop(0)</code>
+                            は残り全要素を前にシフトするため O(n) かかるが、
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >deque.popleft()</code
+                            >
+                            は双方向連結リストの先頭ポインタを1つ進めるだけなので O(1)。 n=2000
+                            のとき、この差は 2000 回 vs 最大 4,000,000 回の操作差になる。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center text-slate-400 text-xs py-4 pb-8">
+                LeetCode #102 · Binary Tree Level Order Traversal · Python BFS 解説
+            </footer>
+        </div>
+
+        <!-- ===== MERMAID プログラマティックレンダリング =====
+  設計方針:
+  ① ダイアグラムを JS テンプレートリテラルで保持
+     → ブラウザの HTML パーサーをバイパスするため、
+       HTML エンティティ(&#40; 等)や `<` のエスケープが不要
+  ② mermaid.render() で SVG に変換 → innerHTML に注入
+     → <div class="mermaid"> の startOnLoad に依存しない
+  ③ htmlLabels:true により <br/> がラベル内で改行として機能
+===== -->
+        <script>
+            mermaid.initialize({
+                startOnLoad: false, // 手動で render() を呼ぶため false
+                theme: 'base',
+                flowchart: {
+                    useMaxWidth: true,
+                    htmlLabels: true, // <br/> を改行として扱う
+                    curve: 'basis',
+                    padding: 20,
+                    nodeSpacing: 50,
+                    rankSpacing: 55,
+                },
+                themeVariables: {
+                    primaryColor: '#dbeafe',
+                    primaryTextColor: '#1e3a5f',
+                    primaryBorderColor: '#2563eb',
+                    lineColor: '#64748b',
+                    secondaryColor: '#d1fae5',
+                    secondaryBorderColor: '#059669',
+                    tertiaryColor: '#fef3c7',
+                    tertiaryBorderColor: '#d97706',
+                    edgeLabelBackground: '#ffffff',
+                },
+            });
+
+            // ──────────────────────────────────────────────
+            // ダイアグラム定義（純粋な JS 文字列）
+            // ・<  →  そのまま書ける（HTML パーサーを経由しない）
+            // ・<br/> → htmlLabels:true でラベル内改行
+            // ・() [] は引用符付きラベル ["..."] 内で安全
+            // ──────────────────────────────────────────────
+            const BFS_DIAGRAM = `flowchart TD
+    S(["Start: levelOrder(root)"])
+    C1{"root is None?"}
+    R1(["return &lbrack;&rbrack;  ✅"])
+    A1["result = &lbrack;&rbrack;<br/>queue = deque(&lbrack;root&rbrack;)"]
+    C2{"queue は空?"}
+    R2(["return result  ✅"])
+    A2["level_size = len(queue)<br/>← 今の階のサイズを固定!<br/>vals = &lbrack;&rbrack;"]
+    C3{"i < level_size ?"}
+    A3["result.append(vals)<br/>→ 今の階が完成！"]
+    A4["node = queue.popleft()"]
+    A5["vals.append(node.val)<br/>※ val=0 も正しく追加"]
+    C4{"node.left あり?"}
+    A6["queue.append(node.left)"]
+    C5{"node.right あり?"}
+    A7["queue.append(node.right)"]
+    A8["i + 1 → for ループへ"]
+
+    S --> C1
+    C1 -- "はい（空ツリー）" --> R1
+    C1 -- "いいえ" --> A1
+    A1 --> C2
+    C2 -- "はい（全処理完了）" --> R2
+    C2 -- "いいえ" --> A2
+    A2 --> C3
+    C3 -- "いいえ（この階終了）" --> A3
+    A3 --> C2
+    C3 -- "はい" --> A4
+    A4 --> A5
+    A5 --> C4
+    C4 -- "あり" --> A6
+    C4 -- "なし" --> C5
+    A6 --> C5
+    C5 -- "あり" --> A7
+    C5 -- "なし" --> A8
+    A7 --> A8
+    A8 --> C3
+
+    classDef startEnd fill:#d1fae5,stroke:#059669,stroke-width:2px,color:#064e3b,font-weight:bold
+    classDef process  fill:#dbeafe,stroke:#2563eb,stroke-width:2px,color:#1e3a5f
+    classDef decision fill:#fef3c7,stroke:#d97706,stroke-width:2px,color:#78350f
+    classDef core     fill:#ede9fe,stroke:#7c3aed,stroke-width:2.5px,color:#3b0764,font-weight:bold
+
+    class S,R1,R2 startEnd
+    class A1,A3,A4,A5,A6,A7,A8 process
+    class C1,C2,C3,C4,C5 decision
+    class A2 core`;
+
+            // DOM 構築後にレンダリング
+            document.addEventListener('DOMContentLoaded', async function () {
+                const target = document.getElementById('mermaid-render-target');
+                try {
+                    const { svg } = await mermaid.render('bfs-flowchart-svg', BFS_DIAGRAM);
+                    target.innerHTML = svg;
+                } catch (err) {
+                    console.error('[Mermaid] render error:', err);
+                    target.innerHTML =
+                        '<p style="color:#dc2626;padding:16px;font-size:13px;">' +
+                        '⚠️ フローチャートの描画に失敗しました。コンソールを確認してください。</p>';
+                }
+            });
+        </script>
+
+        <!-- ===== REACT STEPS ===== -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空ツリーのチェック',
+                    desc:
+                        'root が None（空ツリー）かどうかを確認し、空なら即座に [] を返します。' +
+                        'なぜなら、None に対して .val や .left などにアクセスすると実行時エラーになるためです。' +
+                        '例）root=None → if root is None → return [] でここで終了。',
+                    visual: 'check_none',
+                    queue: [],
+                    result: [],
+                    level: -1,
+                },
+                {
+                    step: 2,
+                    title: 'result と queue を初期化',
+                    desc:
+                        '結果格納用の2次元リスト result=[] と、BFS用のキュー queue=deque([root]) を用意します。' +
+                        'deque を使う理由は popleft() が O(1) のため。list.pop(0) は O(n) になり遅くなります。' +
+                        '例）root=Node(3) → queue = deque([Node(3)])',
+                    visual: 'init',
+                    queue: ['Node(3)'],
+                    result: [],
+                    level: 0,
+                },
+                {
+                    step: 3,
+                    title: 'level_size を固定する（BFS の核心）',
+                    desc:
+                        'while ループの先頭で level_size = len(queue) を変数に保存します。' +
+                        'この値が「今の階のノード数」です。ループ中に queue が変化するため、先に固定しないとズレます。' +
+                        '例）queue = [Node(9), Node(20)] → level_size = 2 に固定',
+                    visual: 'fix_size',
+                    queue: ['Node(9)', 'Node(20)'],
+                    result: [['Node(3).val=3']],
+                    level: 1,
+                },
+                {
+                    step: 4,
+                    title: 'popleft() でノードを取り出す',
+                    desc:
+                        'queue.popleft() でキューの先頭ノードを O(1) で取り出し、その val を vals に追加します。' +
+                        'val が 0 のときも正しく追加されます（or トリックは val=0 で壊れるため使いません）。' +
+                        '例）popleft() → Node(9), vals.append(9) → vals=[9]',
+                    visual: 'popleft',
+                    queue: ['Node(20)'],
+                    result: [['3']],
+                    level: 1,
+                    vals: ['9'],
+                },
+                {
+                    step: 5,
+                    title: '子ノードをキューに追加する',
+                    desc:
+                        '取り出したノードの left / right が None でない場合、キューの末尾に追加します（次の階の準備）。' +
+                        'is not None でチェックすることで、キューに None が混入するのを防ぎます。' +
+                        '例）Node(20).left=Node(15) → queue.append(Node(15))',
+                    visual: 'push_children',
+                    queue: ['Node(20)', 'Node(15)', 'Node(7)'],
+                    result: [['3']],
+                    level: 1,
+                    vals: ['9'],
+                },
+                {
+                    step: 6,
+                    title: '今の階の値リストを result に追加',
+                    desc:
+                        'level_size 個分のノードを処理し終えたら vals を result に追加します。' +
+                        'これで「1つの階層分」の処理が完了し、次の while ループで次の階層へ進みます。' +
+                        '例）vals=[9,20] → result.append([9,20]) → result=[[3],[9,20]]',
+                    visual: 'append_level',
+                    queue: ['Node(15)', 'Node(7)'],
+                    result: [['3'], ['9', '20']],
+                    level: 2,
+                },
+            ];
+
+            function QueueViz({ items, highlight }) {
+                return (
+                    <div className="flex flex-wrap gap-2 items-center">
+                        <span className="text-xs text-slate-500 font-semibold mono">queue:</span>
+                        <span className="text-xs text-slate-400">[</span>
+                        {items.length === 0 && (
+                            <span className="text-xs text-slate-400 italic">空</span>
+                        )}
+                        {items.map((item, i) => (
+                            <span
+                                key={i}
+                                className={[
+                                    'mono text-xs px-2 py-1 rounded-lg font-bold border',
+                                    i === 0 && highlight
+                                        ? 'bg-emerald-200 border-emerald-500 text-emerald-800'
+                                        : 'bg-sky-100 border-sky-300 text-sky-800',
+                                ].join(' ')}
+                            >
+                                {item}
+                            </span>
+                        ))}
+                        <span className="text-xs text-slate-400">]</span>
+                    </div>
+                );
+            }
+
+            function ResultViz({ result }) {
+                return (
+                    <div className="flex flex-wrap gap-2 items-start">
+                        <span className="text-xs text-slate-500 font-semibold mono mt-1">
+                            result:
+                        </span>
+                        <span className="text-xs text-slate-400 mt-1">[</span>
+                        {result.length === 0 && (
+                            <span className="text-xs text-slate-400 italic mt-1">空</span>
+                        )}
+                        {result.map((level, i) => (
+                            <span
+                                key={i}
+                                className="mono text-xs px-2 py-1 rounded-lg bg-violet-100 border border-violet-300 text-violet-800 font-bold"
+                            >
+                                [{level.join(', ')}]
+                            </span>
+                        ))}
+                        <span className="text-xs text-slate-400 mt-1">]</span>
+                    </div>
+                );
+            }
+
+            function TreeViz({ highlightLevel }) {
+                const nodes = [
+                    { id: 0, val: 3, x: 200, y: 30, depth: 0 },
+                    { id: 1, val: 9, x: 100, y: 100, depth: 1 },
+                    { id: 2, val: 20, x: 300, y: 100, depth: 1 },
+                    { id: 3, val: 15, x: 220, y: 170, depth: 2 },
+                    { id: 4, val: 7, x: 380, y: 170, depth: 2 },
+                ];
+                const edges = [
+                    [0, 1],
+                    [0, 2],
+                    [2, 3],
+                    [2, 4],
+                ];
+                const colors = ['#d1fae5', '#bfdbfe', '#ede9fe'];
+                const borders = ['#059669', '#0284c7', '#7c3aed'];
+                return (
+                    <svg
+                        viewBox="0 0 460 210"
+                        style={{ width: '100%', maxWidth: '420px', height: 'auto' }}
+                    >
+                        {edges.map(([a, b], i) => (
+                            <line
+                                key={i}
+                                x1={nodes[a].x}
+                                y1={nodes[a].y + 16}
+                                x2={nodes[b].x}
+                                y2={nodes[b].y - 16}
+                                stroke="#cbd5e1"
+                                strokeWidth="2"
+                            />
+                        ))}
+                        {nodes.map((n) => (
+                            <g key={n.id}>
+                                <circle
+                                    cx={n.x}
+                                    cy={n.y}
+                                    r="22"
+                                    fill={highlightLevel === n.depth ? colors[n.depth] : '#f8fafc'}
+                                    stroke={
+                                        highlightLevel === n.depth ? borders[n.depth] : '#cbd5e1'
+                                    }
+                                    strokeWidth={highlightLevel === n.depth ? '3' : '1.5'}
+                                />
+                                <text
+                                    x={n.x}
+                                    y={n.y + 5}
+                                    textAnchor="middle"
+                                    fontSize="15"
+                                    fill={highlightLevel === n.depth ? '#1e293b' : '#94a3b8'}
+                                    fontWeight={highlightLevel === n.depth ? 'bold' : 'normal'}
+                                    fontFamily="JetBrains Mono"
+                                >
+                                    {n.val}
+                                </text>
+                            </g>
+                        ))}
+                        {[0, 1, 2].map((d) => (
+                            <text
+                                key={d}
+                                x="10"
+                                y={d === 0 ? 35 : d === 1 ? 105 : 175}
+                                fontSize="10"
+                                fill="#94a3b8"
+                                fontFamily="Noto Sans JP"
+                            >
+                                深さ{d}
+                            </text>
+                        ))}
+                    </svg>
+                );
+            }
+
+            function StepVisualization({ stepData }) {
+                if (!stepData) return null;
+                const { visual, queue, result, level, vals } = stepData;
+                return (
+                    <div className="mt-4 space-y-3">
+                        <div className="flex justify-center">
+                            <TreeViz highlightLevel={level} />
+                        </div>
+                        <div className="p-4 rounded-2xl bg-slate-50 border border-slate-200 mono text-xs space-y-2">
+                            <div className="text-slate-500 font-sans text-xs font-bold mb-2">
+                                🔍 現在の変数の状態
+                            </div>
+                            <QueueViz items={queue || []} highlight={visual === 'popleft'} />
+                            {vals && (
+                                <div className="flex flex-wrap gap-2 items-center">
+                                    <span className="text-xs text-slate-500 font-semibold">
+                                        vals:
+                                    </span>
+                                    <span className="text-xs text-amber-700 font-bold">
+                                        [{vals.join(', ')}]
+                                    </span>
+                                </div>
+                            )}
+                            <ResultViz result={result || []} />
+                            {level >= 0 && (
+                                <div className="text-xs text-violet-600 font-semibold">
+                                    現在処理中の深さ: {level === -1 ? '—' : level}
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            function StepsApp() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+                const currentStepData = stepsData[activeStep - 1];
+
+                const handlePlay = () => setIsPlaying(true);
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 1800);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-6 mt-2">
+                        <div>
+                            <h3 className="mt-0 mb-3 text-teal-800 text-lg font-bold">
+                                ステップ一覧
+                            </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-sm rounded-2xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'border-emerald-500 shadow-lg'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-300 hover:translate-x-1',
+                                            ].join(' ')}
+                                            style={
+                                                isActive
+                                                    ? {
+                                                          background:
+                                                              'linear-gradient(135deg,#d1fae5,#a7f3d0)',
+                                                      }
+                                                    : {}
+                                            }
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold text-sm mb-0.5',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}: {step.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs">
+                                                {step.desc.substring(0, 48)}…
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        <div>
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-xl 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-5 border-2 border-emerald-200"
+                                style={{ background: '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 stepData={currentStepData} />
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#10b981,#059669)',
+                                    }}
+                                    onClick={handlePlay}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#0ea5e9,#0284c7)',
+                                    }}
+                                    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-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#0ea5e9,#0284c7)',
+                                    }}
+                                    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-bold 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-4 rounded-2xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            const root = ReactDOM.createRoot(document.getElementById('steps-root'));
+            root.render(<StepsApp />);
+
+            setTimeout(() => {
+                document.querySelectorAll('pre code.language-python').forEach((el) => {
+                    Prism.highlightElement(el);
+                });
+            }, 300);
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html b/public/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html
new file mode 100644
index 00000000..a235a09a
--- /dev/null
+++ b/public/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html	
@@ -0,0 +1,1341 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1.0" />
+        <title>LeetCode 102 · Binary Tree Level Order Traversal</title>
+        <script src="/vendor/react/react.development.js"></script>
+        <script src="/vendor/react-dom/react-dom.development.js"></script>
+        <script src="/vendor/babel/babel.min.js"></script>
+        <script src="/vendor/tailwindcss/script.js"></script>
+        <script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
+        <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;500;700&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/themes/prism-tomorrow.css"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.css"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/plugins/toolbar/prism-toolbar.css"
+            rel="stylesheet"
+        />
+        <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;
+            }
+            .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;
+            }
+            details[open] > summary .arrow {
+                transform: rotate(90deg);
+            }
+            .arrow {
+                display: inline-block;
+                transition: transform 0.2s;
+            }
+
+            /* ── Mermaid カスタムスタイル ── */
+            .mermaid-wrapper {
+                background: linear-gradient(135deg, #f0fdf4 0%, #e0f2fe 100%);
+                border: 2px solid #a7f3d0;
+                border-radius: 20px;
+                padding: 28px 16px;
+                overflow-x: auto;
+            }
+            .mermaid-wrapper .mermaid {
+                display: flex;
+                justify-content: center;
+            }
+            /* ノードラベルの日本語フォント */
+            .mermaid svg text {
+                font-family: 'Noto Sans JP', 'JetBrains Mono', sans-serif !important;
+            }
+        </style>
+    </head>
+    <body
+        class="min-h-screen"
+        style="background: linear-gradient(135deg, #f0fdf4 0%, #e0f2fe 50%, #fdf4ff 100%)"
+    >
+        <div class="max-w-5xl mx-auto px-4 py-8">
+            <!-- ===== HEADER ===== -->
+            <header
+                id="header"
+                class="mb-8 rounded-3xl p-8 shadow-xl"
+                style="background: linear-gradient(135deg, #d1fae5 0%, #bfdbfe 60%, #ede9fe 100%)"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="outfit bg-emerald-600 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >LeetCode #102</span
+                    >
+                    <span
+                        class="outfit bg-sky-500 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >Medium</span
+                    >
+                    <span
+                        class="outfit bg-violet-500 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >BFS</span
+                    >
+                </div>
+                <h1 class="outfit text-4xl font-black text-teal-900 mb-1 leading-tight">
+                    Binary Tree Level Order Traversal
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold">
+                    BFS + collections.deque による O(n) 実装
+                </p>
+                <div
+                    class="mt-4 inline-block bg-white/70 rounded-2xl px-5 py-3 border border-white/80 shadow"
+                >
+                    <p class="text-teal-800 font-bold text-base">
+                        💡
+                        一言で言うと：「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」
+                    </p>
+                </div>
+                <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-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ===== OVERVIEW ===== -->
+            <section id="overview" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="mb-5 p-5 rounded-2xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-bold text-base">💡 この問題を一言で言うと：</p>
+                    <p class="text-slate-700 text-sm mt-2 leading-7">
+                        「木の同じ深さ（階層）にあるノードを全部集めて1つのリストにまとめ、それを深さ順に並べた2次元配列を返す問題」です。<br />
+                        左から右の順番でノードを集める必要があります。
+                    </p>
+                </div>
+
+                <div class="mb-5 p-5 rounded-2xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-bold text-sm mb-3">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-700 text-sm space-y-2 list-disc list-inside leading-7">
+                        <li>
+                            「縦方向（深さ優先）」に探索するだけでは、同じ深さのノードをまとめる境界が分からない
+                        </li>
+                        <li>
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">list.pop(0)</code>
+                            を使うと先頭削除が O(n) になり全体が O(n²) へ悪化する
+                        </li>
+                        <li>
+                            ノードの値が
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">0</code>
+                            のとき、<code class="bg-amber-100 px-1 rounded mono text-xs">or</code>
+                            トリックは
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">0</code
+                            >（falsy）と誤判定して壊れる
+                        </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-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-2xl">O(n)</div>
+                        <div class="text-xs mt-1 font-semibold">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-2xl">O(n)</div>
+                        <div class="text-xs mt-1 font-semibold">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-lg mono break-all leading-tight">
+                            deque
+                        </div>
+                        <div class="text-xs mt-1 font-semibold">データ構造</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-lg">BFS</div>
+                        <div class="text-xs mt-1 font-semibold">探索手法</div>
+                    </div>
+                </div>
+
+                <div class="rounded-2xl bg-slate-50 border border-slate-200 p-5 mb-4">
+                    <p class="text-slate-600 font-bold text-sm mb-3">📥 入出力例</p>
+                    <div class="grid md:grid-cols-2 gap-4">
+                        <div>
+                            <p class="text-xs text-slate-500 mb-1 font-semibold">入力（ツリー）</p>
+                            <pre
+                                class="mono text-sm bg-slate-800 text-emerald-300 rounded-xl p-4 leading-6"
+                            >
+    3
+   / \
+  9  20
+     / \
+    15   7</pre
+                            >
+                        </div>
+                        <div>
+                            <p class="text-xs text-slate-500 mb-1 font-semibold">出力と理由</p>
+                            <pre
+                                class="mono text-sm bg-slate-800 text-sky-300 rounded-xl p-4 leading-6"
+                            >
+[[3],[9,20],[15,7]]
+
+深さ0 → [3]
+深さ1 → [9, 20]  ← 左から右
+深さ2 → [15, 7]  ← 左から右</pre
+                            >
+                        </div>
+                    </div>
+                </div>
+
+                <div class="rounded-2xl bg-slate-50 border border-slate-200 p-5">
+                    <p class="text-slate-600 font-bold text-sm mb-2">📋 制約</p>
+                    <ul class="text-sm text-slate-600 space-y-1 list-disc list-inside">
+                        <li>ノード数：0 以上 2000 以下</li>
+                        <li>ノードの値：<strong>-1000 以上 1000 以下（0 が含まれる）</strong></li>
+                    </ul>
+                </div>
+            </section>
+
+            <!-- ===== STEPS (React) ===== -->
+            <section id="steps" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-2 pb-3 border-b-4 border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-6">
+                    各ステップをクリックするか、▶ Play ボタンで自動再生できます。
+                </p>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ===== CODE ===== -->
+            <section id="code" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-5 p-5 rounded-2xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-bold text-sm mb-3">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-2 list-decimal list-inside leading-7">
+                        <li>
+                            <strong>空ツリーのチェック</strong>：root が None なら即座に [] を返す
+                        </li>
+                        <li>
+                            <strong>deque の初期化</strong>：root をキューに入れて BFS 開始の準備
+                        </li>
+                        <li>
+                            <strong>while ループ</strong>：キューが空になるまで、階層ごとに処理する
+                        </li>
+                        <li>
+                            <strong>level_size の固定</strong
+                            >：今の階のサイズをここで確定させる（核心）
+                        </li>
+                        <li>
+                            <strong>for ループ</strong>：level_size 個だけ popleft()
+                            し、値収集と子の登録を行う
+                        </li>
+                        <li><strong>結果への追加</strong>：今の階の値リストを result に追加する</li>
+                    </ol>
+                </div>
+
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from collections import deque
+from typing import Optional
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+        # 基底条件: root が None（空ツリー）なら即座に空リストを返す
+        # None チェックをしないと後続の node.val アクセスでクラッシュする
+        if root is None:
+            return []
+
+        result: list[list[int]] = []
+
+        # collections.deque をキューとして使う
+        # list.pop(0) は O(n) だが deque.popleft() は O(1)
+        # deque は C言語実装の双方向キューで先頭・末尾への操作が高速
+        queue: deque[TreeNode] = deque([root])
+
+        # キューが空になるまでループ（= 全ノードを処理し終えるまで）
+        while queue:
+            # ── BFS の核心：今の階のサイズをここで固定する ──
+            # ループ中に popleft()/append() で queue の長さが変化するため
+            # 先に変数へ保存しないと「今の階」の範囲がずれて Wrong Answer になる
+            level_size: int = len(queue)
+            level_values: list[int] = []
+
+            for _ in range(level_size):
+                # popleft() でキューの先頭ノードを O(1) で取り出す
+                node: TreeNode = queue.popleft()
+
+                # val を直接 append する（0 も正しく追加される）
+                # `or` トリックは val=0 のとき falsy と判定されて壊れるため使わない
+                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)
+
+            result.append(level_values)
+
+        return result</code></pre>
+
+                <div class="mt-5 p-5 rounded-2xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-bold text-sm mb-3">
+                        ▶ 入力例 [3, 9, 20, null, null, 15, 7] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs mono leading-7 overflow-x-auto whitespace-pre"
+                    >
+初期状態: queue = deque([Node(3)]),  result = []
+
+━━ ループ 1回目（深さ0） ━━
+  level_size = 1   ← ここで固定！
+  vals = []
+  i=0: popleft() → Node(3)   queue = deque([])
+       append(3)  → vals = [3]
+       left=Node(9)  → queue = deque([Node(9)])
+       right=Node(20) → queue = deque([Node(9), Node(20)])
+  result = [[3]]
+
+━━ ループ 2回目（深さ1） ━━
+  level_size = 2   ← ここで固定！
+  i=0: Node(9)  → vals=[9]       子なし
+  i=1: Node(20) → vals=[9,20]    left=Node(15), right=Node(7)
+  result = [[3], [9, 20]]
+
+━━ ループ 3回目（深さ2） ━━
+  level_size = 2
+  i=0: Node(15) → vals=[15]      子なし
+  i=1: Node(7)  → vals=[15,7]    子なし
+  result = [[3], [9, 20], [15, 7]]
+
+queue が空 → ループ終了
+戻り値: [[3], [9, 20], [15, 7]] ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ===== FLOWCHART ===== -->
+            <section id="diagram" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <!-- 凡例 -->
+                <div class="mb-6 p-5 rounded-2xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-bold text-sm mb-4">
+                        🗺️ フローチャートの読み方（Mermaid 記法）
+                    </p>
+                    <div
+                        class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700"
+                    >
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded-full bg-emerald-100 border-2 border-emerald-500 text-emerald-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >([…])</span
+                            >
+                            <span>スタジアム形（緑）<br />= 開始・終了</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded-lg bg-sky-100 border-2 border-sky-400 text-sky-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >[…]</span
+                            >
+                            <span>四角形（青）<br />= 処理ステップ</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded bg-amber-100 border-2 border-amber-400 text-amber-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >{…}</span
+                            >
+                            <span>ひし形（黄）<br />= 条件分岐</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span class="flex flex-col gap-1">
+                                <span class="flex items-center gap-1"
+                                    ><span
+                                        class="inline-block w-6 h-0.5 bg-emerald-500 rounded"
+                                    ></span
+                                    ><span class="text-emerald-700 font-semibold"
+                                        >Yes（はい）</span
+                                    ></span
+                                >
+                                <span class="flex items-center gap-1"
+                                    ><span class="inline-block w-6 h-0.5 bg-red-400 rounded"></span
+                                    ><span class="text-red-600 font-semibold"
+                                        >No（いいえ）</span
+                                    ></span
+                                >
+                            </span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Mermaid フローチャート（JS経由でレンダリング・HTMLパーサーを完全回避） -->
+                <div class="mermaid-wrapper">
+                    <div
+                        id="mermaid-render-target"
+                        style="
+                            display: flex;
+                            justify-content: center;
+                            min-height: 120px;
+                            align-items: center;
+                        "
+                    >
+                        <span style="color: #94a3b8; font-size: 13px">読み込み中…</span>
+                    </div>
+                </div>
+
+                <!-- 色の意味の補足 -->
+                <div class="mt-4 flex flex-wrap gap-3 text-xs">
+                    <span
+                        class="inline-flex items-center gap-2 bg-emerald-50 border border-emerald-200 rounded-full px-3 py-1.5 text-emerald-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-emerald-400 inline-block"></span> 緑 =
+                        開始・終了ノード
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-sky-50 border border-sky-200 rounded-full px-3 py-1.5 text-sky-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-blue-400 inline-block"></span> 青 =
+                        通常の処理
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-amber-50 border border-amber-200 rounded-full px-3 py-1.5 text-amber-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-amber-400 inline-block"></span> 黄 =
+                        条件分岐
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-violet-50 border border-violet-200 rounded-full px-3 py-1.5 text-violet-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-violet-400 inline-block"></span> 紫 =
+                        BFS の核心処理
+                    </span>
+                </div>
+
+                <!-- フロー追跡 -->
+                <div class="mt-6 p-5 rounded-2xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-bold 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>「Start」 → root=Node(3) を受け取る</li>
+                        <li>
+                            「root is None?」 → いいえ → 初期化: result=[], queue=deque([Node(3)])
+                        </li>
+                        <li>
+                            「queue は空?」 → いいえ（Node(3) がある）→
+                            <strong class="text-violet-700">level_size=1</strong>, vals=[]
+                        </li>
+                        <li>
+                            「i &lt; 1?」 → はい → popleft()=Node(3), vals=[3], left=Node(9)→追加,
+                            right=Node(20)→追加
+                        </li>
+                        <li>「i &lt; 1?」 → いいえ → result.append([3]) → ループバック</li>
+                        <li>
+                            （深さ1）<strong class="text-violet-700">level_size=2</strong>,
+                            Node(9)→vals=[9], Node(20)→vals=[9,20], Node(15)&amp;Node(7)追加
+                        </li>
+                        <li>
+                            （深さ2）<strong class="text-violet-700">level_size=2</strong>,
+                            Node(15)→vals=[15], Node(7)→vals=[15,7]
+                        </li>
+                        <li>
+                            「queue は空?」 → はい → 「return result」へ → [[3],[9,20],[15,7]] ✅
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ===== COMPLEXITY ===== -->
+            <section id="complexity" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <div class="mb-6 p-5 rounded-2xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-bold text-sm mb-4">
+                        📖 Big-O 記法の読み方（n = ノード数）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs">
+                        <div class="text-center p-4 rounded-xl bg-emerald-100 text-emerald-800">
+                            <div class="outfit font-black text-xl mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-sky-100 text-sky-800">
+                            <div class="outfit font-black text-xl mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-amber-100 text-amber-800">
+                            <div class="outfit font-black text-xl mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-amber-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-red-100 text-red-800">
+                            <div class="outfit font-black text-xl mb-1 mono">list.pop(0)</div>
+                            <div class="leading-5">
+                                先頭削除は O(n)<br /><span class="text-red-600"
+                                    >全体 O(n²) になる</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto rounded-2xl border border-slate-200 mb-5">
+                    <table class="w-full text-sm text-left">
+                        <thead>
+                            <tr class="bg-gradient-to-r from-emerald-50 to-sky-50">
+                                <th class="px-5 py-3 font-bold text-slate-700">種別</th>
+                                <th class="px-5 py-3 font-bold text-slate-700">計算量</th>
+                                <th class="px-5 py-3 font-bold text-slate-700">理由</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-t border-slate-100">
+                                <td class="px-5 py-3 font-semibold text-emerald-700">時間計算量</td>
+                                <td class="px-5 py-3 mono font-bold text-emerald-800">O(n)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    各ノードを popleft() で1回だけ処理（O(1)×n回）
+                                </td>
+                            </tr>
+                            <tr class="border-t border-slate-100 bg-slate-50/50">
+                                <td class="px-5 py-3 font-semibold text-sky-700">空間計算量</td>
+                                <td class="px-5 py-3 mono font-bold text-sky-800">O(n)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    キューに最大で最下層のノード数（最大 n/2 個）が入る
+                                </td>
+                            </tr>
+                            <tr class="border-t border-slate-100">
+                                <td class="px-5 py-3 font-semibold text-red-600">
+                                    比較：list.pop(0)
+                                </td>
+                                <td class="px-5 py-3 mono font-bold text-red-700">O(n²)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    先頭削除のたびに残り全要素をシフト（O(n)×n回）
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <div class="p-5 rounded-2xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-bold text-sm mb-2">
+                        🔍 なぜこの計算量になるのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        全ノード数を n とすると、各ノードはキューへの
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">append()</code
+                        >（O(1)）と
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">popleft()</code
+                        >（O(1)）を1回ずつ行うため、 合計操作回数は 2n =
+                        <strong>O(n)</strong> です。 空間については、完全二分木の最下層に最大 n/2
+                        個のノードが集まるため、 キューの最大サイズは O(n) となります。
+                        これは出力配列 result のサイズも同様で、全ノードの値を格納するため O(n)
+                        です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===== GLOSSARY ===== -->
+            <section id="glossary" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-3 pb-3 border-b-4 border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-6">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたときに参照してください。
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> BFS（幅優先探索）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Breadth-First Search
+                            の略。グラフや木を「横方向に広がりながら」探索する方法。
+                            同じ深さのノードをすべて処理してから次の深さへ進む。
+                            「エレベーターで同じ階を全部回ってから次の階へ行く」イメージ。
+                            この問題では「同じ階層のノードをまとめる」処理と自然に一致するため選ばれる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> Big-O 記法
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            アルゴリズムの「入力サイズが大きくなるにつれて処理時間やメモリがどう増えるか」を表す記法。
+                            O(1) は常に一定、O(n) は入力に比例、O(n²) は入力の2乗で増加する。
+                            実際の秒数ではなく「増え方の傾向」を表す。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> deque（デック）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            のこと。 Doubly-Ended Queue（両端キュー）の略。前からも後ろからも O(1)
+                            で出し入れできる「両端開きの箱」。 Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list</code>
+                            の先頭削除は O(n) だが、 deque の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">popleft()</code> は
+                            O(1)。 C言語で実装されており高速。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> falsy（フォールシー）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">if</code>
+                            の条件式で
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">False</code>
+                            相当と見なされる値。
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">0</code>、<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >None</code
+                            >、<code class="bg-slate-100 px-1 rounded mono text-xs">[]</code>、<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >""</code
+                            >
+                            などが該当する。 ノードの値
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">val = 0</code> は
+                            falsy なので、
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">0 or 式</code>
+                            という書き方は「0のとき右辺を実行する」という誤動作を引き起こす。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> FIFO（先入れ先出し）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            First In, First Out の略。最初に入れたものを最初に取り出す順序。
+                            銀行の窓口の行列と同じ仕組み。キューはこの性質を持つ。 BFS
+                            はこの性質を利用して「深さが浅いノードから順番に処理する」を実現する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> キュー（Queue）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            先に入れたものを先に取り出す（FIFO）データ構造。
+                            銀行の窓口の行列と同じ。 BFS
+                            では「処理待ちのノード」をキューに積み、先頭から順番に処理することで
+                            「浅い順」に探索できる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span>
+                            level_size（階層サイズの固定）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            BFS の while ループの各反復の開始時に
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >level_size = len(queue)</code
+                            >
+                            で 「今の階のノード数」を変数に保存するテクニック。 ループ中に子の追加で
+                            queue の長さが変化するため、先に固定しないと
+                            「今の階」と「次の階」の境界が混在して Wrong Answer になる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> 二分木（Binary Tree）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            各ノードが「左の子」と「右の子」の最大2つを持つ木構造のデータ。
+                            木の頂点を「根（root）」と呼び、子を持たないノードを「葉（leaf）」と呼ぶ。
+                            根からあるノードまでの辺の数を「深さ（depth）」と呼ぶ。根の深さは 0。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> popleft()
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">deque</code>
+                            の先頭要素を O(1) で取り出すメソッド。
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list.pop(0)</code>
+                            は残り全要素を前にシフトするため O(n) かかるが、
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >deque.popleft()</code
+                            >
+                            は双方向連結リストの先頭ポインタを1つ進めるだけなので O(1)。 n=2000
+                            のとき、この差は 2000 回 vs 最大 4,000,000 回の操作差になる。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center text-slate-400 text-xs py-4 pb-8">
+                LeetCode #102 · Binary Tree Level Order Traversal · Python BFS 解説
+            </footer>
+        </div>
+
+        <!-- ===== MERMAID プログラマティックレンダリング =====
+  設計方針:
+  ① ダイアグラムを JS テンプレートリテラルで保持
+     → ブラウザの HTML パーサーをバイパスするため、
+       HTML エンティティ(&#40; 等)や `<` のエスケープが不要
+  ② mermaid.render() で SVG に変換 → innerHTML に注入
+     → <div class="mermaid"> の startOnLoad に依存しない
+  ③ htmlLabels:true により <br/> がラベル内で改行として機能
+===== -->
+        <script>
+            mermaid.initialize({
+                startOnLoad: false, // 手動で render() を呼ぶため false
+                theme: 'base',
+                flowchart: {
+                    useMaxWidth: true,
+                    htmlLabels: true, // <br/> を改行として扱う
+                    curve: 'basis',
+                    padding: 20,
+                    nodeSpacing: 50,
+                    rankSpacing: 55,
+                },
+                themeVariables: {
+                    primaryColor: '#dbeafe',
+                    primaryTextColor: '#1e3a5f',
+                    primaryBorderColor: '#2563eb',
+                    lineColor: '#64748b',
+                    secondaryColor: '#d1fae5',
+                    secondaryBorderColor: '#059669',
+                    tertiaryColor: '#fef3c7',
+                    tertiaryBorderColor: '#d97706',
+                    edgeLabelBackground: '#ffffff',
+                },
+            });
+
+            // ──────────────────────────────────────────────
+            // ダイアグラム定義（純粋な JS 文字列）
+            // ・<  →  そのまま書ける（HTML パーサーを経由しない）
+            // ・<br/> → htmlLabels:true でラベル内改行
+            // ・() [] は引用符付きラベル ["..."] 内で安全
+            // ──────────────────────────────────────────────
+            const BFS_DIAGRAM = `flowchart TD
+    S(["Start: levelOrder(root)"])
+    C1{"root is None?"}
+    R1(["return &lbrack;&rbrack;  ✅"])
+    A1["result = &lbrack;&rbrack;<br/>queue = deque(&lbrack;root&rbrack;)"]
+    C2{"queue は空?"}
+    R2(["return result  ✅"])
+    A2["level_size = len(queue)<br/>← 今の階のサイズを固定!<br/>vals = &lbrack;&rbrack;"]
+    C3{"i < level_size ?"}
+    A3["result.append(vals)<br/>→ 今の階が完成！"]
+    A4["node = queue.popleft()"]
+    A5["vals.append(node.val)<br/>※ val=0 も正しく追加"]
+    C4{"node.left あり?"}
+    A6["queue.append(node.left)"]
+    C5{"node.right あり?"}
+    A7["queue.append(node.right)"]
+    A8["i + 1 → for ループへ"]
+
+    S --> C1
+    C1 -- "はい（空ツリー）" --> R1
+    C1 -- "いいえ" --> A1
+    A1 --> C2
+    C2 -- "はい（全処理完了）" --> R2
+    C2 -- "いいえ" --> A2
+    A2 --> C3
+    C3 -- "いいえ（この階終了）" --> A3
+    A3 --> C2
+    C3 -- "はい" --> A4
+    A4 --> A5
+    A5 --> C4
+    C4 -- "あり" --> A6
+    C4 -- "なし" --> C5
+    A6 --> C5
+    C5 -- "あり" --> A7
+    C5 -- "なし" --> A8
+    A7 --> A8
+    A8 --> C3
+
+    classDef startEnd fill:#d1fae5,stroke:#059669,stroke-width:2px,color:#064e3b,font-weight:bold
+    classDef process  fill:#dbeafe,stroke:#2563eb,stroke-width:2px,color:#1e3a5f
+    classDef decision fill:#fef3c7,stroke:#d97706,stroke-width:2px,color:#78350f
+    classDef core     fill:#ede9fe,stroke:#7c3aed,stroke-width:2.5px,color:#3b0764,font-weight:bold
+
+    class S,R1,R2 startEnd
+    class A1,A3,A4,A5,A6,A7,A8 process
+    class C1,C2,C3,C4,C5 decision
+    class A2 core`;
+
+            // DOM 構築後にレンダリング
+            document.addEventListener('DOMContentLoaded', async function () {
+                const target = document.getElementById('mermaid-render-target');
+                try {
+                    const { svg } = await mermaid.render('bfs-flowchart-svg', BFS_DIAGRAM);
+                    target.innerHTML = svg;
+                } catch (err) {
+                    console.error('[Mermaid] render error:', err);
+                    target.innerHTML =
+                        '<p style="color:#dc2626;padding:16px;font-size:13px;">' +
+                        '⚠️ フローチャートの描画に失敗しました。コンソールを確認してください。</p>';
+                }
+            });
+        </script>
+
+        <!-- ===== REACT STEPS ===== -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空ツリーのチェック',
+                    desc:
+                        'root が None（空ツリー）かどうかを確認し、空なら即座に [] を返します。' +
+                        'なぜなら、None に対して .val や .left などにアクセスすると実行時エラーになるためです。' +
+                        '例）root=None → if root is None → return [] でここで終了。',
+                    visual: 'check_none',
+                    queue: [],
+                    result: [],
+                    level: -1,
+                },
+                {
+                    step: 2,
+                    title: 'result と queue を初期化',
+                    desc:
+                        '結果格納用の2次元リスト result=[] と、BFS用のキュー queue=deque([root]) を用意します。' +
+                        'deque を使う理由は popleft() が O(1) のため。list.pop(0) は O(n) になり遅くなります。' +
+                        '例）root=Node(3) → queue = deque([Node(3)])',
+                    visual: 'init',
+                    queue: ['Node(3)'],
+                    result: [],
+                    level: 0,
+                },
+                {
+                    step: 3,
+                    title: 'level_size を固定する（BFS の核心）',
+                    desc:
+                        'while ループの先頭で level_size = len(queue) を変数に保存します。' +
+                        'この値が「今の階のノード数」です。ループ中に queue が変化するため、先に固定しないとズレます。' +
+                        '例）queue = [Node(9), Node(20)] → level_size = 2 に固定',
+                    visual: 'fix_size',
+                    queue: ['Node(9)', 'Node(20)'],
+                    result: [['Node(3).val=3']],
+                    level: 1,
+                },
+                {
+                    step: 4,
+                    title: 'popleft() でノードを取り出す',
+                    desc:
+                        'queue.popleft() でキューの先頭ノードを O(1) で取り出し、その val を vals に追加します。' +
+                        'val が 0 のときも正しく追加されます（or トリックは val=0 で壊れるため使いません）。' +
+                        '例）popleft() → Node(9), vals.append(9) → vals=[9]',
+                    visual: 'popleft',
+                    queue: ['Node(20)'],
+                    result: [['3']],
+                    level: 1,
+                    vals: ['9'],
+                },
+                {
+                    step: 5,
+                    title: '子ノードをキューに追加する',
+                    desc:
+                        '取り出したノードの left / right が None でない場合、キューの末尾に追加します（次の階の準備）。' +
+                        'is not None でチェックすることで、キューに None が混入するのを防ぎます。' +
+                        '例）Node(20).left=Node(15) → queue.append(Node(15))',
+                    visual: 'push_children',
+                    queue: ['Node(20)', 'Node(15)', 'Node(7)'],
+                    result: [['3']],
+                    level: 1,
+                    vals: ['9'],
+                },
+                {
+                    step: 6,
+                    title: '今の階の値リストを result に追加',
+                    desc:
+                        'level_size 個分のノードを処理し終えたら vals を result に追加します。' +
+                        'これで「1つの階層分」の処理が完了し、次の while ループで次の階層へ進みます。' +
+                        '例）vals=[9,20] → result.append([9,20]) → result=[[3],[9,20]]',
+                    visual: 'append_level',
+                    queue: ['Node(15)', 'Node(7)'],
+                    result: [['3'], ['9', '20']],
+                    level: 2,
+                },
+            ];
+
+            function QueueViz({ items, highlight }) {
+                return (
+                    <div className="flex flex-wrap gap-2 items-center">
+                        <span className="text-xs text-slate-500 font-semibold mono">queue:</span>
+                        <span className="text-xs text-slate-400">[</span>
+                        {items.length === 0 && (
+                            <span className="text-xs text-slate-400 italic">空</span>
+                        )}
+                        {items.map((item, i) => (
+                            <span
+                                key={i}
+                                className={[
+                                    'mono text-xs px-2 py-1 rounded-lg font-bold border',
+                                    i === 0 && highlight
+                                        ? 'bg-emerald-200 border-emerald-500 text-emerald-800'
+                                        : 'bg-sky-100 border-sky-300 text-sky-800',
+                                ].join(' ')}
+                            >
+                                {item}
+                            </span>
+                        ))}
+                        <span className="text-xs text-slate-400">]</span>
+                    </div>
+                );
+            }
+
+            function ResultViz({ result }) {
+                return (
+                    <div className="flex flex-wrap gap-2 items-start">
+                        <span className="text-xs text-slate-500 font-semibold mono mt-1">
+                            result:
+                        </span>
+                        <span className="text-xs text-slate-400 mt-1">[</span>
+                        {result.length === 0 && (
+                            <span className="text-xs text-slate-400 italic mt-1">空</span>
+                        )}
+                        {result.map((level, i) => (
+                            <span
+                                key={i}
+                                className="mono text-xs px-2 py-1 rounded-lg bg-violet-100 border border-violet-300 text-violet-800 font-bold"
+                            >
+                                [{level.join(', ')}]
+                            </span>
+                        ))}
+                        <span className="text-xs text-slate-400 mt-1">]</span>
+                    </div>
+                );
+            }
+
+            function TreeViz({ highlightLevel }) {
+                const nodes = [
+                    { id: 0, val: 3, x: 200, y: 30, depth: 0 },
+                    { id: 1, val: 9, x: 100, y: 100, depth: 1 },
+                    { id: 2, val: 20, x: 300, y: 100, depth: 1 },
+                    { id: 3, val: 15, x: 220, y: 170, depth: 2 },
+                    { id: 4, val: 7, x: 380, y: 170, depth: 2 },
+                ];
+                const edges = [
+                    [0, 1],
+                    [0, 2],
+                    [2, 3],
+                    [2, 4],
+                ];
+                const colors = ['#d1fae5', '#bfdbfe', '#ede9fe'];
+                const borders = ['#059669', '#0284c7', '#7c3aed'];
+                return (
+                    <svg
+                        viewBox="0 0 460 210"
+                        style={{ width: '100%', maxWidth: '420px', height: 'auto' }}
+                    >
+                        {edges.map(([a, b], i) => (
+                            <line
+                                key={i}
+                                x1={nodes[a].x}
+                                y1={nodes[a].y + 16}
+                                x2={nodes[b].x}
+                                y2={nodes[b].y - 16}
+                                stroke="#cbd5e1"
+                                strokeWidth="2"
+                            />
+                        ))}
+                        {nodes.map((n) => (
+                            <g key={n.id}>
+                                <circle
+                                    cx={n.x}
+                                    cy={n.y}
+                                    r="22"
+                                    fill={highlightLevel === n.depth ? colors[n.depth] : '#f8fafc'}
+                                    stroke={
+                                        highlightLevel === n.depth ? borders[n.depth] : '#cbd5e1'
+                                    }
+                                    strokeWidth={highlightLevel === n.depth ? '3' : '1.5'}
+                                />
+                                <text
+                                    x={n.x}
+                                    y={n.y + 5}
+                                    textAnchor="middle"
+                                    fontSize="15"
+                                    fill={highlightLevel === n.depth ? '#1e293b' : '#94a3b8'}
+                                    fontWeight={highlightLevel === n.depth ? 'bold' : 'normal'}
+                                    fontFamily="JetBrains Mono"
+                                >
+                                    {n.val}
+                                </text>
+                            </g>
+                        ))}
+                        {[0, 1, 2].map((d) => (
+                            <text
+                                key={d}
+                                x="10"
+                                y={d === 0 ? 35 : d === 1 ? 105 : 175}
+                                fontSize="10"
+                                fill="#94a3b8"
+                                fontFamily="Noto Sans JP"
+                            >
+                                深さ{d}
+                            </text>
+                        ))}
+                    </svg>
+                );
+            }
+
+            function StepVisualization({ stepData }) {
+                if (!stepData) return null;
+                const { visual, queue, result, level, vals } = stepData;
+                return (
+                    <div className="mt-4 space-y-3">
+                        <div className="flex justify-center">
+                            <TreeViz highlightLevel={level} />
+                        </div>
+                        <div className="p-4 rounded-2xl bg-slate-50 border border-slate-200 mono text-xs space-y-2">
+                            <div className="text-slate-500 font-sans text-xs font-bold mb-2">
+                                🔍 現在の変数の状態
+                            </div>
+                            <QueueViz items={queue || []} highlight={visual === 'popleft'} />
+                            {vals && (
+                                <div className="flex flex-wrap gap-2 items-center">
+                                    <span className="text-xs text-slate-500 font-semibold">
+                                        vals:
+                                    </span>
+                                    <span className="text-xs text-amber-700 font-bold">
+                                        [{vals.join(', ')}]
+                                    </span>
+                                </div>
+                            )}
+                            <ResultViz result={result || []} />
+                            {level >= 0 && (
+                                <div className="text-xs text-violet-600 font-semibold">
+                                    現在処理中の深さ: {level === -1 ? '—' : level}
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            function StepsApp() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+                const currentStepData = stepsData[activeStep - 1];
+
+                const handlePlay = () => setIsPlaying(true);
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 1800);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-6 mt-2">
+                        <div>
+                            <h3 className="mt-0 mb-3 text-teal-800 text-lg font-bold">
+                                ステップ一覧
+                            </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-sm rounded-2xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'border-emerald-500 shadow-lg'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-300 hover:translate-x-1',
+                                            ].join(' ')}
+                                            style={
+                                                isActive
+                                                    ? {
+                                                          background:
+                                                              'linear-gradient(135deg,#d1fae5,#a7f3d0)',
+                                                      }
+                                                    : {}
+                                            }
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold text-sm mb-0.5',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}: {step.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs">
+                                                {step.desc.substring(0, 48)}…
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        <div>
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-xl 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-5 border-2 border-emerald-200"
+                                style={{ background: '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 stepData={currentStepData} />
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#10b981,#059669)',
+                                    }}
+                                    onClick={handlePlay}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#0ea5e9,#0284c7)',
+                                    }}
+                                    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-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#0ea5e9,#0284c7)',
+                                    }}
+                                    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-bold 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-4 rounded-2xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            const root = ReactDOM.createRoot(document.getElementById('steps-root'));
+            root.render(<StepsApp />);
+
+            setTimeout(() => {
+                document.querySelectorAll('pre code.language-python').forEach((el) => {
+                    Prism.highlightElement(el);
+                });
+            }, 300);
+        </script>
+    </body>
+</html>
diff --git a/public/index.html b/public/index.html
index 0bae42ab..dd1088d8 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">168 interactive lessons across 6 domains</p>
+        <p class="site-subtitle">169 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">168</span>
+            <span class="tab-icon">🌍</span> All <span class="tab-count">169</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">90</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="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>
@@ -467,6 +467,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/greedy%20algorithm/leetcode/45.%20Jump%20Game%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Jump Game II アルゴリズム解析</span></span><span class="file-path">Algorithm/greedy algorithm/leetcode/45. Jump Game II/Claude/README.html</span></a></li>
 <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/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>
@@ -642,6 +643,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/greedy%20algorithm/leetcode/45.%20Jump%20Game%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Jump Game II アルゴリズム解析</span></span><span class="file-path">Algorithm/greedy algorithm/leetcode/45. Jump Game II/Claude/README.html</span></a></li>
 <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/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>
@@ -819,7 +821,7 @@ <h1 class="site-title">
 
     <footer>
         <span class="footer-icon">🧪</span>
-        Generated on 2026-04-10
+        Generated on 2026-04-11
     </footer>
 
     <script>

From 3e0ca8067706dffa61a5ff4ac324825e4b7056d6 Mon Sep 17 00:00:00 2001
From: myoshi2891 <96483039+myoshi2891@users.noreply.github.com>
Date: Sat, 11 Apr 2026 00:51:47 +0000
Subject: [PATCH 3/4] build: auto-generate public directory

---
 public/index.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/public/index.html b/public/index.html
index dd1088d8..55b6be04 100644
--- a/public/index.html
+++ b/public/index.html
@@ -501,8 +501,8 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/81.%20Search%20in%20Rotated%20Sorted%20Array%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Search in Rotated Sorted Array II - Technical Analysis</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/81. Search in Rotated Sorted Array II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/73.%20Set%20Matrix%20Zeroes/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Set Matrix Zeroes Algorithm - Python Implementation</span></span><span class="file-path">Algorithm/Other/leetcode/73. Set Matrix Zeroes/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Dutch%20National%20Flag/leetcode/75.%20Sort%20Colors/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Sort Colors Algorithm - Interactive Technical Guide</span></span><span class="file-path">Algorithm/Dutch National Flag/leetcode/75. Sort Colors/Claude/README.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/59.%20Spiral%20Matrix%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Spiral Matrix Algorithm Analysis</span></span><span class="file-path">Algorithm/Other/leetcode/59. Spiral Matrix II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/54.%20Spiral%20Matrix/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Spiral Matrix Algorithm Analysis</span></span><span class="file-path">Algorithm/Other/leetcode/54. Spiral Matrix/Claude/README.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/59.%20Spiral%20Matrix%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Spiral Matrix Algorithm Analysis</span></span><span class="file-path">Algorithm/Other/leetcode/59. Spiral Matrix II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/90.%20Subsets%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Subsets II - 反復的拡張法による重複排除 | アルゴリズム解説</span></span><span class="file-path">Algorithm/Other/leetcode/90. Subsets II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/TwoPointers/leetcode/80.%20Remove%20Duplicates%20from%20Sorted%20Array%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Two-Pointer Algorithm: Remove Duplicates from Sorted Array II</span></span><span class="file-path">Algorithm/TwoPointers/leetcode/80. Remove Duplicates from Sorted Array II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/34.%20Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array/READEME-typescript.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">TypeScript Binary Search Performance Analysis</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/34. Find First and Last Position of Element in Sorted Array/READEME-typescript.html</span></a></li>
@@ -677,8 +677,8 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/81.%20Search%20in%20Rotated%20Sorted%20Array%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Search in Rotated Sorted Array II - Technical Analysis</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/81. Search in Rotated Sorted Array II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/73.%20Set%20Matrix%20Zeroes/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Set Matrix Zeroes Algorithm - Python Implementation</span></span><span class="file-path">Algorithm/Other/leetcode/73. Set Matrix Zeroes/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Dutch%20National%20Flag/leetcode/75.%20Sort%20Colors/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Sort Colors Algorithm - Interactive Technical Guide</span></span><span class="file-path">Algorithm/Dutch National Flag/leetcode/75. Sort Colors/Claude/README.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/59.%20Spiral%20Matrix%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Spiral Matrix Algorithm Analysis</span></span><span class="file-path">Algorithm/Other/leetcode/59. Spiral Matrix II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/54.%20Spiral%20Matrix/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Spiral Matrix Algorithm Analysis</span></span><span class="file-path">Algorithm/Other/leetcode/54. Spiral Matrix/Claude/README.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/59.%20Spiral%20Matrix%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Spiral Matrix Algorithm Analysis</span></span><span class="file-path">Algorithm/Other/leetcode/59. Spiral Matrix II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/90.%20Subsets%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Subsets II - 反復的拡張法による重複排除 | アルゴリズム解説</span></span><span class="file-path">Algorithm/Other/leetcode/90. Subsets II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/TwoPointers/leetcode/80.%20Remove%20Duplicates%20from%20Sorted%20Array%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Two-Pointer Algorithm: Remove Duplicates from Sorted Array II</span></span><span class="file-path">Algorithm/TwoPointers/leetcode/80. Remove Duplicates from Sorted Array II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/34.%20Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array/READEME-typescript.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">TypeScript Binary Search Performance Analysis</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/34. Find First and Last Position of Element in Sorted Array/READEME-typescript.html</span></a></li>

From 2ffb28f240deb5305d08cc1e2849c2c9d1e28efa Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sat, 11 Apr 2026 10:06:36 +0900
Subject: [PATCH 4/4] fix(Trees): optimize TS BFS performance and restructure
 documentation to 5-section format

---
 ...y_Tree_Level_Order_Traversal_Typescript.md | 267 ++-----
 .../README.md                                 | 664 +-----------------
 2 files changed, 99 insertions(+), 832 deletions(-)

diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md
index 7f1f6ff2..89f5a9e0 100644
--- a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md	
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md	
@@ -5,18 +5,24 @@
 
 ---
 
-# LeetCode 102 · Binary Tree Level Order Traversal
+# LeetCode 102 · Binary Tree Level Order Traversal — TypeScript版
 
 ---
 
-## 1. 問題の分析
+## 目次（Table of Contents）
 
-> 💡 **この問題は一言で言うと「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」です。**
-> 木の「同じ深さ（階層）」にあるすべての値をひとつの配列にまとめ、その配列を深さ順に並べた2次元配列を返します。
+- [1. Overview](#overview)
+- [2. Algorithm](#algorithm)
+- [3. Complexity](#complexity)
+- [4. Implementation](#implementation)
+- [5. Optimization](#optimization)
 
 ---
 
-### 🌳 問題が要求していること（視覚的確認）
+<h2 id="overview">1. Overview</h2>
+
+> 💡 **この問題は一言で言うと「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」です。**
+> 木の「同じ深さ（階層）」にあるすべての値をひとつの配列にまとめ、その配列を深さ順に並べた2次元配列を返します。
 
 ```
         3          ← 深さ0: [3]
@@ -28,24 +34,11 @@
 出力: [[3], [9, 20], [15, 7]]
 ```
 
----
-
-### 競技プログラミング視点での分析
-
-- ノード数は最大 2000 なので、O(n) のアルゴリズムで十分に余裕がある
-- 各ノードを **ちょうど1回だけ** 訪問する手法が理想
-- 追加メモリは出力配列のみに抑えたい
-
-### 業務開発視点での分析
+### 競技プログラミング・業務開発視点
 
-- `TreeNode | null` という **Union型（＝複数の型のうちどれかを表す型）** を安全に扱う必要がある
-- `null` チェックを怠ると実行時エラーになるため、型ガード（＝実行時に型を絞り込む条件分岐）が必須
-- 結果配列はイミュータブル（＝変更不可）に構築して副作用を防ぐ
-
-### TypeScript特有の考慮点
-
-- `TreeNode | null` の null 安全性を TypeScript のコンパイラに保証させる
-- キュー（後述）の要素型を明示することで、取り出した要素が必ず `TreeNode` 型であると保証できる
+- **ノード数**: 最大 2000 なので O(n) が必須。
+- **型安全性**: `TreeNode | null` という **Union型** を安全に扱う必要がある。
+- **JSの特性**: `Array.shift()` は $O(n)$ のため、キューとして使う場合はポインタ管理（$O(1)$）を行う必要がある。
 
 > 📖 **このセクションで登場した用語**
 >
@@ -55,121 +48,63 @@
 
 ---
 
-## 2. アルゴリズムアプローチ比較
+<h2 id="algorithm">2. Algorithm</h2>
 
-> 💡 同じ問題でも解き方は複数あります。「速さ（時間計算量）」と「メモリの使い方（空間計算量）」を比べて最適なものを選びます。
+### アプローチ比較
 
-| アプローチ                 | 時間計算量 | 空間計算量 | TS実装コスト | 型安全性 | 可読性 | 備考                             |
-| -------------------------- | ---------- | ---------- | ------------ | -------- | ------ | -------------------------------- |
-| **BFS（幅優先探索）**      | O(n)       | O(n)       | 低           | 高       | 高     | ✅ 今回の選択                    |
-| DFS（深さ優先探索）        | O(n)       | O(n)       | 中           | 高       | 中     | 再帰でも実装可能だが直感的でない |
-| 総当たり（各深さでループ） | O(n²)      | O(n)       | 高           | 中       | 低     | 非推奨                           |
+| アプローチ                 | 時間計算量 | 空間計算量 | 備考                             |
+| -------------------------- | ---------- | ---------- | -------------------------------- |
+| **BFS（幅優先探索）**      | O(n)       | O(n)       | ✅ 今回の選択                    |
+| DFS（深さ優先探索）        | O(n)       | O(n)       | 再帰でも実装可能だが直感的でない |
+| 総当たり（各深さでループ） | O(n²)      | O(n)       | 非推奨                           |
 
-> 💡 **BFS（幅優先探索）を例え話で理解する**
-> BFS は「同じ階のすべての部屋を開けてから、次の階に進むエレベーター」のようなものです。
-> 木でいえば「同じ深さのノードをすべて処理してから、次の深さへ進む」動き方です。
-> これを実現するのが **キュー（＝先に入れたものを先に出す「行列」のデータ構造）** です。
-> 📖 **このセクションで登場した用語**
->
-> - **BFS（幅優先探索）**：グラフや木を「横方向に広がりながら」探索する方法
-> - **DFS（深さ優先探索）**：グラフや木を「縦方向に深く潜りながら」探索する方法
-> - **キュー**：先に入れたものを先に出す（FIFO: First In, First Out）データ構造。銀行の窓口の行列と同じ
+### BFS（幅優先探索）の仕組み
 
----
+BFS は「同じ階のすべての部屋を開けてから、次の階に進むエレベーター」のようなものです。
+これを実現するのが **キュー（FIFO: First In, First Out）** です。
 
-## 3. 選択したアルゴリズムと理由
+- **核心テクニック**: キューから「今の階のノード数分だけ」取り出すことで、自然に「1階ぶんのグループ」が作れる。
+- **TypeScript特有の工夫**: キューの型を `TreeNode[]` と明示することで、取り出した要素が必ず `TreeNode` 型になりコンパイル時に安全を保証。
 
-- **選択したアプローチ**: **BFS（幅優先探索）+ キュー**
-- **理由**:
-    - **DFS を選ばなかった理由**: DFS は縦に深く潜るため、「同じ階のノードをまとめる」処理と相性が悪く、深さ情報を別途管理する手間が増える
-    - **総当たりを選ばなかった理由**: ノードを重複して走査するため O(n²) になり、ノード数 2000 でも無駄が大きい
-    - **BFS を選んだ理由**: キューから「今の階のノード数分だけ」取り出すことで、自然に「1階ぶんのグループ」が作れる
+---
 
-- **TypeScript特有の最適化ポイント**:
-    - キューの型を `TreeNode[]` と明示することで、取り出した要素が必ず `TreeNode` 型になりコンパイル時に安全を保証
-    - `node.left` / `node.right` は `TreeNode | null` なので、`!== null` チェックで null を排除してからキューに追加する
+<h2 id="complexity">3. Complexity</h2>
 
-> 📖 **このセクションで登場した用語**
->
-> - **コンパイル時保証**：TypeScript がコードを変換する段階でエラーを検出すること。実行前にバグを防げる
-> - **FIFO**：First In, First Out。最初に入れたものを最初に取り出す順序
+| 項目           | 値   | 理由                                                                                         |
+| -------------- | ---- | -------------------------------------------------------------------------------------------- |
+| **時間計算量** | O(n) | 各ノードをキューへの追加・取り出しでちょうど1回ずつ処理するため（ポインタ管理で各操作 O(1)） |
+| **空間計算量** | O(n) | キューに最大で「木の最も広い階のノード数」が入る。最悪ケースは全ノード数 n に比例            |
 
 ---
 
-## 4. 実装コード
+<h2 id="implementation">4. Implementation</h2>
 
-> 💡 **コードの大まかな骨格**（コードを読む前にこの構造を頭に入れてください）
->
-> 1. `root` が `null` なら即座に空配列 `[]` を返す
-> 2. `root` をキューに入れて探索開始
-> 3. キューが空になるまで繰り返す
->     - 今の階のノード数（`levelSize`）を記録する
->     - ちょうど `levelSize` 個のノードを取り出し、その値を今の階の配列に追加
->     - 取り出したノードの左・右の子があればキューに追加（次の階の準備）
-> 4. 各階の配列を `result` に追加して返す
+### 業務開発版（型安全・パフォーマンス最適化）
 
 ```typescript
-// Runtime 2 ms
-// Beats 39.72%
-// Memory 60.20 MB
-// Beats 57.23%
-
 function levelOrder(root: TreeNode | null): number[][] {
-    // ─────────────────────────────────────────────────────────
-    // ① root が null（木が空）の場合は空配列を返す
-    //    後続でキューにアクセスするため、ここで弾かないと
-    //    null に対して .left などへアクセスしてクラッシュする
-    // ─────────────────────────────────────────────────────────
     if (root === null) return [];
 
-    // ─────────────────────────────────────────────────────────
-    // ② 結果を格納する2次元配列を用意する
-    //    result[0] = 深さ0のノード値の配列、
-    //    result[1] = 深さ1のノード値の配列、... となる
-    // ─────────────────────────────────────────────────────────
     const result: number[][] = [];
-
-    // ─────────────────────────────────────────────────────────
-    // ③ キュー（行列）を用意し、root を最初の要素として入れる
-    //    型を TreeNode[] と明示することで、取り出した要素が
-    //    null でないことをコンパイラが保証してくれる
-    //    （null をキューに入れないよう、後続の追加時にチェックする）
-    // ─────────────────────────────────────────────────────────
     const queue: TreeNode[] = [root];
+    let head = 0; // shift() の O(n) を避けるための先頭ポインタ
 
-    // ─────────────────────────────────────────────────────────
-    // ④ キューが空になるまでループ（= 全ノードを処理し終えるまで）
-    // ─────────────────────────────────────────────────────────
-    while (queue.length > 0) {
+    while (head < queue.length) {
         // ── 今この瞬間のキューの長さ = 「現在の階のノード数」 ──
-        // この値を先に固定するのが BFS の核心。
-        // ループ中に queue.length は変化するため、
-        // 先に変数に保存しておかないと「今の階」の範囲がズレる。
-        const levelSize: number = queue.length;
-
-        // 今の階のノード値を格納する一時配列
+        // 未処理分（queue.length - head）を変数に保存して固定する。
+        const levelSize: number = queue.length - head;
         const levelValues: number[] = [];
 
-        // 今の階のノードを「levelSize 個分」だけ取り出す
         for (let i = 0; i < levelSize; i++) {
-            // shift() でキューの先頭からノードを取り出す（FIFO）
-            // queue の要素は TreeNode[] なので null にならない（③で保証）
-            const node = queue.shift()!; // ! は「nullでないことをここで断言」
-
-            // 取り出したノードの値を今の階の配列に追加
+            // 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);
-            }
+            // 次の階の準備
+            if (node.left !== null) queue.push(node.left);
+            if (node.right !== null) queue.push(node.right);
         }
 
-        // 今の階分の値配列を結果に追加
         result.push(levelValues);
     }
 
@@ -177,115 +112,35 @@ function levelOrder(root: TreeNode | null): number[][] {
 }
 ```
 
----
-
-### 🔍 動作トレース（具体的な入力例での変数変化）
-
-**入力**: `root = [3, 9, 20, null, null, 15, 7]`（ツリー構造は下記）
-
-```
-    3
-   / \
-  9  20
-     / \
-    15   7
-```
+### 🔍 動作トレース（`root = [3, 9, 20, null, null, 15, 7]`）
 
 ```
-初期状態:
-  queue   = [Node(3)]
-  result  = []
-
 ━━━━━━━━━━ while ループ 1回目（深さ0） ━━━━━━━━━━
-  levelSize  = 1          ← 今の階のノード数は1
-  levelValues = []
-
-  i=0: node = queue.shift() → Node(3)  queue = []
-       levelValues.push(3)  → [3]
-       node.left  = Node(9)  → queue.push(Node(9))   queue = [Node(9)]
-       node.right = Node(20) → queue.push(Node(20))  queue = [Node(9), Node(20)]
-
-  result.push([3]) → result = [[3]]
+  levelSize  = 1          ← queue.length(1) - head(0) = 1
+  i=0: node = queue[head++] → Node(3)   queue = [3], head = 1
+       node.left = 9, node.right = 20 を queue に追加
+  result.push([3])
 
 ━━━━━━━━━━ while ループ 2回目（深さ1） ━━━━━━━━━━
-  levelSize  = 2          ← 今の階のノード数は2
-  levelValues = []
-
-  i=0: node = queue.shift() → Node(9)   queue = [Node(20)]
-       levelValues.push(9)  → [9]
-       node.left  = null → スキップ
-       node.right = null → スキップ
-
-  i=1: node = queue.shift() → Node(20)  queue = []
-       levelValues.push(20) → [9, 20]
-       node.left  = Node(15) → queue.push(Node(15))  queue = [Node(15)]
-       node.right = Node(7)  → queue.push(Node(7))   queue = [Node(15), Node(7)]
-
-  result.push([9,20]) → result = [[3], [9, 20]]
-
-━━━━━━━━━━ while ループ 3回目（深さ2） ━━━━━━━━━━
-  levelSize  = 2          ← 今の階のノード数は2
-  levelValues = []
-
-  i=0: node = queue.shift() → Node(15)  queue = [Node(7)]
-       levelValues.push(15) → [15]
-       node.left  = null → スキップ
-       node.right = null → スキップ
-
-  i=1: node = queue.shift() → Node(7)   queue = []
-       levelValues.push(7)  → [15, 7]
-       node.left  = null → スキップ
-       node.right = null → スキップ
-
-  result.push([15,7]) → result = [[3], [9, 20], [15, 7]]
-
-━━━━━━━━━━ queue が空 → ループ終了 ━━━━━━━━━━
-戻り値: [[3], [9, 20], [15, 7]] ✅
+  levelSize  = 2          ← queue.length(3) - head(1) = 2
+  i=0, 1: Node(9), Node(20) を処理
+  result.push([9, 20])
 ```
 
 ---
 
-### ✅ LeetCode 提出フォーマット（そのままコピー可）
-
-```typescript
-function levelOrder(root: TreeNode | null): number[][] {
-    if (root === null) return [];
-
-    const result: number[][] = [];
-    const queue: TreeNode[] = [root];
-
-    while (queue.length > 0) {
-        const levelSize: number = queue.length;
-        const levelValues: number[] = [];
-
-        for (let i = 0; i < levelSize; i++) {
-            const node = queue.shift()!;
-            levelValues.push(node.val);
+<h2 id="optimization">5. Optimization</h2>
 
-            if (node.left !== null) queue.push(node.left);
-            if (node.right !== null) queue.push(node.right);
-        }
+### パフォーマンス最適化：`Array.shift()` の回避
 
-        result.push(levelValues);
-    }
+JavaScript の `Array.shift()` は、先頭要素を削除した後に残り全要素のインデックスを 1 つずつ前にずらすため、**$O(n)$ の計算量**がかかります。
+キュー操作を伴う BFS で `shift()` をループ内で使用すると、全体の計算量が **$O(n^2)$** に悪化してしまいます。
 
-    return result;
-}
-```
+**解決策：**
+`head` 変数を用いて現在の先頭位置を指し示し、要素を取り出すたびに `head++` する方式を採用します。これにより、実質的な削除操作を伴わずに $O(1)$ で先頭要素を取得できます。
 
 > 📖 **このセクションで登場した用語**
 >
-> - **`shift()`**：配列の先頭要素を取り出して返すメソッド。キューの「取り出し」操作に使う
-> - **`push()`**：配列の末尾に要素を追加するメソッド。キューの「追加」操作に使う
-> - **`!`（非null断言）**：TypeScriptに「この値は絶対 null でない」と伝える記号。型チェックを強制的に通す代わりに、間違えると実行時エラーになるため、確信がある箇所にのみ使う
-> - **FIFO**：First In First Out。先に入れたものを先に取り出す順序。キューはこの性質を持つ
-> - **`readonly`（今回不使用だが参考）**：変数を変更不可にする TypeScript の修飾子。JavaScript には存在せず、コンパイル時の書き換えを防ぐために使う
-
----
-
-## 5. 計算量まとめ
-
-| 項目           | 値   | 理由                                                                              |
-| -------------- | ---- | --------------------------------------------------------------------------------- |
-| **時間計算量** | O(n) | 各ノードをキューへの追加・取り出しでちょうど1回ずつ処理するため                   |
-| **空間計算量** | O(n) | キューに最大で「木の最も広い階のノード数」が入る。最悪ケースは全ノード数 n に比例 |
+> - **`head` インデックス**：配列の先頭を指すポインタ。
+> - **FIFO**：First In First Out。先に入れたものを先に取り出す順序。
+> - **`!`（非null断言）**：TypeScriptに「この値は絶対 null でない」と伝える記号。
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md
index e4d16f5e..d63d4caa 100644
--- a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md	
+++ b/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md	
@@ -4,19 +4,15 @@
 
 ## 目次（Table of Contents）
 
-- [概要](#overview)
-- [アルゴリズム要点 TL;DR](#tldr)
-- [図解](#figures)
-- [正しさのスケッチ](#correctness)
-- [計算量](#complexity)
-- [Python 実装](#impl)
-- [CPython 最適化ポイント](#cpython)
-- [エッジケースと検証観点](#edgecases)
-- [FAQ](#faq)
+- [1. Overview](#overview)
+- [2. Algorithm](#algorithm)
+- [3. Complexity](#complexity)
+- [4. Implementation](#implementation)
+- [5. Optimization](#optimization)
 
 ---
 
-<h2 id="overview">概要</h2>
+<h2 id="overview">1. Overview</h2>
 
 > 💡 **この問題は一言で言うと「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」です。**
 
@@ -54,11 +50,10 @@
 
 ---
 
-<h2 id="tldr">アルゴリズム要点（TL;DR）</h2>
+<h2 id="algorithm">2. Algorithm</h2>
 
 > 💡 **TL;DR（Too Long; Didn't Read）** とは「長くて読めない人向けの要約」という意味です。
 > ここではアルゴリズム全体の戦略をざっくり把握するための章です。
-> 詳細は後の章で説明するので、**「なんとなくこういう手順で解くんだな」というイメージを掴む**ことを目的にしています。
 
 - **手法：BFS（幅優先探索）**
   木を「同じ深さのノードをすべて処理してから次の深さへ進む」順番で探索する。
@@ -71,36 +66,7 @@
 - **核心テクニック：`level_size = len(queue)` をループ前に固定する**
   ループ中にキューへの追加・取り出しが同時に起きるため、「今の階のサイズ」を先に変数へ保存しないとズレが生じる。
 
-- **時間計算量：O(n)** 各ノードをちょうど1回だけ処理する。
-
-- **空間計算量：O(n)** キューに最大で最下層のノード数（最大 n/2 個）が入る。
-
-- **`val = 0` への注意**
-  ノードの値が `-1000 〜 1000` のため `0` は普通に登場する。
-  `0 or 式` のような `or` トリックは `val=0` のとき `0`（falsy）と判定されて壊れるため**絶対に使わない**。
-
-> 📖 **この章で登場した用語**
->
-> - **TL;DR**：「長くて読めない人向けの要約」を意味する略語
-> - **キュー**：先に入れたものを先に取り出す（FIFO）データ構造。銀行の窓口の行列と同じ仕組み
-> - **falsy（フォールシー）**：Pythonで `if` の条件式が `False` 相当と見なされる値。`0`, `None`, `[]`, `""` などが該当する
-
----
-
-<h2 id="figures">図解</h2>
-
-> 💡 **Mermaid フローチャートの読み方：**
->
-> - **長方形 `[]`** は「処理ステップ」を表します。
-> - **ひし形 `{}`** は「条件分岐」を表します。Yes/No の矢印でどちらへ進むかが決まります。
-> - 矢印は処理の流れを示し、上から下（または左から右）へ読み進めます。
-
----
-
-### フローチャート
-
-この図は `levelOrder` 関数全体の処理の流れを表しています。
-上から下へ読み進めることで、BFS がどのように「階層ごと」に処理するかを確認できます。
+### 図解
 
 ```mermaid
 flowchart TD
@@ -126,634 +92,80 @@ flowchart TD
   NextI --> ForLoop
 ```
 
-**各ノードの意味：**
-
-- `Start`：関数の入り口。`root` を引数として受け取る
-- `IsNone`（ひし形）：`root` が `None`（空ツリー）かどうかを判定する
-- `RetEmpty`：空ツリーなら空リストを即返す
-- `Init`：`result = []` と `queue = deque([root])` を初期化する
-- `WhileLoop`（ひし形）：キューが空でない間ループを続ける判定
-- `FixSize`：**今の階のサイズを変数に固定する**（BFS の核心）
-- `InitVals`：今の階の値を格納する一時リストを作る
-- `ForLoop`（ひし形）：`level_size` 個分のノードを処理するループ判定
-- `PopNode`：`popleft()` でキューの先頭ノードを O(1) で取り出す
-- `AppendVal`：ノードの値を今の階のリストに追加する（`val=0` も正しく追加される）
-- `CheckLeft` / `CheckRight`（ひし形）：子が存在するかどうかを判定する
-- `PushLeft` / `PushRight`：子をキューの末尾に追加する（次の階として処理待ちにする）
-- `AppendLevel`：今の階の値リストを結果に追加する
-
----
-
-### データフロー図
-
-この図は入力ツリーがどのようにキューを経由して結果配列へ変換されるかのデータの流れを表しています。
-
-```mermaid
-graph LR
-  subgraph Input
-    Root[root TreeNode]
-  end
-  subgraph BFS_Core
-    Root --> Q[deque queue]
-    Q --> Pop[popleft O1]
-    Pop --> Val[node.val]
-    Pop --> Kids[left and right children]
-    Kids --> Q
-  end
-  subgraph Output
-    Val --> LV[level_values list]
-    LV --> Res[result 2D list]
-  end
-```
-
-**主要な流れの説明：**
-
-- `root → deque`：ルートノードをキューに入れてBFS開始
-- `popleft() → node.val`：先頭ノードを取り出してその値を今の階のリストへ追加
-- `left/right → deque`：子ノードをキューの末尾へ追加（次の階として登録）
-- `level_values → result`：今の階の値リストを結果の2次元配列へ追加
-
----
-
-> 💡 **代表例でのトレース：`root = [3, 9, 20, null, null, 15, 7]`**
-
-```
-ツリー:
-    3
-   / \
-  9  20
-     / \
-    15   7
-
-Step 1: Start → root = Node(3)
-Step 2: IsNone → No（rootは存在する）
-Step 3: Init → result=[], queue=deque([Node(3)])
-
-━━ while ループ 1回目（深さ0） ━━
-Step 4: FixSize → level_size = len(queue) = 1（ここで固定）
-Step 5: InitVals → vals = []
-Step 6: ForLoop i=0:
-        PopNode  → node = Node(3)   queue = deque([])
-        AppendVal → vals = [3]      （val=3 を正しく追加）
-        CheckLeft → Node(9) あり    → queue = deque([Node(9)])
-        CheckRight → Node(20) あり  → queue = deque([Node(9), Node(20)])
-Step 7: AppendLevel → result = [[3]]
-
-━━ while ループ 2回目（深さ1） ━━
-Step 8: FixSize → level_size = 2（ここで固定。以降 queue が変わっても影響しない）
-Step 9: ForLoop i=0:
-        PopNode  → node = Node(9)   queue = deque([Node(20)])
-        AppendVal → vals = [9]
-        left=None, right=None → スキップ
-        ForLoop i=1:
-        PopNode  → node = Node(20)  queue = deque([])
-        AppendVal → vals = [9, 20]
-        left=Node(15) → queue = deque([Node(15)])
-        right=Node(7) → queue = deque([Node(15), Node(7)])
-Step 10: AppendLevel → result = [[3], [9, 20]]
-
-━━ while ループ 3回目（深さ2） ━━
-Step 11: FixSize → level_size = 2
-         i=0: Node(15) → vals=[15]  子なし
-         i=1: Node(7)  → vals=[15,7] 子なし
-Step 12: AppendLevel → result = [[3], [9, 20], [15, 7]]
-
-Step 13: WhileLoop → queue が空 → ループ終了
-Step 14: RetResult → [[3], [9, 20], [15, 7]] ✅
-```
-
-> 📖 **この章で登場した用語**
->
-> - **フローチャート**：処理の手順を図形と矢印で表したもの。ひし形=条件分岐、長方形=処理
-> - **データフロー図**：データがどのように変換・移動するかを示す図
-> - **サブグラフ**：フローチャートの中で関連する処理をグループ化したもの
-> - **FIFO**：First In First Out。最初に入れたものを最初に取り出す順序。キューはこの性質を持つ
+### 正しさのスケッチ
 
----
-
-<h2 id="correctness">正しさのスケッチ</h2>
-
-> 💡 **「正しさのスケッチ」** とは、アルゴリズムが**常に正しい答えを返せる根拠**を整理したものです。
-> 数学的な厳密な証明ではなく「なぜ正しいと言えるか」の説明です。
+1. **不変条件**：「while ループの各反復の開始時点で、`queue` には現在の階のノードだけが入っている」
+    - `level_size` 回だけ `popleft()` することで今の階を全部処理し、その間に追加された子は「次の階」として末尾に積まれる。
+2. **網羅性**：ルートから始まり、全ノードの左右の子をキューに積むため、存在する全ノードがちょうど1回処理される。
+3. **基底条件**：`root is None` なら `[]` を返す。`while queue` で全ノード処理後に終了する。
 
 ---
 
-### 1. 不変条件（＝アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件）
-
-**「while ループの各反復の開始時点で、`queue` には現在の階のノードだけが入っている」**
-
-- ループ開始時：`level_size = len(queue)` で今の階のサイズを固定する
-- `level_size` 回だけ `popleft()` することで今の階のノードを全部取り出す
-- その間に追加された子ノードは「次の階」としてキューの末尾に積まれるだけで、今の階のカウントには影響しない
-- ループ終了時：キューには次の階のノードだけが残り、次の反復の開始時にも不変条件が保たれる
-
-### 2. 網羅性（＝すべてのケースをもれなく処理できているという保証）
-
-- 全ノードは「キューに積まれる」→「`popleft()` で取り出される」の2ステップを必ずたどる
-- ルートはループ前にキューに積まれる
-- 各ノードの左・右の子は「そのノードを処理するとき」に `None` チェックをしてからキューに積まれる
-- したがって、存在するすべてのノードがちょうど1回だけ処理される
-
-### 3. 基底条件（＝再帰の終了条件に相当する、処理を打ち切る条件）
-
-- `root is None`：ツリーが空の場合は即座に `[]` を返す
-  → これがないと `queue = deque([None])` となり `node.val` アクセスでクラッシュする
-- `while queue`：キューが空になった（全ノードを処理し終えた）ときにループを終了する
-  → これにより無限ループにならない
-
-### 4. 終了性（＝アルゴリズムが必ず有限ステップで終わるという保証）
-
-- ノード数は有限（最大 2000）
-- 各ノードはキューから取り出されると二度と積まれない（子ノードを追加するだけ）
-- したがって `popleft()` の合計呼び出し回数はノード数 n に等しく、ループは必ず終了する
-
-> 📖 **この章で登場した用語**
->
-> - **不変条件**：アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件
-> - **網羅性**：すべてのケースをもれなく処理できているという保証
-> - **基底条件**：処理を打ち切る（または再帰を終了させる）条件
-> - **終了性**：アルゴリズムが必ず有限ステップで終わるという保証
-
----
-
-<h2 id="complexity">計算量</h2>
-
-> 💡 **計算量** とは「入力が大きくなるにつれて、処理にかかる時間・メモリがどう増えるか」の目安です。
+<h2 id="complexity">3. Complexity</h2>
 
-| 記法         | 意味                   | 直感的なイメージ           |
-| ------------ | ---------------------- | -------------------------- |
-| `O(1)`       | 入力サイズによらず一定 | 辞書で直接ページを開く     |
-| `O(n)`       | 入力に比例して増加     | リストを端から順に読む     |
-| `O(n log n)` | n よりやや速く増加     | ソートアルゴリズムの典型   |
-| `O(n²)`      | 入力の2乗で増加        | 全ペアを総当たりで確認する |
+| 項目           | 値   | 理由                                                                         |
+| -------------- | ---- | ---------------------------------------------------------------------------- |
+| **時間計算量** | O(n) | 各ノードをキューへの追加・取り出しでちょうど1回ずつ処理する（各操作 O(1)）   |
+| **空間計算量** | O(n) | `result` 配列と、最大で最下層のノード数（最大 n/2 個）を保持するキューのため |
 
 ---
 
-### 時間計算量：O(n)
+<h2 id="implementation">4. Implementation</h2>
 
-- 各ノードはキューへの追加（`append`）とキューからの取り出し（`popleft`）を1回ずつ行う
-- どちらも `deque` の O(1) 操作なので、n ノード全体で O(n)
-- 結果配列へのリスト追加（`result.append(vals)`）も合計 O(n)
-
-### 空間計算量：O(n)
-
-- `result`（出力配列）：全ノードの値を格納するため O(n)
-- `queue`（キュー）：最大で「最も広い階のノード数」が同時に入る
-  完全二分木の最下層は最大 n/2 ノードなので O(n)
-
----
-
-### `list.pop(0)` を使った場合との比較
-
-「`list.pop(0)` ではダメなのか」を疑問に思う方のために比較します。
-
-| 手法                          | `popleft()` 1回の計算量    | 全体の時間計算量 |
-| ----------------------------- | -------------------------- | ---------------- |
-| `collections.deque.popleft()` | O(1)                       | **O(n)** ✅      |
-| `list.pop(0)`                 | O(n)（残り全要素をシフト） | **O(n²)** ❌     |
-
-n = 2000 のとき、`list.pop(0)` を使うと最大 2000 × 2000 = **4,000,000 回**の操作が発生します。
-`deque.popleft()` ならば **2000 回**で済みます。
-
-> 📖 **この章で登場した用語**
->
-> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
-> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
-> - **O(n²)**：入力が2倍になると処理が約4倍になること。`list.pop(0)` を n 回呼ぶと発生する
-
----
-
-<h2 id="impl">Python 実装</h2>
-
-> 💡 **コードを読む前に、実装の全体的な骨格を確認しましょう。**
->
-> 1. `root is None` チェックで空ツリーを即返す
-> 2. `result`（結果格納用）と `queue`（BFS用）を初期化する
-> 3. `while queue` でキューが空になるまでループ
-> 4. `level_size = len(queue)` で今の階のサイズを**変数に保存して固定**する（核心）
-> 5. `level_size` 回だけ `popleft()` し、値の収集と子の登録を行う
-> 6. 今の階の値リストを `result` に追加する
-> 7. すべての階を処理し終えたら `result` を返す
-
----
-
-### 業務開発版（型安全・pylance 対応）
-
-チームで長期間メンテナンスするプロダクションコードに向きます。
-型ヒントとコメントを充実させることで、後から読んだ人が意図を理解しやすい構造です。
+### Python 実装（業務開発版）
 
 ```python
-from __future__ import annotations
-
-# TYPE_CHECKING は pylance などの型チェッカーが動くときだけ True になる特殊フラグ。
-# これを使うことで「型チェック時のみ import する」定義を書ける。
-# 実行時（LeetCode のジャッジ）では TreeNode は既に定義済みなので import 不要。
-from typing import TYPE_CHECKING, Optional
 from collections import deque
-
-if TYPE_CHECKING:
-    # pylance に TreeNode の構造を教えるための型スタブ（型情報のみの定義）。
-    # 実行時には評価されないため、LeetCode 環境でエラーにならない。
-    class TreeNode:
-        val: int
-        left: Optional[TreeNode]
-        right: Optional[TreeNode]
-        def __init__(
-            self,
-            val: int = 0,
-            left: Optional[TreeNode] = None,
-            right: Optional[TreeNode] = None,
-        ) -> None: ...
-
+from typing import Optional
 
 class Solution:
-    """
-    LeetCode #102 Binary Tree Level Order Traversal
-
-    BFS（幅優先探索）+ collections.deque を使って
-    木を上から下へ階層ごとにグループ化して返す。
-    """
-
     def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
-        """
-        二分木のレベル順トラバーサルを返す（業務開発版）。
-
-        Args:
-            root: 二分木のルートノード。None の場合は空ツリーを意味する。
-
-        Returns:
-            各階層の値を格納した2次元リスト。
-            空ツリーの場合は空リスト [] を返す。
-
-        Complexity:
-            Time:  O(n) — 各ノードを1回だけキューに出し入れする
-            Space: O(n) — キューに最大で最下層のノード数が入る
-        """
-        # ── 基底条件：root が None（空ツリー）なら即座に空リストを返す ──
-        # Optional[TreeNode] 型のため、None チェックをしないと
-        # pylance が「None に .val はない」とエラーを報告する。
-        # ここで弾いた後は、以降のコードで root を TreeNode として安全に扱える。
         if root is None:
             return []
 
-        # 結果を格納する2次元リスト。
-        # result[0] = 深さ0の値リスト、result[1] = 深さ1の値リスト、...
         result: list[list[int]] = []
-
-        # collections.deque をキューとして使う。
-        # list.pop(0) は O(n) だが deque.popleft() は O(1)。
-        # deque はC言語実装の双方向キューで先頭・末尾への操作が高速。
         queue: deque[TreeNode] = deque([root])
 
-        # キューが空になるまでループ（= 全ノードを処理し終えるまで）
         while queue:
-            # ── BFS の核心：今の階のサイズをここで固定する ──
-            # ループ中に popleft()/append() が混在して queue の長さが変化するため、
-            # 先に変数へ保存しないと「今の階」の範囲がずれて Wrong Answer になる。
             level_size: int = len(queue)
-
-            # 今の階のノード値を格納する一時リスト
             level_values: list[int] = []
 
             for _ in range(level_size):
-                # popleft() でキューの先頭ノードを O(1) で取り出す
                 node: TreeNode = queue.popleft()
-
-                # ノードの値を直接 append する。
-                # `or` トリックは val=0 のとき 0（falsy）と判定されて壊れるため使わない。
-                # 制約 -1000 <= val <= 1000 の範囲では 0 が普通に登場する。
                 level_values.append(node.val)
 
-                # 子ノードをキューの末尾に追加する（次の階の準備）。
-                # is not None でチェックすることで、
-                # キューの中身が常に TreeNode 型であると保証できる。
-                # pylance も None をキューに入れようとするとエラーを検出する。
                 if node.left is not None:
                     queue.append(node.left)
                 if node.right is not None:
                     queue.append(node.right)
 
-            # 今の階の値リストを結果に追加
             result.append(level_values)
 
         return result
 ```
 
----
-
-### 競技プログラミング版（速度・簡潔さ優先）
-
-LeetCode などで制限時間内に正解を出すことが目的のコードに向きます。
-型ヒントは最小限に抑えつつ、**`val=0` を含む全テストケースで正しく動作**します。
-
-```python
-from collections import deque
-from typing import Optional
-
+### エッジケースと検証観点
 
-class Solution:
-    def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
-        # not root は「root が None」のとき True になる。
-        # TreeNode の __bool__ は未定義なので None チェックとして正しく機能する。
-        if not root:
-            return []
-
-        result: list[list[int]] = []
-        # C実装の deque でキューを初期化する。popleft() が O(1) のためキューとして最適。
-        queue: deque[TreeNode] = deque([root])
-
-        while queue:
-            # 今の階のサイズをループ前に固定する（絶対に省略できない）。
-            level_size = len(queue)
-            vals: list[int] = []
-
-            for _ in range(level_size):
-                node = queue.popleft()                    # 先頭ノードを O(1) で取得
-                vals.append(node.val)                     # val を直接追加（0 も正しく扱われる）
-                if node.left:                             # 左の子があればキューへ追加
-                    queue.append(node.left)
-                if node.right:                            # 右の子があればキューへ追加
-                    queue.append(node.right)
-
-            result.append(vals)
-
-        return result
-```
-
----
-
-> 💡 **コードの動作トレース：`root = [3, 9, 20, null, null, 15, 7]`**
-
-```
-初期状態:
-  queue  = deque([Node(3)])
-  result = []
-
-━━ while ループ 1回目（深さ0） ━━
-  level_size = 1        ← len(queue) を変数に保存して固定
-  vals = []
-
-  i=0: node = queue.popleft() → Node(3)   queue = deque([])
-       vals.append(3) → [3]   ← val=3 を正しく追加
-       node.left  = Node(9)  → queue.append → deque([Node(9)])
-       node.right = Node(20) → queue.append → deque([Node(9), Node(20)])
-
-  result.append([3]) → result = [[3]]
-
-━━ while ループ 2回目（深さ1） ━━
-  level_size = 2        ← キューに Node(9), Node(20) の2つが入っている
-  vals = []
-
-  i=0: node = Node(9)    queue = deque([Node(20)])
-       vals.append(9)  → [9]
-       left=None, right=None → スキップ
-
-  i=1: node = Node(20)   queue = deque([])
-       vals.append(20) → [9, 20]
-       left=Node(15)  → deque([Node(15)])
-       right=Node(7)  → deque([Node(15), Node(7)])
-
-  result.append([9, 20]) → result = [[3], [9, 20]]
-
-━━ while ループ 3回目（深さ2） ━━
-  level_size = 2
-  i=0: Node(15) → vals=[15]    子なし
-  i=1: Node(7)  → vals=[15, 7] 子なし
-
-  result.append([15, 7]) → result = [[3], [9, 20], [15, 7]]
-
-━━ queue が空 → ループ終了 ━━
-戻り値: [[3], [9, 20], [15, 7]] ✅
-```
-
-> 📖 **この章で登場した用語**
->
-> - **`from __future__ import annotations`**：型ヒントを文字列として扱い、前方参照や循環参照を解決できるようにする宣言
-> - **`TYPE_CHECKING`**：pylance などの型チェッカーが動くときだけ `True` になる特殊フラグ。実行時は `False`
-> - **`Optional[X]`**：`X` または `None` のどちらかであることを表す型ヒント
-> - **型スタブ**：実行はされないが型チェッカーに型情報を教えるためだけの定義
-> - **`deque([root])`**：`deque` を初期値ありで生成する書き方
-
----
-
-<h2 id="cpython">CPython 最適化ポイント</h2>
-
-> 💡 **この章では「同じ処理でも Python の書き方によって速さが変わる理由」を説明します。**
-> 最適化テクニックは「最適化前 → 最適化後 → なぜ速くなるか」の3点セットで示します。
-
----
-
-### ① `list.pop(0)` → `deque.popleft()` への置き換え
-
-```python
-# 最適化前：list の先頭取り出し（遅い）
-queue = [root]
-node = queue.pop(0)   # O(n): 残り全要素を1つずつ前にシフトする
-
-# 最適化後：deque の先頭取り出し（速い）
-from collections import deque
-queue = deque([root])
-node = queue.popleft()  # O(1): 双方向連結リストの先頭ポインタを1つ進めるだけ
-```
-
-**なぜ速くなるか：**
-`list.pop(0)` は Python の `list` が内部で「配列」として実装されているため、
-先頭を取り出すと残り全要素を1つ前にずらす処理が走ります（O(n)）。
-`deque` は「双方向連結リスト」として実装されているため、先頭ポインタを1つ進めるだけで済みます（O(1)）。
-`deque` の実装はC言語で書かれているため、Pure Python のループより大幅に高速です。
-
----
-
-### ② `or` トリックを使わない
-
-```python
-# 最適化前（競技版でよく見る書き方）：val=0 で壊れる ❌
-result.append([
-    (node := queue.popleft()).val
-    or queue.extend(c for c in (node.left, node.right) if c)
-    for _ in range(len(queue))
-])
-
-# 最適化後：シンプルな for ループ + append() ✅
-for _ in range(level_size):
-    node = queue.popleft()
-    vals.append(node.val)   # val=0 でも正しく追加される
-    if node.left:
-        queue.append(node.left)
-    if node.right:
-        queue.append(node.right)
-```
-
-**なぜ `or` トリックが壊れるか：**
-Python の `or` 演算子は「左辺が falsy（`0`, `None`, `False`, `[]` など）のとき右辺を評価する」性質を持ちます。
-`val = 0` のとき `0 or queue.extend(...)` は `extend()` を実行し、その戻り値は `None`。
-結果として `None` がリストに混入し、Wrong Answer になります。
-制約 `-1000 <= val <= 1000` では `0` は普通に登場するため、このバグは必ず踏みます。
-
----
-
-### ③ `Vec::with_capacity` 相当：`list` の事前確保
-
-```python
-# 最適化前：サイズが分からない状態でリストを作る
-vals = []
-
-# 最適化後：サイズが分かっているときは初期容量を指定する（Python ではリスト内包表記で代用）
-# ただし今回は append() の順序が重要なため、内包表記への置き換えは行わない。
-# level_size が分かっているので「最大 level_size 回の append()」が保証されており、
-# CPython の list は amortized O(1) で append するため実用上は問題ない。
-vals = []  # level_size 回の append() は amortized O(1)
-```
-
-**なぜ問題にならないか：**
-CPython の `list.append()` は内部で「容量が足りなくなったら2倍に拡張する」戦略（amortized O(1)）を採用しています。
-n 回の `append()` 全体では O(n) になるため、今回の実装では追加の最適化は不要です。
-
-> 📖 **この章で登場した用語**
->
-> - **双方向連結リスト**：各要素が「前の要素」と「次の要素」へのポインタを持つデータ構造。先頭・末尾への操作が O(1)
-> - **amortized O(1)**：1回の操作は最悪 O(n) になることがあるが、n 回の操作を平均するとO(1) になること
-> - **falsy**：Pythonで `if` 条件が `False` 相当と見なされる値。`0`, `None`, `[]`, `""` などが該当する
-> - **Pure Python**：C言語の拡張を使わず Python のみで書かれたコード。C実装より遅い
+| ケース             | 入力          | 期待出力        | 対処箇所                     |
+| ------------------ | ------------- | --------------- | ---------------------------- |
+| 空ツリー           | `root = None` | `[]`            | `if root is None: return []` |
+| `val = 0` のノード | `[0]`         | `[[0]]`         | `vals.append(node.val)`      |
+| 偏った木 (左のみ)  | `1→2→3`       | `[[1],[2],[3]]` | `level_size` の固定          |
 
 ---
 
-<h2 id="edgecases">エッジケースと検証観点</h2>
+<h2 id="optimization">5. Optimization</h2>
 
-> 💡 **エッジケース** とは「入力が空・最小値・最大値・特殊な構造」など、通常とは異なる境界的な入力のことです。
-> エッジケースを見落とすと、普通のテストは通るのに特定の入力でだけバグが発生します。
+### CPython 最適化ポイント
 
-| ケース                       | 入力                    | 期待出力                 | なぜ問題になりうるか                                               | 対処箇所                                    |
-| ---------------------------- | ----------------------- | ------------------------ | ------------------------------------------------------------------ | ------------------------------------------- |
-| 空ツリー                     | `root = None`           | `[]`                     | `queue.popleft()` や `node.val` にアクセスするとクラッシュする     | `if root is None: return []`                |
-| ノード1つ                    | `root = Node(1)`        | `[[1]]`                  | 子が存在しないため、子の追加ループがスキップされる必要がある       | `if node.left` で `None` を自然に弾く       |
-| `val = 0` のノード           | `root = Node(0)`        | `[[0]]`                  | `or` トリックで `0` が falsy と判定されて `None` が混入する        | `vals.append(node.val)` で直接追加          |
-| 左のみ偏った木               | `1→2→3`（左の子のみ）   | `[[1],[2],[3]]`          | 各階層にノードが1つずつ。`level_size=1` が毎回設定される必要がある | `level_size = len(queue)` が毎回正しく動く  |
-| 右のみ偏った木               | `1→2→3`（右の子のみ）   | `[[1],[2],[3]]`          | 左のみ偏った木と同様                                               | 同上                                        |
-| 完全二分木（最大）           | 2000 ノード、すべて存在 | 最下層に最大 1000 ノード | キューに 1000 ノードが同時に入る。`deque` なら問題なく処理できる   | O(1) の `popleft()` で十分に高速            |
-| `val = -1000` / `val = 1000` | 制約境界値              | そのまま返す             | 整数範囲の端の値が正しく扱われるか                                 | `append(node.val)` は整数をそのまま追加する |
-| すべてのノードの値が同じ     | 全ノード `val = 5`      | 各階層に `5` が並ぶ      | 値の比較は不要なので影響しないが、重複値でも正しく動くか確認が必要 | `append(node.val)` は値を問わず追加する     |
-
-> 📖 **この章で登場した用語**
->
-> - **エッジケース**：空のリスト・要素1つ・最大サイズ入力など、境界的な条件の入力
-> - **境界値**：制約の上限・下限にあたる値。例：ノード値 -1000 や 1000
-> - **偏った木（skewed tree）**：左または右の子のみを持つノードが連続した、ほぼリスト状の木構造
-
----
-
-<h2 id="faq">FAQ</h2>
-
-> 💡 **FAQ（Frequently Asked Questions）** とは「よくある質問と回答」のことです。
-> 初学者がつまずきやすいポイントを想定した質問をまとめています。
-> 各回答は「**結論 → 理由 → 補足（具体例）**」の順で書いています。
-
----
+1. **`list.pop(0)` → `deque.popleft()`**:
+   `list.pop(0)` は O(n) の要素シフトが発生し全体で O(n²) になるが、`deque.popleft()` は O(1) で動作する。
+2. **`or` トリックの回避**:
+   `0 or extend(...)` は `val=0`（falsy）のときに右辺を評価してしまい、戻り値 `None` がリストに混入するため、安全な `append()` を使用する。
 
-**Q1. なぜ `list.pop(0)` ではなく `collections.deque` を使うのですか？**
-
-**結論：** `list.pop(0)` はキューとして使うと全体の計算量が O(n²) になるため使いません。
-
-**理由：**
-Python の `list` は内部で「連続したメモリ領域（配列）」として実装されています。
-先頭要素を取り出す `pop(0)` は、残り全要素を1つずつ前にずらす処理が走るため O(n) かかります。
-これを n 回繰り返すと O(n²) になり、n=2000 では 4,000,000 回の操作が発生します。
-
-**補足：**
-`deque` は「双方向連結リスト」として実装されており、先頭・末尾への操作が O(1)。
-n 回の `popleft()` 全体でも O(n) で済みます。
-
----
-
-**Q2. `level_size = len(queue)` を変数に保存しないとどうなりますか？**
-
-**結論：** `for _ in range(len(queue))` と直接書くと、「今の階」の範囲がずれて Wrong Answer になります。
-
-**理由：**
-`range(len(queue))` はループ開始時に1回だけ評価されます。
-しかし `len(queue)` はあくまで「その時点」のサイズを返すだけで、
-ループ中に `popleft()` で減り `append()` で増えるため、次の階のノードも今の階として処理してしまいます。
-
-**補足：**
-
-```python
-# 危険な書き方（level_size を固定しない）
-while queue:
-    for _ in range(len(queue)):    # ← この len(queue) はループ開始時点の値のみ
-        node = queue.popleft()     # 取り出すたびに queue が縮む
-        if node.left:
-            queue.append(node.left)  # 追加で queue が増える → 次の階も処理してしまう
-
-# 正しい書き方（level_size を固定する）
-while queue:
-    level_size = len(queue)        # ← この時点でのサイズを変数に保存して固定
-    for _ in range(level_size):
-        ...
-```
+### FAQ
 
----
-
-**Q3. なぜ前回の競技版で `or` トリックを使ったのに Wrong Answer になったのですか？**
-
-**結論：** `val = 0` のノードがあると `0 or 式` の `0` が falsy と判定されて壊れます。
-
-**理由：**
-Python の `or` 演算子は「左辺が falsy なら右辺を評価して返す」性質を持ちます。
-`val = 0` のとき `node.val` は `0` なので、`0 or queue.extend(...)` の左辺は falsy と判定されます。
-その結果 `queue.extend(...)` が実行され、その戻り値（`None`）がリスト内包表記の要素として入ってしまいます。
-
-**補足：**
-制約 `-1000 <= val <= 1000` には `0` が含まれており、LeetCode の 2〜3 番目のテストケース付近で確実に踏みます。
-`vals.append(node.val)` と直接書けばどんな値でも正しく処理できます。
-
----
-
-**Q4. `if node.left:` と `if node.left is not None:` の違いは何ですか？どちらを使うべきですか？**
-
-**結論：** どちらも今回の問題では同じ動作をしますが、意図の明確さから `is not None` が推奨されます。
-
-**理由：**
-`TreeNode` は `__bool__` メソッドを定義していないため、`if node.left:` は「`None` かどうか」を判定しています。
-一方 `if node.left is not None:` は「`None` でないこと」を明示的に表現しており、読み手に意図が伝わりやすいです。
-pylance も `is not None` を推奨します（PEP8 準拠）。
-
-**補足：**
-競技プログラミング版では入力速度を重視して `if node.left:` と短く書くこともあります。
-業務開発版では `is not None` を使って意図を明確にするのが良い習慣です。
-
----
-
-**Q5. BFS と DFS のどちらを使っても答えは同じになりますか？どちらが良いですか？**
-
-**結論：** 両方でも正解は得られますが、**この問題には BFS の方が自然で実装しやすい**です。
-
-**理由：**
-DFS（深さ優先探索）は縦方向に深く潜るため、「同じ深さのノードをまとめる」処理のために
-「今どの深さにいるか」という情報を引数やデータ構造で別途管理する必要があります。
-BFS は「同じ深さのノードをまとめて処理してから次へ進む」動き方をするため、
-`level_size = len(queue)` だけで自然に階層分けができます。
-
-**補足：**
-DFS で解く場合はこのような設計になります：
-
-```python
-# DFS版（参考）：深さ情報を引数で持ち回る必要がある
-def dfs(node: Optional[TreeNode], depth: int, result: list[list[int]]) -> None:
-    if node is None:
-        return
-    if len(result) == depth:       # 今の深さの配列がまだない場合は追加
-        result.append([])
-    result[depth].append(node.val) # 深さをインデックスとして値を追加
-    dfs(node.left, depth + 1, result)
-    dfs(node.right, depth + 1, result)
-```
-
-BFS 版と比べてコードが複雑になり、再帰の深さがツリーの高さに比例してスタックを消費するデメリットもあります。
-
-> 📖 **この章で登場した用語**
->
-> - **FAQ**：Frequently Asked Questions の略。よくある質問と回答のこと
-> - **falsy**：Pythonで `if` 条件が `False` 相当と見なされる値。`0`, `None`, `[]` などが該当する
-> - **PEP8**：Pythonの公式スタイルガイド。`== None` より `is None` / `is not None` を推奨する
-> - **DFS（深さ優先探索）**：グラフや木を「縦方向に深く潜りながら」探索する方法。スタックや再帰で実装する
-> - **スタック**：後に入れたものを先に取り出す（LIFO）データ構造。関数の再帰呼び出しはスタックを消費する
+- **Q: なぜ `level_size` を先に保存するのですか？**
+    - **A**: ループ内で `append()` が行われるため、`len(queue)` が動的に増えてしまい、次の階のノードまで今の階として処理してしまうのを防ぐためです。
+- **Q: DFS でも解けますか？**
+    - **A**: はい。ただし「今どの深さにいるか」を引数で持ち回る必要があり、この問題には BFS の方が直感的で自然です。