Update 0108.将有序数组转换为二叉搜索树.md

problems/0108.将有序数组转换为二叉搜索树.md

@@ -316,73 +316,65 @@ class Solution {
 ```
 
 ## Python  
-**递归**
+递归法
-
 ```python
-# 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 sortedArrayToBST(self, nums: List[int]) -> TreeNode:
-        '''
-        构造二叉树：重点是选取数组最中间元素为分割点，左侧是递归左区间；右侧是递归右区间
-        必然是平衡树
-        左闭右闭区间
-        '''
-        # 返回根节点
-        root = self.traversal(nums, 0, len(nums)-1)
-        return root
-
     def traversal(self, nums: List[int], left: int, right: int) -> TreeNode:
-        # Base Case
         if left > right:
             return None
         
-        # 确定左右界的中心，防越界
         mid = left + (right - left) // 2
-        # 构建根节点
+        root = TreeNode(nums[mid])
-        mid_root = TreeNode(nums[mid])
+        root.left = self.traversal(nums, left, mid - 1)
-        # 构建以左右界的中心为分割点的左右子树
+        root.right = self.traversal(nums, mid + 1, right)
-        mid_root.left = self.traversal(nums, left, mid-1)
+        return root
-        mid_root.right = self.traversal(nums, mid+1, right)
+    
+    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
+        root = self.traversal(nums, 0, len(nums) - 1)
+        return root
 
-        # 返回由被传入的左右界定义的某子树的根节点
-        return mid_root
 ```
 
-**迭代**（左闭右开）
+迭代法
 ```python
+from collections import deque
+
 class Solution:
-    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
-        if len(nums) == 0: return None
+        if len(nums) == 0:
-        root = TreeNode()  # 初始化
+            return None
-        nodeSt = [root]
-        leftSt = [0]
-        rightSt = [len(nums)]
         
-        while nodeSt:
+        root = TreeNode(0)  # 初始根节点
-            node = nodeSt.pop()  # 处理根节点
+        nodeQue = deque()   # 放遍历的节点
-            left = leftSt.pop()
+        leftQue = deque()   # 保存左区间下标
-            right = rightSt.pop()
+        rightQue = deque()  # 保存右区间下标
+        
+        nodeQue.append(root)               # 根节点入队列
+        leftQue.append(0)                  # 0为左区间下标初始位置
+        rightQue.append(len(nums) - 1)     # len(nums) - 1为右区间下标初始位置
+
+        while nodeQue:
+            curNode = nodeQue.popleft()
+            left = leftQue.popleft()
+            right = rightQue.popleft()
             mid = left + (right - left) // 2
-            node.val = nums[mid]
 
-            if left < mid:  # 处理左区间
+            curNode.val = nums[mid]  # 将mid对应的元素给中间节点
-                node.left = TreeNode()
-                nodeSt.append(node.left)
-                leftSt.append(left)
-                rightSt.append(mid)
 
-            if right > mid + 1:  # 处理右区间
+            if left <= mid - 1:  # 处理左区间
-                node.right = TreeNode()
+                curNode.left = TreeNode(0)
-                nodeSt.append(node.right)
+                nodeQue.append(curNode.left)
-                leftSt.append(mid + 1)
+                leftQue.append(left)
-                rightSt.append(right)
+                rightQue.append(mid - 1)
+
+            if right >= mid + 1:  # 处理右区间
+                curNode.right = TreeNode(0)
+                nodeQue.append(curNode.right)
+                leftQue.append(mid + 1)
+                rightQue.append(right)
 
         return root
+
 ```
 
 ## Go