leetcode笔记——113路径总和Ⅱ&剑指34题

题目：

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

示例:
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

返回:

[
   [5,4,11,2],
   [5,8,4,5]
]

思路：网上百度大神的代码，原文链接如下：https://blog.csdn.net/Jin_Kwok/article/details/51356502

以下代码的思想是使用深度优先搜索(DFS)按照中序遍历的顺序（左 根 右）遍历树中的所有根节点到叶子结点的路径，判断是否满足条件。

这个题也是剑指中的34二叉树中和为某一值的路径。

 

代码：

public class Solution {
    
    public List> pathSum(TreeNode root, int sum)
    {
       List> result=new ArrayList>();//List接口变量用的ArrayList类对象实例化
       List temp=new ArrayList();
       
       if(root==null)return result;
       DFS(result,temp,root,sum);
       return result;
    }
    
    void DFS(List> result,List temp,TreeNode root,int sum)
    {
       if(root==null)return;
       if(root.left==null&&root.right==null)
       {
           temp.add(root.val);
           if(sumOfPath(temp)==sum)
               result.add(new ArrayList(temp));//一定要注意
           temp.remove(temp.size()-1);
           return;
       }
       else
       {
           temp.add(root.val);
           DFS(result,temp,root.left,sum);
           DFS(result,temp,root.right,sum);
           temp.remove(temp.size()-1);
       }
   }
   
   int sumOfPath(List temp)
   {
       int sum=0;
       for(int i=0;i        {
           sum+=temp.get(i);
       }
       return sum;
   }
}

剑指中的代码：

public ArrayList> FindPath(TreeNode root,int target) {
if(root == null)
return resultList;   //这块之前应该先创建resultList
list.add(root.val);
target -= root.val;
if(target == 0 && root.left == null && root.right == null){
resultList.add(new ArrayList<>(list));
}else {
FindPath(root.left,target);
FindPath(root.right,target);
}
//每返回上一层一次就要回退一个节点
list.remove(list.size()-1);
return resultList;
}

执行最快的代码：

执行最快的代码使用递归的思想，每次判断的时候用和sum减去当前节点的值。当到达叶子结点并且当前节点的值等于sum时，将其保存在结果集中。不满足条件时，继续探索左子树或者右子树。知道满足条件。当到达叶子结点但是不满足条件时，弹出当前节点。这种做法是采用前序遍历的思想。

我自己写的时候忘了把节点加到l中了。。。。

我重新做这个题，又是不会做。。。。。。不适用深度优先搜索的思路而是用递推的思想。

class Solution {
    public List> pathSum(TreeNode root, int sum) {
        List>list = new ArrayList();
        if(root==null)
            return list;
        Listl = new ArrayList();
        path(root,list,l,sum);
        return list;
    }
    public void path(TreeNode node, List>list, Listl,int sum){
        l.add(node.val);
        if(node.left==null&&node.right==null&&node.val==sum){
            list.add(new ArrayList(l));
            l.remove(l.size()-1);
            return;
        }
        if(node.left!=null){
            path(node.left,list,l,sum-node.val);
        }
        if(node.right!=null){
            path(node.right,list,l,sum-node.val);
        }
        l.remove(l.size()-1);
    }
}