From 1efb77e96310d884eb2b8647232dd1586f4f0afb Mon Sep 17 00:00:00 2001
From: zucong <sebastiancong@163.com>
Date: Tue, 25 Jan 2022 14:33:12 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BC=98=E5=8C=96=200112.=E8=B7=AF=E5=BE=84?=
 =?UTF-8?q?=E6=80=BB=E5=92=8C=20Go=E7=89=88=E6=9C=AC=E8=A7=A3=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0112.路径总和.md | 101 ++++++++++++++--------------------
 1 file changed, 41 insertions(+), 60 deletions(-)

diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 910e57c8..b3e121ba 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -531,82 +531,63 @@ class solution:
 ```go
 //递归法
 /**
- * definition for a binary tree node.
- * type treenode struct {
- *     val int
- *     left *treenode
- *     right *treenode
+ * 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
+func hasPathSum(root *TreeNode, targetSum int) bool {
+    if root == nil {
+        return false
     }
-    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)
+    
+    targetSum -= root.Val // 将targetSum在遍历每层的时候都减去本层节点的值
+    if root.Left == nil && root.Right == nil && targetSum == 0 { // 如果剩余的targetSum为0, 则正好就是符合的结果
+        return true
     }
+    return hasPathSum(root.Left, targetSum) || hasPathSum(root.Right, targetSum) // 否则递归找
 }
 ```
 
-113 递归法
+113. 路径总和 II
 
 ```go
 /**
- * definition for a binary tree node.
- * type treenode struct {
- *     val int
- *     left *treenode
- *     right *treenode
+ * 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)
+func pathSum(root *TreeNode, targetSum int) [][]int {
+    result := make([][]int, 0)
+    traverse(root, &result, new([]int), targetSum)
     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)
-        }
+
+func traverse(node *TreeNode, result *[][]int, currPath *[]int, targetSum int) {
+    if node == nil { // 这个判空也可以挪到递归遍历左右子树时去判断
+        return
     }
-    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]//回溯
+
+    targetSum -= node.Val // 将targetSum在遍历每层的时候都减去本层节点的值
+    *currPath = append(*currPath, node.Val) // 把当前节点放到路径记录里
+    
+    if node.Left == nil && node.Right == nil && targetSum == 0 { // 如果剩余的targetSum为0, 则正好就是符合的结果
+        // 不能直接将currPath放到result里面, 因为currPath是共享的, 每次遍历子树时都会被修改
+        pathCopy := make([]int, len(*currPath)) 
+        for i, element := range *currPath {
+            pathCopy[i] = element
+        }
+        *result = append(*result, pathCopy) // 将副本放到结果集里
     }
+
+    traverse(node.Left, result, currPath, targetSum)
+    traverse(node.Right, result, currPath, targetSum)
+    *currPath = (*currPath)[:len(*currPath)-1] // 当前节点遍历完成, 从路径记录里删除掉
 }
 ```