diff --git a/102. Binary Tree Level Order Traversal.md b/102. Binary Tree Level Order Traversal.md
new file mode 100644
index 0000000..567bc32
--- /dev/null
+++ b/102. Binary Tree Level Order Traversal.md	
@@ -0,0 +1,194 @@
+BFSで解くのが自然。
+
+1st
+
+BFS。`ans.append(values_of_this_level.copy())`は`copy`しなくても良いが、`copy`しておいた方が変更に強いかなと思いcopyした
+
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+        nodes = [root]
+        ans = []
+        while nodes:
+            values_of_this_level = []
+            next_level = []
+            for node in nodes:
+                values_of_this_level.append(node.val)
+                if node.left:
+                    next_level.append(node.left)
+                if node.right:
+                    next_level.append(node.right)
+            ans.append(values_of_this_level.copy())
+            nodes = next_level
+        return ans
+```
+
+2nd
+
+1stの書き直し。
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+        current_level = [root]
+        ans = []
+        while current_level:
+            values = []
+            next_level = []
+            for node in current_level:
+                values.append(node.val)
+                if node.left:
+                    next_level.append(node.left)
+                if node.right:
+                    next_level.append(node.right)
+            ans.append(values.copy())
+            current_level = next_level
+        return ans
+```
+
+Recursion
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        def order_nodes_by_level(node, level):
+            if len(nodes_ordered_by_level) < level:
+                nodes_ordered_by_level.append([])
+            nodes_ordered_by_level[level - 1].append(node.val)
+            if node.left:
+                order_nodes_by_level(node.left, level + 1)
+            if node.right:
+                order_nodes_by_level(node.right, level + 1)
+
+        if root is None:
+            return []
+        nodes_ordered_by_level = []
+        order_nodes_by_level(root, 1)
+        return nodes_ordered_by_level
+```
+
+> これ、一応 while にしておきます?
+まあ、2つ以上深いのがいきなり呼ばれることはないわけですが。
+
+> 私は、while だと思っていて、上から読んでいくと、
+「level が大きくて nodes_ordered_by_level が足りない場合、足りるように拡張します。そして、拡張した場所に書き込みます。」(読んでいくと、あとから、足りないことがあったとしても1段であることが他のところから分かる。)
+「level が大きくて nodes_ordered_by_level が足りない場合、1段だけ拡張します。そして、level 番目に書き込みます。(書き込めなかったら IndexError が投げられます。)」(読んでいくと、1段だけしか拡張しなくても、level 番目が準備されているので例外はないことが分かる。)
+というふうに読めます。どっちが読み手にとっていいですか。
+1段だけしか拡張しなくても例外が投げられることがないことに気がつくパズルを解かせる必要ないですよね。そうすると、下にするならば、コメント1行付けておいて、くらいの感覚です。
+
+deque
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+        nodes = deque([(root, 1)])
+        ans = []
+        while nodes:
+            node, level = nodes.popleft()
+            if len(ans) < level:
+                ans.append([])
+            ans[level - 1].append(node.val)
+            if node.left:
+                nodes.append((node.left, level + 1))
+            if node.right:
+                nodes.append((node.right, level + 1))
+        return ans
+```
+
+3rd
+
+だいたい1stと同じ。
+
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+        nodes = [root]
+        ans = []
+        while nodes:
+            values = []
+            next_nodes = []
+            for node in nodes:
+                values.append(node.val)
+                if node.left:
+                    next_nodes.append(node.left)
+                if node.right:
+                    next_nodes.append(node.right)
+            ans.append(values)
+            nodes = next_nodes
+        return ans
+```
+
+4th
+
+BFS, iterative
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+        nodes = [root]
+        orders = []
+        while nodes:
+            values = []
+            next_nodes = []
+            for node in nodes:
+                values.append(node.val)
+                if node.left:
+                    next_nodes.append(node.left)
+                if node.right:
+                    next_nodes.append(node.right)
+            orders.append(values)
+            nodes = next_nodes
+        return orders
+```
+
+DFS preorder, recursion
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+        
+        def traverse_nodes_by_level(node, level):
+            if node is None:
+                return
+            # DFSのpreorderで2つ飛ばしで深くことはないのでifで良い
+            if len(orders) < level:
+                orders.append([])
+            orders[level - 1].append(node.val)
+            traverse_nodes_by_level(node.left, level + 1)
+            traverse_nodes_by_level(node.right, level + 1)
+
+        orders = []
+        traverse_nodes_by_level(root, 1)
+        return orders
+```
+
+5th
+
+命名とかは若干違うかほぼ同じ。
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return []
+        nodes = [root]
+        level_ordered_nodes = []
+        while nodes:
+            next_nodes = []
+            current_level_values = []
+            for node in nodes:
+                current_level_values.append(node.val)
+                if node.left:
+                    next_nodes.append(node.left)
+                if node.right:
+                    next_nodes.append(node.right)
+            level_ordered_nodes.append(current_level_values)
+            nodes = next_nodes
+        return level_ordered_nodes
+```