diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index 3136c0be..011c695d 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)中介绍了统一的写法，所以，本题也只需将文中的代码少做修改便可。
@@ -257,8 +257,7 @@ public:
 ## 其他语言版本
 
 
-### Java
-
+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;
@@ -309,7 +308,7 @@ class Solution {
 }
 ```
 
-### Python
+Python
 
 递归法：前序遍历：
 ```python
@@ -361,16 +360,15 @@ class Solution:
         return root
 ```
 
-### Go
+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)
             }
         }
@@ -467,7 +469,7 @@ func invertTree(root *TreeNode) *TreeNode {
 }
 ```
 
-### JavaScript
+JavaScript
 
 使用递归版本的前序遍历
 ```javascript
@@ -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,34 +523,34 @@ 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;
 };
 ```
 
-### TypeScript：
+TypeScript：
 
 递归法：
 
@@ -675,7 +677,7 @@ function invertTree(root: TreeNode | null): TreeNode | null {
 };
 ```
 
-### C
+C
 
 递归法
 ```c
@@ -722,7 +724,7 @@ struct TreeNode* invertTree(struct TreeNode* root){
 }
 ```
 
-### Swift：
+Swift：
 ```swift
 // 前序遍历-递归
 func invertTree(_ root: TreeNode?) -> TreeNode? {
@@ -760,7 +762,7 @@ func invertTree1(_ root: TreeNode?) -> TreeNode? {
 }
 ```
 
-### Swift
+Swift
 
 深度优先递归。
 
@@ -808,9 +810,6 @@ func invertTree(_ root: TreeNode?) -> TreeNode? {
     return root
 }
 ```
-
-### Scala
-
 深度优先遍历（前序遍历）:
 ```scala
 object Solution {
@@ -857,7 +856,7 @@ object Solution {
 }
 ```
 
-### rust
+rust
 
 ```rust
 impl Solution {