【Arai60】24問目 108_Convert Sorted Array to Binary Search Tree

arai60/21-29_Tree_BT_BST/24_108_Convert Sorted Array to Binary Search Tree/level_1.py

@@ -0,0 +1,45 @@
+# DFS
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        def helper(left, right):
+            if left > right:
+                return None
+            mid = (left + right) // 2
+            node = TreeNode(nums[mid])
+            node.left = helper(left, mid - 1)
+            node.right = helper(mid + 1, right)
+            return node
+
+        return helper(0, len(nums) - 1)
+
+
+# BFS
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        mid = (len(nums) - 1) // 2
+        root = TreeNode(nums[mid])
+        queue = deque([(root, (0, mid - 1), (mid + 1, len(nums) - 1))])
+        while queue:
+            node, left_range, right_range = queue.popleft()
+            if left_range[0] <= left_range[1]:
+                left_mid = (left_range[0] + left_range[1]) // 2
+                node.left = TreeNode(nums[left_mid])
+                queue.append(
+                    (
+                        node.left,
+                        (left_range[0], left_mid - 1),
+                        (left_mid + 1, left_range[1]),
+                    )
+                )
+            if right_range[0] <= right_range[1]:
+                right_mid = (right_range[0] + right_range[1]) // 2
+                node.right = TreeNode(nums[right_mid])
+                queue.append(
+                    (
+                        node.right,
+                        (right_range[0], right_mid - 1),
+                        (right_mid + 1, right_range[1]),
+                    )
+                )
+
+        return root

arai60/21-29_Tree_BT_BST/24_108_Convert Sorted Array to Binary Search Tree/level_2.py

@@ -0,0 +1,44 @@
+# DFSでnodeを作成していく
+# helper関数を使わない形に修正
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        if not nums:
+            return None
+        mid = (len(nums) - 1) // 2
+        node = TreeNode(val=nums[mid])
+        node.left = self.sortedArrayToBST(nums[:mid])
+        node.right = self.sortedArrayToBST(nums[mid + 1 :])
+        return node
+
+
+# BFS
+# queueの中身をlistに変更
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        mid = (len(nums) - 1) // 2
+        root = TreeNode(nums[mid])
+        queue = deque([(root, nums[:mid], nums[mid + 1 :])])
+        while queue:
+            node, left_nums, right_nums = queue.popleft()
+            if left_nums:
+                left_mid = (len(left_nums) - 1) // 2
+                node.left = TreeNode(left_nums[left_mid])
+                queue.append(
+                    (
+                        node.left,
+                        left_nums[:left_mid],
+                        left_nums[left_mid + 1 :],
+                    )
+                )
+            if right_nums:
+                right_mid = (len(right_nums) - 1) // 2
+                node.right = TreeNode(right_nums[right_mid])
+                queue.append(
+                    (
+                        node.right,
+                        right_nums[:right_mid],
+                        right_nums[right_mid + 1 :],
+                    )
+                )
+
+        return root

arai60/21-29_Tree_BT_BST/24_108_Convert Sorted Array to Binary Search Tree/level_3.py

@@ -0,0 +1,14 @@
+# DFS
+# level1と同じものが一番シンプルで書きやすい
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        def helper(left, right):
+            if left > right:
+                return None
+            mid = (left + right) // 2
+            node = TreeNode(nums[mid])
+            node.left = helper(left, mid - 1)
+            node.right = helper(mid + 1, right)
+            return node
+
+        return helper(0, len(nums) - 1)

arai60/21-29_Tree_BT_BST/24_108_Convert Sorted Array to Binary Search Tree/level_4.py

@@ -0,0 +1,85 @@
+# DFSでnodeを作成していく(再帰①)
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        if not nums:
+            return None
+        mid = (len(nums) - 1) // 2
+        node = TreeNode(val=nums[mid])
+        node.left = self.sortedArrayToBST(nums[:mid])  # 帰りがけの作業
+        node.right = self.sortedArrayToBST(nums[mid + 1 :])  # 帰りがけの作業
+        return node
+
+
+# DFSでnodeを作成していく(再帰②)
+# 呼び出された側でnodeの書き込みまで行う
+# rootだけは別途作成が必要
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+
+        def helper(node, index, nums):
+            left_nums = nums[:index]
+            if left_nums:
+                left_mid = (len(left_nums) - 1) // 2
+                node.left = TreeNode(val=left_nums[left_mid])
+                helper(node.left, left_mid, left_nums)
+            right_nums = nums[index + 1 :]
+            if right_nums:
+                right_mid = (len(right_nums)) // 2
+                node.right = TreeNode(val=right_nums[right_mid])
+                helper(node.right, right_mid, right_nums)
+
+        mid = (len(nums) - 1) // 2
+        root = TreeNode(val=nums[mid])
+        helper(root, mid, nums)
+        return root
+
+
+# 再帰②をstackで実装
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        mid = (len(nums) - 1) // 2
+        root = TreeNode(val=nums[mid])
+        stack = [(root, mid, nums)]
+
+        while stack:
+            node, index, nums_list = stack.pop()
+            left_nums = nums_list[:index]
+            if left_nums:
+                left_mid = (len(left_nums) - 1) // 2
+                node.left = TreeNode(val=left_nums[left_mid])
+                stack.append((node.left, left_mid, left_nums))
+            right_nums = nums_list[index + 1 :]
+            if right_nums:
+                right_mid = (len(right_nums)) // 2
+                node.right = TreeNode(val=right_nums[right_mid])
+                stack.append((node.right, right_mid, right_nums))
+
+        return root
+
+
+# BFS
+# queueの中身をlistに変更
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+
+        def create_child(child_nums):
+            if not child_nums:
+                return 0, None
+            mid = (len(child_nums) - 1) // 2
+            child = TreeNode(child_nums[mid])
+            return mid, child
+
+        if not nums:
+            return None
+        mid = (len(nums) - 1) // 2
+        root = TreeNode(nums[mid])
+        queue = deque([(root, nums[:mid], nums[mid + 1 :])])
+        while queue:
+            parent, left_nums, right_nums = queue.popleft()
+            left_mid, parent.left = create_child(left_nums)
+            if parent.left:
+                queue.append((parent.left, left_nums[:left_mid], left_nums[left_mid + 1 :]))
+            right_mid, parent.right = create_child(right_nums)
+            if parent.right:
+                queue.append((parent.right, right_nums[:right_mid], right_nums[right_mid + 1 :]))
+        return root