diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ac43f0a5..a2fd6f03 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1570,9 +1570,43 @@ class Solution:
         return len(result)
 ```
 
-
 Go：
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func maxDepth(root *TreeNode) int {
+    ans:=0
+    if root==nil{
+        return 0
+    }
+    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{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+        }
+        ans++//记录深度，其他的是层序遍历的板子
+    }
+    return ans
+}
+```
+
+
+
 JavaScript：
 
 # 111.二叉树的最小深度
@@ -1674,6 +1708,46 @@ class Solution:
 
 Go：
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func minDepth(root *TreeNode) int {
+    ans:=0
+    if root==nil{
+        return 0
+    }
+    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代表是上一层
+            }
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+        }
+        ans++//记录层数
+        
+
+    }
+    return ans+1
+}
+```
+
+
+
 JavaScript：
 
 
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index b69cad55..fb5d831a 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -363,7 +363,9 @@ class Solution:
         return root
 ```
 
-### Go 
+### Go
+
+递归版本的前序遍历
 
 ```Go
 func invertTree(root *TreeNode) *TreeNode {
@@ -381,6 +383,96 @@ func invertTree(root *TreeNode) *TreeNode {
 }
 ```
 
+递归版本的后序遍历
+
+```go
+func invertTree(root *TreeNode) *TreeNode {
+    if root==nil{
+        return root
+    }
+    invertTree(root.Left)//遍历左节点
+    invertTree(root.Right)//遍历右节点
+    root.Left,root.Right=root.Right,root.Left//交换
+    return root
+}
+```
+
+迭代版本的前序遍历
+
+```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
+        }
+        node=stack[len(stack)-1]
+        stack=stack[:len(stack)-1]
+        node=node.Right
+    }
+    return root
+}
+```
+
+迭代版本的后序遍历
+
+```go
+func invertTree(root *TreeNode) *TreeNode {
+    stack:=[]*TreeNode{}
+    node:=root
+    var prev *TreeNode
+    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
+        }
+    }
+    return root
+}
+```
+
+层序遍历
+
+```go
+func invertTree(root *TreeNode) *TreeNode {
+    if root==nil{
+        return 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{
+                queue.PushBack(e.Left)
+            }
+            if e.Right!=nil{
+                queue.PushBack(e.Right)
+            }
+        }
+    }
+    return root
+}
+```
+
+
+
 ### JavaScript
 
 使用递归版本的前序遍历
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index 599a3180..415ff88b 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -227,6 +227,45 @@ class Solution:
 ```
 Go：
 
+```
+func canPartition(nums []int) bool {
+    /**
+    动态五部曲：
+        1.确定dp数组和下标含义
+        2.确定递推公式
+        3.dp数组初始化
+        4.dp遍历顺序
+        5.打印
+    **/
+    //确定和
+    var sum int
+    for _,v:=range nums{
+        sum+=v
+    }
+    if sum%2!=0{   //如果和为奇数，则不可能分成两个相等的数组
+        return false
+    }
+    sum/=2
+    //确定dp数组和下标含义
+    var dp [][]bool //dp[i][j] 表示： 前i个石头是否总和不大于J
+    //初始化数组
+    dp=make([][]bool,len(nums)+1)
+    for i,_:=range dp{
+        dp[i]=make([]bool,sum+1)
+        dp[i][0]=true
+    }
+    for i:=1;i<=len(nums);i++{
+        for j:=1;j<=sum;j++{//j是固定总量
+            if j>=nums[i-1]{//如果容量够用则可放入背包
+                dp[i][j]=dp[i-1][j]||dp[i-1][j-nums[i-1]]
+            }else{//如果容量不够用则不拿，维持前一个状态
+                dp[i][j]=dp[i-1][j]
+            }
+        }
+    }
+    return dp[len(nums)][sum]
+}
+```
 
 javaScript: