diff --git a/problems/0108.将有序数组转换为二叉搜索树.md b/problems/0108.将有序数组转换为二叉搜索树.md
index 9318a0e2..ffb60b38 100644
--- a/problems/0108.将有序数组转换为二叉搜索树.md
+++ b/problems/0108.将有序数组转换为二叉搜索树.md
@@ -35,7 +35,7 @@
 
 因为只要给我们一个有序数组，如果强调平衡，都可以以线性结构来构造二叉搜索树。 
 
-例如 有序数组[-10，-3，0，5，9] 可以就可以构造成这样的二叉搜索树，如图。 
+例如 有序数组[-10，-3，0，5，9] 就可以构造成这样的二叉搜索树，如图。 
 
 ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20220930173553.png)
 
@@ -147,7 +147,7 @@ public:
 };
 ```
 
-**注意：在调用traversal的时候为什么传入的left和right为什么是0和nums.size() - 1，因为定义的区间为左闭右闭**。
+**注意：在调用traversal的时候传入的left和right为什么是0和nums.size() - 1，因为定义的区间为左闭右闭**。
 
 
 ## 迭代法
@@ -354,10 +354,15 @@ class Solution:
 
 ```go
 func sortedArrayToBST(nums []int) *TreeNode {
-    if len(nums)==0{return nil}//终止条件，最后数组为空则可以返回
-    root:=&TreeNode{nums[len(nums)/2],nil,nil}//按照BSL的特点，从中间构造节点
-    root.Left=sortedArrayToBST(nums[:len(nums)/2])//数组的左边为左子树
-    root.Right=sortedArrayToBST(nums[len(nums)/2+1:])//数字的右边为右子树
+    if len(nums) == 0 {    //终止条件，最后数组为空则可以返回
+        return nil
+    }
+    idx := len(nums)/2
+    root := &TreeNode{Val: nums[idx]} 
+     
+    root.Left = sortedArrayToBST(nums[:idx])
+    root.Right = sortedArrayToBST(nums[idx+1:])
+
     return root
 }
 ```
@@ -384,33 +389,33 @@ var sortedArrayToBST = function (nums) {
 迭代
 ```JavaScript
 var sortedArrayToBST = function(nums) {
-    if(nums.length===0){
+    if(nums.length===0) {
         return null;
     }
-    let root=new TreeNode(0); //初始根节点
-    let nodeQue=[root]; //放遍历的节点,并初始化
-    let leftQue=[0]; //放左区间的下标,初始化
-    let rightQue=[nums.length-1]; // 放右区间的下标
+    let root = new TreeNode(0);       //初始根节点
+    let nodeQue = [root];             //放遍历的节点,并初始化
+    let leftQue = [0];                //放左区间的下标,初始化
+    let rightQue = [nums.length-1];   // 放右区间的下标
     
-    while(nodeQue.length){
-        let curNode=nodeQue.pop();
-        let left=leftQue.pop();
-        let right=rightQue.pop();
-        let mid=left+Math.floor((right-left)/2);
+    while(nodeQue.length) {
+        let curNode = nodeQue.pop();
+        let left = leftQue.pop();
+        let right = rightQue.pop();
+        let mid = left + Math.floor((right-left)/2);
         
-        curNode.val=nums[mid]; //将下标为mid的元素给中间节点
+        curNode.val = nums[mid];      //将下标为mid的元素给中间节点
         
 //         处理左区间
-        if(left<=mid-1){
-            curNode.left=new TreeNode(0);
+        if(left <= mid-1) {
+            curNode.left = new TreeNode(0);
             nodeQue.push(curNode.left);
             leftQue.push(left);
             rightQue.push(mid-1);
         }
         
 //         处理右区间
-        if(right>=mid+1){
-            curNode.right=new TreeNode(0);
+        if(right >= mid+1) {
+            curNode.right = new TreeNode(0);
             nodeQue.push(curNode.right);
             leftQue.push(mid+1);
             rightQue.push(right);