Invert Binary Tree

0226.Invert-Binary-Tree/memo.md

@@ -0,0 +1,41 @@
+# 226. Invert Binary Tree
+
+## step1
+
+再帰で書くとpost-orderのDFSが一番素直と思われる
+
+## step2
+post-orderを明示的に書く
+
+pre-order, in-orderも書く
+
+考え直すとpre-orderも自然。
+
+ループでも書き直す。ループで書くならpre-orderが最も自然
+
+{再帰, ループ} + {in-order, pre-order, post-order}の6通りできる。
+
+### 他の人のコード
+
+https://github.com/naoto-iwase/leetcode/pull/64
+
+https://github.com/ryosuketc/leetcode_grind75/pull/6
+
+https://github.com/Kitaken0107/GrindEasy/pull/9
+
+https://github.com/Ryotaro25/leetcode_first60/pull/71
+
+https://github.com/wf9a5m75/leetcode3/pull/13
+
+
+BFSを書いていなかったので書く
+
+tupleとlistどちらを使っても同じ場合はtupleを使うようにしているのだった。理由はオーバーヘッドが小さいから。
+
+https://github.com/tom4649/Coding/pull/25/changes#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5
+
+で実験した。
+
+ただし周囲のメンバーが違和感を感じる場合はそちらに合わせるのが良いだろう
+
+

0226.Invert-Binary-Tree/step1.py

@@ -0,0 +1,12 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if root is None:
+            return None
+        root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
+        return root

0226.Invert-Binary-Tree/step2.py

@@ -0,0 +1,134 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+# 明示的にpost-orderを表す
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if root is None:
+            return None
+
+        root.left = self.invertTree(root.left)
+        root.right = self.invertTree(root.right)
+        root.left, root.right = root.right, root.left
+
+        return root
+
+
+# pre-order
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if root is None:
+            return None
+
+        root.left, root.right = root.right, root.left
+
+        root.left = self.invertTree(root.left)
+        root.right = self.invertTree(root.right)
+
+        return root
+
+
+# in-order
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if root is None:
+            return None
+
+        left_subtree = root.left
+        right_subtree = root.right
+
+        self.invertTree(left_subtree)
+
+        root.left, root.right = right_subtree, left_subtree
+
+        self.invertTree(right_subtree)
+
+        return root
+
+
+# post-order
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if root is None:
+            return None
+
+        stack = [(root, False)]
+        while stack:
+            node, visited = stack.pop()
+            if node is None:
+                continue
+            if visited:
+                node.left, node.right = node.right, node.left
+            else:
+                stack.append((node, True))
+                stack.append((node.right, False))
+                stack.append((node.left, False))
+
+        return root
+
+
+# pre-order
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        stack = [root]
+
+        while stack:
+            node = stack.pop()
+            if node is None:
+                continue
+            node.left, node.right = node.right, node.left
+            stack.append(node.right)
+            stack.append(node.left)
+
+        return root
+
+
+# in-order
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if root is None:
+            return None
+
+        stack = [(root, root.left, root.right, False)]
+
+        while stack:
+            node, left_subtree, right_subtree, visited = stack.pop()
+            if node is None:
+                continue
+            if not visited:
+                if right_subtree is not None:
+                    stack.append(
+                        (right_subtree, right_subtree.left, right_subtree.right, False)
+                    )
+                stack.append((node, left_subtree, right_subtree, True))
+                if left_subtree is not None:
+                    stack.append(
+                        (left_subtree, left_subtree.left, left_subtree.right, False)
+                    )
+            else:
+                node.left, node.right = right_subtree, left_subtree
+
+        return root
+
+
+import collections
+
+
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if root is None:
+            return None
+
+        frontier = collections.deque((root,))
+
+        while frontier:
+            node = frontier.popleft()
+            node.left, node.right = node.right, node.left
+            for child in (node.left, node.right):
+                if child is not None:
+                    frontier.append(child)
+
+        return root