diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
index 3bdd862f..40e3e18e 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -21,7 +21,7 @@
 
 对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了**其实我们要比较的是两个树（这两个树是根节点的左右子树）**，所以在递归遍历的过程中，也是要同时遍历两棵树。
 
-那么如果比较呢？
+那么如何比较呢？
 
 比较的是两个子树的里侧和外侧的元素是否相等。如图所示：
 
@@ -80,7 +80,7 @@ else if (left == NULL && right == NULL) return true;
 else if (left->val != right->val) return false; // 注意这里我没有使用else
 ```
 
-注意上面最后一种情况，我没有使用else，而是elseif， 因为我们把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。
+注意上面最后一种情况，我没有使用else，而是else if， 因为我们把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。
 
 3.  确定单层递归的逻辑
 
@@ -244,7 +244,7 @@ public:
 
 这次我们又深度剖析了一道二叉树的“简单题”，大家会发现，真正的把题目搞清楚其实并不简单，leetcode上accept了和真正掌握了还是有距离的。
 
-我们介绍了递归法和迭代法，递归依然通过递归三部曲来解决了这道题目，如果只看精简的代码根本看不出来递归三部曲是如果解题的。
+我们介绍了递归法和迭代法，递归依然通过递归三部曲来解决了这道题目，如果只看精简的代码根本看不出来递归三部曲是如何解题的。
 
 在迭代法中我们使用了队列，需要注意的是这不是层序遍历，而且仅仅通过一个容器来成对的存放我们要比较的元素，知道这一本质之后就发现，用队列，用栈，甚至用数组，都是可以的。
 
@@ -259,7 +259,7 @@ public:
 
 # 其他语言版本
 
-## Java
+Java
 
 ```Java
     /**
@@ -364,7 +364,7 @@ public:
 
 ```
 
-## Python
+Python
 
 递归法:
 ```python
@@ -464,8 +464,7 @@ class Solution:
         return True
 ```
 
-## Go
-
+Go
 ```go
 /**
  * Definition for a binary tree node.
@@ -488,10 +487,12 @@ func defs(left *TreeNode, right *TreeNode) bool {
     }
     return defs(left.Left, right.Right) && defs(right.Left, left.Right);
 }
+
 func isSymmetric(root *TreeNode) bool {
     return defs(root.Left, root.Right);
 }
 
+
 // 迭代
 func isSymmetric(root *TreeNode) bool {
     var queue []*TreeNode;
@@ -515,59 +516,60 @@ func isSymmetric(root *TreeNode) bool {
 ```
 
 
-## JavaScript
+JavaScript
 
 递归判断是否为对称二叉树：
 ```javascript
 var isSymmetric = function(root) {
-    //使用递归遍历左右子树 递归三部曲
+    // 使用递归遍历左右子树 递归三部曲
     // 1. 确定递归的参数 root.left root.right和返回值true false 
-    const compareNode=function(left,right){
-        //2. 确定终止条件 空的情况
-        if(left===null&&right!==null||left!==null&&right===null){
+    const compareNode = function(left, right) {
+        // 2. 确定终止条件 空的情况
+        if(left === null && right !== null || left !== null && right === null) {
             return false;
-        }else if(left===null&&right===null){
+        } else if(left === null && right === null) {
             return true;
-        }else if(left.val!==right.val){
+        } else if(left.val !== right.val) {
             return false;
         }
-        //3. 确定单层递归逻辑
-        let outSide=compareNode(left.left,right.right);
-        let inSide=compareNode(left.right,right.left);
-        return outSide&&inSide;
+        // 3. 确定单层递归逻辑
+        let outSide = compareNode(left.left, right.right);
+        let inSide = compareNode(left.right, right.left);
+        return outSide && inSide;
     }
-    if(root===null){
+    if(root === null) {
         return true;
     }
-    return compareNode(root.left,root.right);
+    return compareNode(root.left, root.right);
 };
 ```
 
 队列实现迭代判断是否为对称二叉树：
 ```javascript
 var isSymmetric = function(root) {
-  //迭代方法判断是否是对称二叉树
-  //首先判断root是否为空
-  if(root===null){
+  // 迭代方法判断是否是对称二叉树
+  // 首先判断root是否为空
+  if(root === null) {
       return true;
   }
-  let queue=[];
+  let queue = [];
   queue.push(root.left);
   queue.push(root.right);
-  while(queue.length){
-      let leftNode=queue.shift();//左节点
-      let rightNode=queue.shift();//右节点
-      if(leftNode===null&&rightNode===null){
+  while(queue.length) {
+      let leftNode = queue.shift();    //左节点
+      let rightNode = queue.shift();   //右节点
+      if(leftNode === null && rightNode === null) {
           continue;
       }
-      if(leftNode===null||rightNode===null||leftNode.val!==rightNode.val){
+      if(leftNode === null || rightNode === null || leftNode.val !== rightNode.val) {
           return false;
       }
-      queue.push(leftNode.left);//左节点左孩子入队
-      queue.push(rightNode.right);//右节点右孩子入队
-      queue.push(leftNode.right);//左节点右孩子入队
-      queue.push(rightNode.left);//右节点左孩子入队
+      queue.push(leftNode.left);     //左节点左孩子入队
+      queue.push(rightNode.right);   //右节点右孩子入队
+      queue.push(leftNode.right);    //左节点右孩子入队
+      queue.push(rightNode.left);    //右节点左孩子入队
   }
+  
   return true;
 };
 ```
@@ -575,33 +577,34 @@ var isSymmetric = function(root) {
 栈实现迭代判断是否为对称二叉树：
 ```javascript
 var isSymmetric = function(root) {
-  //迭代方法判断是否是对称二叉树
-  //首先判断root是否为空
-  if(root===null){
+  // 迭代方法判断是否是对称二叉树
+  // 首先判断root是否为空
+  if(root === null) {
       return true;
   }
-  let stack=[];
+  let stack = [];
   stack.push(root.left);
   stack.push(root.right);
-  while(stack.length){
-      let rightNode=stack.pop();//左节点
-      let leftNode=stack.pop();//右节点
-      if(leftNode===null&&rightNode===null){
+  while(stack.length) {
+      let rightNode = stack.pop();    //左节点
+      let leftNode=stack.pop();       //右节点
+      if(leftNode === null && rightNode === null) {
           continue;
       }
-      if(leftNode===null||rightNode===null||leftNode.val!==rightNode.val){
+      if(leftNode === null || rightNode === null || leftNode.val !== rightNode.val) {
           return false;
       }
-      stack.push(leftNode.left);//左节点左孩子入队
-      stack.push(rightNode.right);//右节点右孩子入队
-      stack.push(leftNode.right);//左节点右孩子入队
-      stack.push(rightNode.left);//右节点左孩子入队
+      stack.push(leftNode.left);      //左节点左孩子入队
+      stack.push(rightNode.right);    //右节点右孩子入队
+      stack.push(leftNode.right);     //左节点右孩子入队
+      stack.push(rightNode.left);     //右节点左孩子入队
   }
+  
   return true;
 };
 ```
 
-## TypeScript：
+TypeScript：
 
 > 递归法
 
@@ -670,7 +673,7 @@ function isSymmetric(root: TreeNode | null): boolean {
 };
 ```
 
-## Swift:
+Swift:
 
 > 递归
 ```swift
@@ -752,7 +755,7 @@ func isSymmetric3(_ root: TreeNode?) -> Bool {
 }
 ```
 
-## Scala
+Scala
 
 > 递归：
 ```scala
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 1a01c0ae..9985971f 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -47,7 +47,7 @@
 
 层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
 
-需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
+需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
 
 **而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。**
 
@@ -106,50 +106,6 @@ public:
 };
 ```
 
-python3代码：
-
-
-```python
-
-class Solution:
-    """二叉树层序遍历迭代解法"""
-
-    def levelOrder(self, root: TreeNode) -> List[List[int]]:
-        results = []
-        if not root:
-            return results
-        
-        from collections import deque
-        que = deque([root])
-        
-        while que:
-            size = len(que)
-            result = []
-            for _ in range(size):
-                cur = que.popleft()
-                result.append(cur.val)
-                if cur.left:
-                    que.append(cur.left)
-                if cur.right:
-                    que.append(cur.right)
-            results.append(result)
-
-        return results
-```
-```python
-# 递归法
-class Solution:
-    def levelOrder(self, root: TreeNode) -> List[List[int]]:
-        res = []
-        def helper(root, depth):
-            if not root: return []
-            if len(res) == depth: res.append([]) # start the current depth
-            res[depth].append(root.val) # fulfil the current depth
-            if  root.left: helper(root.left, depth + 1) # process child nodes for the next depth
-            if  root.right: helper(root.right, depth + 1)
-        helper(root, 0)
-        return res
-```
 java: 
 
 ```Java
@@ -206,6 +162,51 @@ class Solution {
 }
 ```
 
+python3代码：
+
+
+```python
+
+class Solution:
+    """二叉树层序遍历迭代解法"""
+
+    def levelOrder(self, root: TreeNode) -> List[List[int]]:
+        results = []
+        if not root:
+            return results
+        
+        from collections import deque
+        que = deque([root])
+        
+        while que:
+            size = len(que)
+            result = []
+            for _ in range(size):
+                cur = que.popleft()
+                result.append(cur.val)
+                if cur.left:
+                    que.append(cur.left)
+                if cur.right:
+                    que.append(cur.right)
+            results.append(result)
+
+        return results
+```
+```python
+# 递归法
+class Solution:
+    def levelOrder(self, root: TreeNode) -> List[List[int]]:
+        res = []
+        def helper(root, depth):
+            if not root: return []
+            if len(res) == depth: res.append([]) # start the current depth
+            res[depth].append(root.val) # fulfil the current depth
+            if  root.left: helper(root.left, depth + 1) # process child nodes for the next depth
+            if  root.right: helper(root.right, depth + 1)
+        helper(root, 0)
+        return res
+```
+
 go: 
 
 ```go
@@ -243,28 +244,31 @@ func levelOrder(root *TreeNode) [][]int {
 102. 二叉树的层序遍历
  */
 func levelOrder(root *TreeNode) [][]int {
-    res:=[][]int{}
-    if root==nil{//防止为空
+    res := [][]int{}
+    if root == nil{//防止为空
         return res
     }
-    queue:=list.New()
+    queue := list.New()
     queue.PushBack(root)
+    
     var tmpArr []int
-    for queue.Len()>0 {
-        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-        for i:=0;i<length;i++{
-            node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
-            if node.Left!=nil{
+    
+    for queue.Len() > 0 {
+        length := queue.Len()               //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*TreeNode)    //出队列
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
+            tmpArr = append(tmpArr, node.Val)    //将值加入本层切片中
         }
-        res=append(res,tmpArr)//放入结果集
-        tmpArr=[]int{}//清空层的数据
+        res = append(res, tmpArr)          //放入结果集
+        tmpArr = []int{}                  //清空层的数据
     }
+    
     return res
 }
 ```
@@ -274,22 +278,22 @@ javascript代码：
 ```javascript
 var levelOrder = function(root) {
     //二叉树的层序遍历
-    let res=[],queue=[];
+    let res = [], queue = [];
     queue.push(root);
-    if(root===null){
+    if(root === null) {
         return res;
     }
-    while(queue.length!==0){
+    while(queue.length !== 0) {
         // 记录当前层级节点数
-        let length=queue.length;
+        let length = queue.length;
         //存放每一层的节点 
-        let curLevel=[];
-        for(let i=0;i<length;i++){
-            let node=queue.shift();
+        let curLevel = [];
+        for(let i = 0;i < length; i++) {
+            let node = queue.shift();
             curLevel.push(node.val);
             // 存放当前层下一层的节点
-            node.left&&queue.push(node.left);
-            node.right&&queue.push(node.right);
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
         }
         //把每一层的结果放到结果数组
         res.push(curLevel);
@@ -535,31 +539,34 @@ go:
 107. 二叉树的层序遍历 II
  */
 func levelOrderBottom(root *TreeNode) [][]int {
-    queue:=list.New()
-    res:=[][]int{}
-    if root==nil{
+    queue := list.New()
+    res := [][]int{}
+    if root == nil{
         return res
     }
     queue.PushBack(root)
-    for queue.Len()>0{
-        length:=queue.Len()
-        tmp:=[]int{}
-        for i:=0;i<length;i++{
-            node:=queue.Remove(queue.Front()).(*TreeNode)
-            if node.Left!=nil{
+    
+    for queue.Len() > 0 {
+        length := queue.Len()
+        tmp := []int{}
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*TreeNode)
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmp=append(tmp,node.Val)
+            tmp = append(tmp, node.Val)
         }
-        res=append(res,tmp)
+        res=append(res, tmp)
     }
+    
     //反转结果集
-    for i:=0;i<len(res)/2;i++{
-        res[i],res[len(res)-i-1]=res[len(res)-i-1],res[i]
+    for i:=0; i<len(res)/2; i++ {
+        res[i], res[len(res)-i-1] = res[len(res)-i-1], res[i]
     }
+    
     return res
 }
 ```
@@ -568,20 +575,20 @@ javascript代码
 
 ```javascript
 var levelOrderBottom = function(root) {
-    let res=[],queue=[];
+    let res = [], queue = [];
     queue.push(root);
-    while(queue.length&&root!==null){
+    while(queue.length && root!==null) {
         // 存放当前层级节点数组
-        let curLevel=[];
+        let curLevel = [];
         // 计算当前层级节点数量
-        let length=queue.length;
-        while(length--){
-            let node=queue.shift();
+        let length = queue.length;
+        while(length--) {
+            let node = queue.shift();
             // 把当前层节点存入curLevel数组
             curLevel.push(node.val);
             // 把下一层级的左右节点存入queue队列
-            node.left&&queue.push(node.left);
-            node.right&&queue.push(node.right);
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
         }
 	// 从数组前头插入值，避免最后反转数组，减少运算时间
         res.unshift(curLevel);
@@ -852,21 +859,23 @@ javascript代码:
 ```javascript
 var rightSideView = function(root) {
     //二叉树右视图 只需要把每一层最后一个节点存储到res数组
-    let res=[],queue=[];
+    let res = [], queue = [];
     queue.push(root);
-    while(queue.length&&root!==null){
+    
+    while(queue.length && root!==null) {
         // 记录当前层级节点个数
-        let length=queue.length;
-        while(length--){
-            let node=queue.shift();
-            //length长度为0的时候表明到了层级最后一个节点
-            if(!length){
+        let length = queue.length;
+        while(length--) {
+            let node = queue.shift();
+            // length长度为0的时候表明到了层级最后一个节点
+            if(!length) {
                 res.push(node.val);
             }
-            node.left&&queue.push(node.left);
-            node.right&&queue.push(node.right);
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
         }
     }
+    
     return res;
 };
 ```
@@ -1129,22 +1138,24 @@ javascript代码：
 ```javascript
 var averageOfLevels = function(root) {
     //层级平均值
-    let res=[],queue=[];
+    let res = [], queue = [];
     queue.push(root);
-    while(queue.length&&root!==null){
+    
+    while(queue.length && root!==null) {
         //每一层节点个数
-        let length=queue.length;
+        let length = queue.length;
         //sum记录每一层的和
-        let sum=0;
-        for(let i=0;i<length;i++){
-            let node=queue.shift();
-            sum+=node.val;
-            node.left&&queue.push(node.left);
-            node.right&&queue.push(node.right);
+        let sum = 0;
+        for(let i=0; i < length; i++) {
+            let node = queue.shift();
+            sum += node.val;
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
         }
         //每一层的平均值存入数组res
         res.push(sum/length);
     }
+    
     return res;
 };
 ```
@@ -1405,24 +1416,25 @@ go:
  */
 
 func levelOrder(root *Node) [][]int {
-    queue:=list.New()
-    res:=[][]int{}//结果集
-    if root==nil{
+    queue := list.New()
+    res := [][]int{}       //结果集
+    if root == nil{
         return res
     }
     queue.PushBack(root)
-    for queue.Len()>0{
-        length:=queue.Len()//记录当前层的数量
+    for queue.Len() > 0 {
+        length := queue.Len()     //记录当前层的数量
         var tmp []int
-        for T:=0;T<length;T++{//该层的每个元素：一添加到该层的结果集中；二找到该元素的下层元素加入到队列中，方便下次使用
-            myNode:=queue.Remove(queue.Front()).(*Node)
-            tmp=append(tmp,myNode.Val)
-            for i:=0;i<len(myNode.Children);i++{
+        for T := 0; T < length; T++ {        //该层的每个元素：一添加到该层的结果集中；二找到该元素的下层元素加入到队列中，方便下次使用
+            myNode := queue.Remove(queue.Front()).(*Node)
+            tmp = append(tmp, myNode.Val)
+            for i := 0; i < len(myNode.Children); i++ {
                 queue.PushBack(myNode.Children[i])
             }
         }
-        res=append(res,tmp)
+        res = append(res, tmp)
     }
+    
     return res
 }
 ```
@@ -1432,23 +1444,26 @@ JavaScript代码：
 ```JavaScript
 var levelOrder = function(root) {
     //每一层可能有2个以上,所以不再使用node.left node.right
-    let res=[],queue=[];
+    let res = [], queue = [];
     queue.push(root);
-    while(queue.length&&root!==null){
+    
+    while(queue.length && root!==null) {
         //记录每一层节点个数还是和二叉树一致
-        let length=queue.length;
+        let length = queue.length;
         //存放每层节点 也和二叉树一致
-        let curLevel=[];
-        while(length--){
+        let curLevel = [];
+        while(length--) {
             let node = queue.shift();
             curLevel.push(node.val);
+	    
             //这里不再是 ndoe.left node.right 而是循坏node.children
            for(let item of node.children){
-               item&&queue.push(item);
+               item && queue.push(item);
            }
         }
         res.push(curLevel);
     }
+    
     return res;
 };
 ```
@@ -1708,21 +1723,23 @@ javascript代码：
 ```javascript
 var largestValues = function(root) {
     //使用层序遍历
-    let res=[],queue=[];
+    let res = [], queue = [];
     queue.push(root);
-    while(root!==null&&queue.length){
+    
+    while(root !== null && queue.length) { 
         //设置max初始值就是队列的第一个元素
-        let max=queue[0].val;
-        let length=queue.length;
-        while(length--){
+        let max = queue[0].val;
+        let length = queue.length;
+        while(length--) {
             let node = queue.shift();
-            max=max>node.val?max:node.val;
-            node.left&&queue.push(node.left);
-            node.right&&queue.push(node.right);
+            max = max > node.val ? max : node.val;
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
         }
         //把每一层的最大值放到res数组
         res.push(max);
     }
+    
     return res;
 };
 ```
@@ -1964,66 +1981,6 @@ class Solution:
             first = first.left  # 从本层扩展到下一层
         return root
 ```
-JavaScript:
-```javascript
-
-/**
- * // Definition for a Node.
- * function Node(val, left, right, next) {
- *    this.val = val === undefined ? null : val;
- *    this.left = left === undefined ? null : left;
- *    this.right = right === undefined ? null : right;
- *    this.next = next === undefined ? null : next;
- * };
- */
-
-/**
- * @param {Node} root
- * @return {Node}
- */
-var connect = function(root) {
-    if (root === null) return root;
-    let queue = [root];
-    while (queue.length) {
-        let n = queue.length;
-        for (let i=0; i<n; i++) {
-            let node = queue.shift();
-            if (i < n-1) {
-                node.next = queue[0];
-            }
-            node.left && queue.push(node.left);
-            node.right && queue.push(node.right);
-        }
-    }
-    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
@@ -2064,6 +2021,66 @@ func connect(root *Node) *Node {
 
 ```
 
+JavaScript:
+```javascript
+
+/**
+ * // Definition for a Node.
+ * function Node(val, left, right, next) {
+ *    this.val = val === undefined ? null : val;
+ *    this.left = left === undefined ? null : left;
+ *    this.right = right === undefined ? null : right;
+ *    this.next = next === undefined ? null : next;
+ * };
+ */
+
+/**
+ * @param {Node} root
+ * @return {Node}
+ */
+var connect = function(root) {
+    if (root === null) return root;
+    let queue = [root];
+    while (queue.length) {
+        let n = queue.length;
+        for (let i = 0; i < n; i++) {
+            let node = queue.shift();
+            if (i < n-1) {
+                node.next = queue[0];
+            }
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
+        }
+    }
+    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;
+};
+```
+
 Swift：
 
 ```swift
@@ -2226,6 +2243,45 @@ class Solution:
         return root
 
 ```
+go:
+
+```GO
+/**
+116. 填充每个节点的下一个右侧节点指针
+117. 填充每个节点的下一个右侧节点指针 II
+ */
+
+func connect(root *Node) *Node {
+    if root == nil { //防止为空
+        return root
+    }
+    queue := list.New()
+    queue.PushBack(root)
+    tmpArr := make([]*Node, 0)
+    for queue.Len() > 0 {
+        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*Node) //出队列
+            if node.Left != nil {
+                queue.PushBack(node.Left)
+            }
+            if node.Right != nil {
+                queue.PushBack(node.Right)
+            }
+            tmpArr = append(tmpArr, node) //将值加入本层切片中
+        }
+        if len(tmpArr) > 1 {
+            // 遍历每层元素,指定next
+            for i := 0; i < len(tmpArr)-1; i++ {
+                tmpArr[i].Next = tmpArr[i+1]
+            }
+        }
+        tmpArr = []*Node{} //清空层的数据
+    }
+    return root
+}
+```
+
 JavaScript:
 ```javascript
 /**
@@ -2284,44 +2340,6 @@ function connect(root: Node | null): Node | null {
 };
 ```
 
-go:
-
-```GO
-/**
-116. 填充每个节点的下一个右侧节点指针
-117. 填充每个节点的下一个右侧节点指针 II
- */
-
-func connect(root *Node) *Node {
-    if root == nil { //防止为空
-        return root
-    }
-    queue := list.New()
-    queue.PushBack(root)
-    tmpArr := make([]*Node, 0)
-    for queue.Len() > 0 {
-        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-        for i := 0; i < length; i++ {
-            node := queue.Remove(queue.Front()).(*Node) //出队列
-            if node.Left != nil {
-                queue.PushBack(node.Left)
-            }
-            if node.Right != nil {
-                queue.PushBack(node.Right)
-            }
-            tmpArr = append(tmpArr, node) //将值加入本层切片中
-        }
-        if len(tmpArr) > 1 {
-            // 遍历每层元素,指定next
-            for i := 0; i < len(tmpArr)-1; i++ {
-                tmpArr[i].Next = tmpArr[i+1]
-            }
-        }
-        tmpArr = []*Node{} //清空层的数据
-    }
-    return root
-}
-```
 Swift：
 
 ```swift
@@ -2461,7 +2479,6 @@ class Solution {
 }
 ```
 
-
 Python：
 ```python 3
 class Solution:
@@ -2498,20 +2515,20 @@ Go：
  * }
  */
 func maxDepth(root *TreeNode) int {
-    ans:=0
-    if root==nil{
+    ans := 0
+    if root == nil {
         return 0
     }
-    queue:=list.New()
+    queue := list.New()
     queue.PushBack(root)
-    for queue.Len()>0{
-        length:=queue.Len()
-        for i:=0;i<length;i++{
-            node:=queue.Remove(queue.Front()).(*TreeNode)
-            if node.Left!=nil{
+    for queue.Len() > 0 {
+        length := queue.Len()
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*TreeNode)
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
         }
@@ -2521,8 +2538,6 @@ func maxDepth(root *TreeNode) int {
 }
 ```
 
-
-
 JavaScript：
 ```javascript
 /**
@@ -2763,30 +2778,29 @@ Go：
  * }
  */
 func minDepth(root *TreeNode) int {
-    ans:=0
-    if root==nil{
+    ans := 0
+    if root == nil {
         return 0
     }
-    queue:=list.New()
+    queue := list.New()
     queue.PushBack(root)
-    for queue.Len()>0{
-        length:=queue.Len()
-        for i:=0;i<length;i++{
-            node:=queue.Remove(queue.Front()).(*TreeNode)
-            if node.Left==nil&&node.Right==nil{//当前节点没有左右节点，则代表此层是最小层
-                return ans+1//返回当前层 ans代表是上一层
+    for queue.Len() > 0 {
+        length := queue.Len()
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*TreeNode)
+            if node.Left == nil && node.Right == nil {      //当前节点没有左右节点，则代表此层是最小层
+                return ans+1                                //返回当前层 ans代表是上一层
             }
-            if node.Left!=nil{
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
         }
         ans++//记录层数
-        
-
     }
+    
     return ans+1
 }
 ```
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index 3136c0be..ad2a7de2 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -104,7 +104,7 @@ public:
 
 ### 深度优先遍历
 
-[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本地可以很轻松的切出如下迭代法的代码：
+[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本题可以很轻松的写出如下迭代法的代码：
 
 C++代码迭代法（前序遍历）
 
@@ -126,7 +126,7 @@ public:
     }
 };
 ```
-如果这个代码看不懂的话可以在回顾一下[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)。
+如果这个代码看不懂的话可以再回顾一下[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)。
 
 
 我们在[二叉树：前中后序迭代方式的统一写法](https://programmercarl.com/二叉树的统一迭代法.html)中介绍了统一的写法，所以，本题也只需将文中的代码少做修改便可。
@@ -258,7 +258,6 @@ public:
 
 
 ### Java
-
 ```Java
 //DFS递归
 class Solution {
@@ -294,8 +293,8 @@ class Solution {
             while (size-- > 0) {
                 TreeNode node = deque.poll();
                 swap(node);
-                if (node.left != null) {deque.offer(node.left);}
-                if (node.right != null) {deque.offer(node.right);}
+                if (node.left != null) deque.offer(node.left);
+                if (node.right != null) deque.offer(node.right);
             }
         }
         return root;
@@ -364,13 +363,12 @@ class Solution:
 ### Go
 
 递归版本的前序遍历
-
 ```Go
 func invertTree(root *TreeNode) *TreeNode {
-    if root ==nil{
+    if root == nil {
         return nil
     }
-    root.Left,root.Right=root.Right,root.Left//交换
+    root.Left, root.Right = root.Right, root.Left    //交换
     
     invertTree(root.Left)
     invertTree(root.Right)
@@ -383,12 +381,14 @@ func invertTree(root *TreeNode) *TreeNode {
 
 ```go
 func invertTree(root *TreeNode) *TreeNode {
-    if root==nil{
+    if root == nil {
         return root
     }
-    invertTree(root.Left)//遍历左节点
-    invertTree(root.Right)//遍历右节点
-    root.Left,root.Right=root.Right,root.Left//交换
+    
+    invertTree(root.Left)     //遍历左节点
+    invertTree(root.Right)    //遍历右节点
+    root.Left, root.Right = root.Right, root.Left    //交换
+    
     return root
 }
 ```
@@ -397,18 +397,19 @@ func invertTree(root *TreeNode) *TreeNode {
 
 ```go
 func invertTree(root *TreeNode) *TreeNode {
-    stack:=[]*TreeNode{}
-    node:=root
-    for node!=nil||len(stack)>0{
-        for node!=nil{
-            node.Left,node.Right=node.Right,node.Left//交换
-            stack=append(stack,node)
-            node=node.Left
+    stack := []*TreeNode{}
+    node := root
+    for node != nil || len(stack) > 0 {
+        for node != nil {
+            node.Left, node.Right = node.Right, node.Left    //交换
+            stack = append(stack,node)
+            node = node.Left
         }
-        node=stack[len(stack)-1]
-        stack=stack[:len(stack)-1]
-        node=node.Right
+        node = stack[len(stack)-1]
+        stack = stack[:len(stack)-1]
+        node = node.Right
     }
+    
     return root
 }
 ```
@@ -417,25 +418,26 @@ func invertTree(root *TreeNode) *TreeNode {
 
 ```go
 func invertTree(root *TreeNode) *TreeNode {
-    stack:=[]*TreeNode{}
-    node:=root
+    stack := []*TreeNode{}
+    node := root
     var prev *TreeNode
-    for node!=nil||len(stack)>0{
-        for node!=nil{
-            stack=append(stack,node)
-            node=node.Left
+    for node != nil || len(stack) > 0 {
+        for node != nil {
+            stack = append(stack, node)
+            node = node.Left
         }
-        node=stack[len(stack)-1]
-        stack=stack[:len(stack)-1]
-        if node.Right==nil||node.Right==prev{
-            node.Left,node.Right=node.Right,node.Left//交换
-            prev=node
-            node=nil
-        }else {
-            stack=append(stack,node)
-            node=node.Right
+        node = stack[len(stack)-1]
+        stack = stack[:len(stack)-1]
+        if node.Right == nil || node.Right == prev {
+            node.Left, node.Right = node.Right, node.Left     //交换
+            prev = node
+            node = nil
+        } else {
+            stack = append(stack, node)
+            node = node.Right
         }
     }
+    
     return root
 }
 ```
@@ -444,21 +446,21 @@ func invertTree(root *TreeNode) *TreeNode {
 
 ```go
 func invertTree(root *TreeNode) *TreeNode {
-    if root==nil{
+    if root == nil{
         return root
     }
-    queue:=list.New()
-    node:=root
+    queue := list.New()
+    node := root
     queue.PushBack(node)
-    for queue.Len()>0{
-        length:=queue.Len()
-        for i:=0;i<length;i++{
-            e:=queue.Remove(queue.Front()).(*TreeNode)
-            e.Left,e.Right=e.Right,e.Left//交换
-            if e.Left!=nil{
+    for queue.Len() > 0 {
+        length := queue.Len()
+        for i := 0; i < length; i++ {
+            e := queue.Remove(queue.Front()).(*TreeNode)
+            e.Left, e.Right = e.Right, e.Left    //交换
+            if e.Left != nil {
                 queue.PushBack(e.Left)
             }
-            if e.Right!=nil{
+            if e.Right != nil {
                 queue.PushBack(e.Right)
             }
         }
@@ -487,31 +489,31 @@ var invertTree = function(root) {
 ```javascript
 var invertTree = function(root) {
     //我们先定义节点交换函数
-    const invertNode=function(root,left,right){
-        let temp=left;
-        left=right;
-        right=temp;
-        root.left=left;
-        root.right=right;
+    const invertNode = function(root, left, right) {
+        let temp = left;
+        left = right;
+        right = temp;
+        root.left = left;
+        root.right = right;
     }
     //使用迭代方法的前序遍历 
-    let stack=[];
-    if(root===null){
+    let stack = [];
+    if(root === null) {
         return root;
     }
     stack.push(root);
-    while(stack.length){
-        let node=stack.pop();
-        if(node!==null){
+    while(stack.length) {
+        let node = stack.pop();
+        if(node !== null) {
             //前序遍历顺序中左右  入栈顺序是前序遍历的倒序右左中
-            node.right&&stack.push(node.right);
-            node.left&&stack.push(node.left);
+            node.right && stack.push(node.right);
+            node.left && stack.push(node.left);
             stack.push(node);
             stack.push(null);
-        }else{
-            node=stack.pop();
+        } else {
+            node = stack.pop();
             //节点处理逻辑
-            invertNode(node,node.left,node.right);
+            invertNode(node, node.left, node.right);
         }
     }
     return root;
@@ -521,27 +523,27 @@ var invertTree = function(root) {
 ```javascript
 var invertTree = function(root) {
     //我们先定义节点交换函数
-    const invertNode=function(root,left,right){
-        let temp=left;
-        left=right;
-        right=temp;
-        root.left=left;
-        root.right=right;
+    const invertNode = function(root, left, right) {
+        let temp = left;
+        left = right;
+        right = temp;
+        root.left = left;
+        root.right = right;
     }
     //使用层序遍历
-    let queue=[];
-    if(root===null){
+    let queue = [];
+    if(root === null) {
         return root;
     } 
     queue.push(root);
-    while(queue.length){
-        let length=queue.length;
-        while(length--){
-            let node=queue.shift();
+    while(queue.length) {
+        let length = queue.length;
+        while(length--) {
+            let node = queue.shift();
             //节点处理逻辑
-            invertNode(node,node.left,node.right);
-            node.left&&queue.push(node.left);
-            node.right&&queue.push(node.right);
+            invertNode(node, node.left, node.right);
+            node.left && queue.push(node.left);
+            node.right && queue.push(node.right);
         }
     }
     return root;
@@ -760,7 +762,6 @@ func invertTree1(_ root: TreeNode?) -> TreeNode? {
 }
 ```
 
-### Swift
 
 深度优先递归。
 
@@ -808,9 +809,6 @@ func invertTree(_ root: TreeNode?) -> TreeNode? {
     return root
 }
 ```
-
-### Scala
-
 深度优先遍历（前序遍历）:
 ```scala
 object Solution {
diff --git a/problems/二叉树理论基础.md b/problems/二叉树理论基础.md
index 03422960..21e2039f 100644
--- a/problems/二叉树理论基础.md
+++ b/problems/二叉树理论基础.md
@@ -14,7 +14,7 @@
 
 <img src='https://img-blog.csdnimg.cn/20210219190809451.png' width=600 alt='二叉树大纲'> </img></div>
 
-说道二叉树，大家对于二叉树其实都很熟悉了，本文呢我也不想教科书式的把二叉树的基础内容在啰嗦一遍，所以一下我讲的都是一些比较重点的内容。
+说到二叉树，大家对于二叉树其实都很熟悉了，本文呢我也不想教科书式的把二叉树的基础内容再啰嗦一遍，所以以下我讲的都是一些比较重点的内容。
 
 相信只要耐心看完，都会有所收获。
 
@@ -83,7 +83,7 @@
 
 那么链式存储方式就用指针， 顺序存储的方式就是用数组。
 
-顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在散落在各个地址的节点串联一起。
+顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在各个地址的节点串联一起。
 
 链式存储如图：
 
@@ -143,7 +143,7 @@
 
 最后再说一说二叉树中深度优先和广度优先遍历实现方式，我们做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。
 
-**之前我们讲栈与队列的时候，就说过栈其实就是递归的一种是实现结构**，也就说前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。
+**之前我们讲栈与队列的时候，就说过栈其实就是递归的一种实现结构**，也就说前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。
 
 而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。
 
diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 78861040..5a9a670a 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -36,13 +36,13 @@
 
 **以下以前序遍历为例：**
 
-1. **确定递归函数的参数和返回值**：因为要打印出前序遍历节点的数值，所以参数里需要传入vector在放节点的数值，除了这一点就不需要在处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：
+1. **确定递归函数的参数和返回值**：因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：
 
 ```cpp
 void traversal(TreeNode* cur, vector<int>& vec)
 ```
 
-2. **确定终止条件**：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：
+2. **确定终止条件**：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：
 
 ```cpp
 if (cur == NULL) return;