diff --git a/problems/0047.全排列II.md b/problems/0047.全排列II.md
index 0cecac50..cce25cd9 100644
--- a/problems/0047.全排列II.md
+++ b/problems/0047.全排列II.md
@@ -292,6 +292,34 @@ var permuteUnique = function (nums) {
 
 ```
 
+### TypeScript
+
+```typescript
+function permuteUnique(nums: number[]): number[][] {
+    nums.sort((a, b) => a - b);
+    const resArr: number[][] = [];
+    const usedArr: boolean[] = new Array(nums.length).fill(false);
+    backTracking(nums, []);
+    return resArr;
+    function backTracking(nums: number[], route: number[]): void {
+        if (route.length === nums.length) {
+            resArr.push(route.slice());
+            return;
+        }
+        for (let i = 0, length = nums.length; i < length; i++) {
+            if (i > 0 && nums[i] === nums[i - 1] && usedArr[i - 1] === false) continue;
+            if (usedArr[i] === false) {
+                route.push(nums[i]);
+                usedArr[i] = true;
+                backTracking(nums, route);
+                usedArr[i] = false;
+                route.pop();
+            }
+        }
+    }
+};
+```
+
 ### Swift
 
 ```swift
diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md
index 496de431..7ecca773 100644
--- a/problems/0106.从中序与后序遍历序列构造二叉树.md
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@@ -790,7 +790,7 @@ func findRootIndex(target int,inorder []int) int{
 
 ```javascript
 var buildTree = function(inorder, postorder) {
-    if (!preorder.length) return null;
+    if (!inorder.length) return null;
     const rootVal = postorder.pop(); // 从后序遍历的数组中获取中间节点的值， 即数组最后一个值
     let rootIndex = inorder.indexOf(rootVal); // 获取中间节点在中序遍历中的下标
     const root = new TreeNode(rootVal); // 创建中间节点
diff --git a/problems/0108.将有序数组转换为二叉搜索树.md b/problems/0108.将有序数组转换为二叉搜索树.md
index bd5915fd..6ee3947b 100644
--- a/problems/0108.将有序数组转换为二叉搜索树.md
+++ b/problems/0108.将有序数组转换为二叉搜索树.md
@@ -355,6 +355,7 @@ func sortedArrayToBST(nums []int) *TreeNode {
 ```
 
 ## JavaScript 
+递归
 
 ```javascript
 var sortedArrayToBST = function (nums) {
@@ -372,7 +373,44 @@ var sortedArrayToBST = function (nums) {
     return buildTree(nums, 0, nums.length - 1);
 };
 ```
-
+迭代
+```JavaScript
+var sortedArrayToBST = function(nums) {
+    if(nums.length===0){
+        return null;
+    }
+    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);
+        
+        curNode.val=nums[mid]; //将下标为mid的元素给中间节点
+        
+//         处理左区间
+        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);
+            nodeQue.push(curNode.right);
+            leftQue.push(mid+1);
+            rightQue.push(right);
+        }
+    }
+    return root;
+};
+```
 ## TypeScript
 
 ```typescript
diff --git a/problems/周总结/20201112回溯周末总结.md b/problems/周总结/20201112回溯周末总结.md
index c61de4bb..af08097b 100644
--- a/problems/周总结/20201112回溯周末总结.md
+++ b/problems/周总结/20201112回溯周末总结.md
@@ -76,7 +76,7 @@
 * 空间复杂度：$O(n)$，递归深度为n，所以系统栈所用空间为$O(n)$，每一层递归所用的空间都是常数级别，注意代码里的result和path都是全局变量，就算是放在参数里，传的也是引用，并不会新申请内存空间，最终空间复杂度为$O(n)$。
 
 排列问题分析：
-* 时间复杂度：$O(n!)$，这个可以从排列的树形图中很明显发现，每一层节点为n，第二层每一个分支都延伸了n-1个分支，再往下又是n-2个分支，所以一直到叶子节点一共就是 n * n-1 * n-2 * ..... 1 = n!。
+* 时间复杂度：$O(n!)$，这个可以从排列的树形图中很明显发现，每一层节点为n，第二层每一个分支都延伸了n-1个分支，再往下又是n-2个分支，所以一直到叶子节点一共就是 n * n-1 * n-2 * ..... 1 = n!。每个叶子节点都会有一个构造全排列填进数组的操作（对应的代码：`result.push_back(path)`），该操作的复杂度为$O(n)$。所以，最终时间复杂度为：n * n!，简化为$O(n!)$。
 * 空间复杂度：$O(n)$，和子集问题同理。
 
 组合问题分析：