Merge branch 'youngyangyang04:master' into master

problems/0112.路径总和.md

@@ -486,6 +486,92 @@ class Solution:
 
 Go：
 
+> 112. 路径总和
+
+```go
+//递归法
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func hasPathSum(root *TreeNode, targetSum int) bool {
+    var flage bool //找没找到的标志
+    if root==nil{
+        return flage
+    }
+    pathSum(root,0,targetSum,&flage)
+    return flage
+}
+func pathSum(root *TreeNode, sum int,targetSum int,flage *bool){
+    sum+=root.Val
+    if root.Left==nil&&root.Right==nil&&sum==targetSum{
+        *flage=true
+        return
+    }
+    if root.Left!=nil&&!(*flage){//左节点不为空且还没找到
+        pathSum(root.Left,sum,targetSum,flage)
+    } 
+    if root.Right!=nil&&!(*flage){//右节点不为空且没找到
+        pathSum(root.Right,sum,targetSum,flage)
+    }
+}
+```
+
+
+
+> 113 递归法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func pathSum(root *TreeNode, targetSum int) [][]int {
+    var result [][]int//最终结果
+    if root==nil{
+        return result
+    }
+    var sumNodes []int//经过路径的节点集合
+    hasPathSum(root,&sumNodes,targetSum,&result)
+    return result
+}
+func hasPathSum(root *TreeNode,sumNodes *[]int,targetSum int,result *[][]int){
+    *sumNodes=append(*sumNodes,root.Val)
+    if root.Left==nil&&root.Right==nil{//叶子节点
+        fmt.Println(*sumNodes)
+        var sum int
+        var number int
+        for k,v:=range *sumNodes{//求该路径节点的和
+            sum+=v
+            number=k
+        }
+        tempNodes:=make([]int,number+1)//新的nodes接受指针里的值，防止最终指针里的值发生变动，导致最后的结果都是最后一个sumNodes的值
+        for k,v:=range *sumNodes{
+            tempNodes[k]=v
+        }
+        if sum==targetSum{
+            *result=append(*result,tempNodes)
+        }
+    }
+    if root.Left!=nil{
+        hasPathSum(root.Left,sumNodes,targetSum,result)
+        *sumNodes=(*sumNodes)[:len(*sumNodes)-1]//回溯
+    }
+    if root.Right!=nil{
+        hasPathSum(root.Right,sumNodes,targetSum,result)
+        *sumNodes=(*sumNodes)[:len(*sumNodes)-1]//回溯
+    }
+}
+```
+
 JavaScript：
 
 0112.路径总和

problems/0404.左叶子之和.md

@@ -226,6 +226,71 @@ class Solution:
 ```
 Go：
 
+> 递归法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func sumOfLeftLeaves(root *TreeNode) int {
+    var  res int
+    findLeft(root,&res)
+    return res
+}
+func findLeft(root *TreeNode,res *int){
+    //左节点
+    if root.Left!=nil&&root.Left.Left==nil&&root.Left.Right==nil{
+        *res=*res+root.Left.Val
+    }
+    if root.Left!=nil{
+        findLeft(root.Left,res)
+    }
+    if root.Right!=nil{
+        findLeft(root.Right,res)
+    }
+}
+```
+
+> 迭代法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func sumOfLeftLeaves(root *TreeNode) int {
+    var  res int
+    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.Left.Left==nil&&node.Left.Right==nil{
+                res=res+node.Left.Val
+            }
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+        }
+    }
+    return res
+}
+```
+
+
 JavaScript:
 递归版本
 ```javascript
@@ -275,6 +340,7 @@ var sumOfLeftLeaves = function(root) {
 
 
 
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

problems/0513.找树左下角的值.md

@@ -298,6 +298,80 @@ class Solution:
 ```
 Go：
 
+> 递归法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ var maxDeep int // 全局变量 深度
+ var  value  int //全局变量 最终值
+func findBottomLeftValue(root *TreeNode) int {
+     if root.Left==nil&&root.Right==nil{//需要提前判断一下（不要这个if的话提交结果会出错，但执行代码不会。防止这种情况出现，故先判断是否只有一个节点）
+         return root.Val
+     }
+    findLeftValue (root,maxDeep)
+    return value
+}
+func findLeftValue (root *TreeNode,deep int){
+     //最左边的值在左边
+     if root.Left==nil&&root.Right==nil{
+         if deep>maxDeep{
+             value=root.Val
+             maxDeep=deep
+         }
+     }
+    //递归
+    if root.Left!=nil{
+        deep++
+        findLeftValue(root.Left,deep)
+        deep--//回溯
+    }
+    if root.Right!=nil{
+        deep++
+        findLeftValue(root.Right,deep)
+        deep--//回溯
+    }
+}
+```
+
+> 迭代法
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func findBottomLeftValue(root *TreeNode) int {
+    queue:=list.New()
+    var gradation int
+    queue.PushBack(root)
+    for queue.Len()>0{
+        length:=queue.Len()
+        for i:=0;i<length;i++{
+            node:=queue.Remove(queue.Front()).(*TreeNode)
+            if i==0{gradation=node.Val}
+            if node.Left!=nil{
+                queue.PushBack(node.Left)
+            }
+            if node.Right!=nil{
+                queue.PushBack(node.Right)
+            }
+        }
+    }
+    return gradation
+}
+```
+
 JavaScript:
 1. 递归版本
 ```javascript