路径求和

path-sum 1

给定一个二叉树和一个值sum，判断是否有从根节点到叶子节点的节点值之和等于sum的路径，

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

 

              5

             / \

            4   8

           /   / \

          11  13  4

         /  \      \

        7    2      1

 

 

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

递归：o(N)

解题思路：

1.判空返回false

2.sum不断减去节点的值

3.如果左右子树同时为空（叶子结点），sum==0,返回true,sum!=0,返回false

4.分别递归左右子树，如果有其中一方满足条件3，说明找到了返回true,否则返回false

import java.util.*;
/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */
public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        if(root==null){
            return false;
        }
        sum-=root.val;
        if(root.left==null &&root.right==null){
            return sum==0;//如果sum=0,返回true，如果sum!=0,返回false
        }
        //分别递归左右子树，有其中一方满足即可
        return hasPathSum(root.left,sum)|| hasPathSum(root.right,sum) ;
    }
}

迭代

解题思路：

1.定义一个结点栈，一个sum栈

2.判空

3.当结点栈不空时，如果叶子节点并且sum==0,说明找到了

4.如果右子树不空，右孩子入栈sum-右孩子节点值

5.如果左子树不空，左孩子入栈sum-左孩子节点值

 

path-sum 2

给定一个二叉树和一个值sum，请找出所有的根节点到叶子节点的节点值之和等于sum的路径，

 

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

 

              5

             / \

            4   8

           /   / \

          11  13  4

         /  \    / \

        7    2  5   1

 

 

返回:

 

[

   [5,4,11,2],

   [5,8,4,5]

]

 

解题思路：

1.判空

2.list记录路径，inner记录入队顺序

3.如果是叶子结点并且sum为0满足条件，将inner复制到list中（list是引用）

4.递归左子树，递归右子树

5.回到上个节点中删除（回溯）

import java.util.*;
/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */
public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return int整型ArrayList<ArrayList<>>
     */
//定义放在外边
    ArrayList<ArrayList<Integer>> list=new ArrayList<>();//返回结果
    ArrayList<Integer>             inner  =new ArrayList<>();
    public ArrayList<ArrayList<Integer>> pathSum (TreeNode root, int sum) {
        
        if(root==null){
            return list;
        }
          inner.add(root.val);
          sum-=root.val;
          if(root.left==null&&root.right==null){
              if(sum==0){
                  // List是引用类型 添加进数组修改还是会改变 需要拷贝一份
                   list.add(new ArrayList<>(inner));//复制一份
              }
          }
          if(root.left!=null){
              pathSum(root.left,sum);
          }
          if(root.right!=null){
            pathSum(root.right,sum);
         }
          // 用数组保存遍历后值 当回到上个节点之前记得删除
          // 当执行到叶子结点时候递归结束往回退，每退一步，移除之前加入的节点（回溯）。
          // 值等不等于sum都需要在执行完了后往回退。
          inner.remove(inner.size()-1);//从列表中删除
          return list;
    }
}