diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 1fb9b633..1a92d42f 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -246,7 +246,35 @@ var levelOrder = function(root) {
 
 ```
 
+TypeScript：
+
+```typescript
+function levelOrder(root: TreeNode | null): number[][] {
+    let helperQueue: TreeNode[] = [];
+    let res: number[][] = [];
+    let tempArr: number[] = [];
+    if (root !== null) helperQueue.push(root);
+    let curNode: TreeNode;
+    while (helperQueue.length > 0) {
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            curNode = helperQueue.shift()!;
+            tempArr.push(curNode.val);
+            if (curNode.left !== null) {
+                helperQueue.push(curNode.left);
+            }
+            if (curNode.right !== null) {
+                helperQueue.push(curNode.right);
+            }
+        }
+        res.push(tempArr);
+        tempArr = [];
+    }
+    return res;
+};
+```
+
 Swift:
+
 ```swift
 func levelOrder(_ root: TreeNode?) -> [[Int]] {
     var res = [[Int]]()
@@ -454,7 +482,31 @@ var levelOrderBottom = function(root) {
 };
 ```
 
+TypeScript:
+
+```typescript
+function levelOrderBottom(root: TreeNode | null): number[][] {
+    let helperQueue: TreeNode[] = [];
+    let resArr: number[][] = [];
+    let tempArr: number[] = [];
+    let tempNode: TreeNode;
+    if (root !== null) helperQueue.push(root);
+    while (helperQueue.length > 0) {
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            tempNode = helperQueue.shift()!;
+            tempArr.push(tempNode.val);
+            if (tempNode.left !== null) helperQueue.push(tempNode.left);
+            if (tempNode.right !== null) helperQueue.push(tempNode.right);
+        }
+        resArr.push(tempArr);
+        tempArr = [];
+    }
+    return resArr.reverse();
+};
+```
+
 Swift:
+
 ```swift
 func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
     var res =  [[Int]]()
@@ -657,7 +709,28 @@ var rightSideView = function(root) {
 };
 ```
 
+TypeScript：
+
+```typescript
+function rightSideView(root: TreeNode | null): number[] {
+    let helperQueue: TreeNode[] = [];
+    let resArr: number[] = [];
+    let tempNode: TreeNode;
+    if (root !== null) helperQueue.push(root);
+    while (helperQueue.length > 0) {
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            tempNode = helperQueue.shift()!;
+            if (i === length - 1) resArr.push(tempNode.val);
+            if (tempNode.left !== null) helperQueue.push(tempNode.left);
+            if (tempNode.right !== null) helperQueue.push(tempNode.right);
+        }
+    }
+    return resArr;
+};
+```
+
 Swift:
+
 ```swift
 func rightSideView(_ root: TreeNode?) -> [Int] {
     var res = [Int]()
@@ -868,7 +941,32 @@ var averageOfLevels = function(root) {
 };
 ```
 
+TypeScript：
+
+```typescript
+function averageOfLevels(root: TreeNode | null): number[] {
+    let helperQueue: TreeNode[] = [];
+    let resArr: number[] = [];
+    let total: number = 0;
+    let tempNode: TreeNode;
+    if (root !== null) helperQueue.push(root);
+    while (helperQueue.length > 0) {
+        let length = helperQueue.length;
+        for (let i = 0; i < length; i++) {
+            tempNode = helperQueue.shift()!;
+            total += tempNode.val;
+            if (tempNode.left) helperQueue.push(tempNode.left);
+            if (tempNode.right) helperQueue.push(tempNode.right);
+        }
+        resArr.push(total / length);
+        total = 0;
+    }
+    return resArr;
+};
+```
+
 Swift:
+
 ```swift
 func averageOfLevels(_ root: TreeNode?) -> [Double] {
     var res = [Double]()
@@ -1092,7 +1190,30 @@ var levelOrder = function(root) {
 };
 ```
 
+TypeScript:
+
+```typescript
+function levelOrder(root: Node | null): number[][] {
+    let helperQueue: Node[] = [];
+    let resArr: number[][] = [];
+    let tempArr: number[] = [];
+    if (root !== null) helperQueue.push(root);
+    let curNode: Node;
+    while (helperQueue.length > 0) {
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            curNode = helperQueue.shift()!;
+            tempArr.push(curNode.val);
+            helperQueue.push(...curNode.children);
+        }
+        resArr.push(tempArr);
+        tempArr = [];
+    }
+    return resArr;
+};
+```
+
 Swift:
+
 ```swift
 func levelOrder(_ root: Node?) -> [[Int]] {
     var res = [[Int]]()
@@ -1272,7 +1393,34 @@ var largestValues = function(root) {
 };
 ```
 
+TypeScript:
+
+```typescript
+function largestValues(root: TreeNode | null): number[] {
+    let helperQueue: TreeNode[] = [];
+    let resArr: number[] = [];
+    let tempNode: TreeNode;
+    let max: number = 0;
+    if (root !== null) helperQueue.push(root);
+    while (helperQueue.length > 0) {
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            tempNode = helperQueue.shift()!;
+            if (i === 0) {
+                max = tempNode.val;
+            } else {
+                max = max > tempNode.val ? max : tempNode.val;
+            }
+            if (tempNode.left) helperQueue.push(tempNode.left);
+            if (tempNode.right) helperQueue.push(tempNode.right);
+        }
+        resArr.push(max);
+    }
+    return resArr;
+};
+```
+
 Swift:
+
 ```swift
 func largestValues(_ root: TreeNode?) -> [Int] {
     var res = [Int]()
@@ -1463,6 +1611,31 @@ var connect = function(root) {
 };
 
 ```
+TypeScript:
+
+```typescript
+function connect(root: Node | null): Node | null {
+    let helperQueue: Node[] = [];
+    let preNode: Node, curNode: Node;
+    if (root !== null) helperQueue.push(root);
+    while (helperQueue.length > 0) {
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            if (i === 0) {
+                preNode = helperQueue.shift()!;
+            } else {
+                curNode = helperQueue.shift()!;
+                preNode.next = curNode;
+                preNode = curNode;
+            }
+            if (preNode.left) helperQueue.push(preNode.left);
+            if (preNode.right) helperQueue.push(preNode.right);
+        }
+        preNode.next = null;
+    }
+    return root;
+};
+```
+
 go:
 
 ```GO
@@ -1689,6 +1862,31 @@ var connect = function(root) {
     return root;
 };
 ```
+TypeScript:
+
+```typescript
+function connect(root: Node | null): Node | null {
+    let helperQueue: Node[] = [];
+    let preNode: Node, curNode: Node;
+    if (root !== null) helperQueue.push(root);
+    while (helperQueue.length > 0) {
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            if (i === 0) {
+                preNode = helperQueue.shift()!;
+            } else {
+                curNode = helperQueue.shift()!;
+                preNode.next = curNode;
+                preNode = curNode;
+            }
+            if (preNode.left) helperQueue.push(preNode.left);
+            if (preNode.right) helperQueue.push(preNode.right);
+        }
+        preNode.next = null;
+    }
+    return root;
+};
+```
+
 go:
 
 ```GO
@@ -1933,7 +2131,28 @@ var maxDepth = function(root) {
 };
 ```
 
+TypeScript:
+
+```typescript
+function maxDepth(root: TreeNode | null): number {
+    let helperQueue: TreeNode[] = [];
+    let resDepth: number = 0;
+    let tempNode: TreeNode;
+    if (root !== null) helperQueue.push(root);
+    while (helperQueue.length > 0) {
+        resDepth++;
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            tempNode = helperQueue.shift()!;
+            if (tempNode.left) helperQueue.push(tempNode.left);
+            if (tempNode.right) helperQueue.push(tempNode.right);
+        }
+    }
+    return resDepth;
+};
+```
+
 Swift:
+
 ```swift
 func maxDepth(_ root: TreeNode?) -> Int {
     guard let root = root else {
@@ -2130,7 +2349,29 @@ var minDepth = function(root) {
 };
 ```
 
+TypeScript:
+
+```typescript
+function minDepth(root: TreeNode | null): number {
+    let helperQueue: TreeNode[] = [];
+    let resMin: number = 0;
+    let tempNode: TreeNode;
+    if (root !== null) helperQueue.push(root);
+    while (helperQueue.length > 0) {
+        resMin++;
+        for (let i = 0, length = helperQueue.length; i < length; i++) {
+            tempNode = helperQueue.shift()!;
+            if (tempNode.left === null && tempNode.right === null) return resMin;
+            if (tempNode.left !== null) helperQueue.push(tempNode.left);
+            if (tempNode.right !== null) helperQueue.push(tempNode.right);
+        }
+    }
+    return resMin;
+};
+```
+
 Swift：
+
 ```swift
 func minDepth(_ root: TreeNode?) -> Int {
     guard let root = root else {