剑指offer 34 二叉树中和为某一值的路径

题目

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

叶子节点 是指没有子节点的节点。

示例

思路分析

step1:通过DFS找出所有从根节点到叶子节点的路径
step2: 将每一条路径存放进入path[]中
step3:判断每一条路径是否符合题意

代码实现

package 剑指offer.搜索与回溯.offer34;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Solution {




    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
        TreeNode() {
        }


    }

    public TreeNode createTree(Integer[] arr) {
        // 使用队列来存储每一层的非空节点，下一层的数目要比上一层高
        ArrayDeque<TreeNode> pre = new ArrayDeque<>();
        TreeNode root = new TreeNode(arr[0]);
        pre.addLast(root);
        // 表示要遍历的下一个节点
        int index = 0;
        while (!pre.isEmpty()) {

            ArrayDeque<TreeNode> cur = new ArrayDeque<>();
            while (!pre.isEmpty()) {
               TreeNode node = pre.removeFirst();
                TreeNode left=null;
                TreeNode right=null;
                // 如果对应索引上的数组不为空的话就创建一个节点,进行判断的时候，
                // 要先索引看是否已经超过数组的长度，如果索引已经超过了数组的长度，那么剩下节点的左右子节点就都是空了
                // 这里index每次都会增加，实际上是不必要的，但是这样写比较简单
                if (++index<arr.length&&arr[index]!=null){
                    left=new TreeNode(arr[index]);
                    cur.addLast(left);
                }
                if (++index<arr.length&&arr[index]!=null){
                    right=new TreeNode(arr[index]);
                    cur.addLast(right);
                }
                node.left=left;
                node.right=right;
            }
            pre=cur;
        }


        return root;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();

//        Integer[] a = {5,4,8,11,null,13,4,7,2,null,null,5,1};
//        int target = 22;
        Integer[] a = {-2,null,-3};
        int target = -5;
      TreeNode A = solution.createTree(a);

        List<List<Integer>> lists = solution.pathSum(A, target);

        System.out.println(lists);


    }


    /**
     * 思路分析
     * BFS寻找所有路径的和是target的情况，然后取满足条件的情况
     *
     * 暴力搜索：
     * 思路找出从头向下的每一个路径，将每一个路径都存放起来，对于每个路径看倒着取值，看是否能累加出来这个target值
     * @param root
     * @param target
     * @return
     */
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {

        dfs(root,target);
        return res;

    }

    //path的值就是从最下层加上来的。
    List<Integer> path = new ArrayList<>();
    public void dfs(TreeNode node,int target){
        if(node == null){
            return;
        }


        TreeNode left = node.left;
        TreeNode right = node.right;

        path.add(node.val);
        dfs(left,target);
        dfs(right,target);

        //todo:对于每一条完整的路径进行判断
        if(left == null && right == null){
            boolean b = checkPath(path, target);
            if(b){
                res.add(new ArrayList<>(path));
            }
        }

        path.remove(path.size()-1);

    }

    /**题意理解错误
     * 校验这个路径是否存在满足条件的子路径，然后返回该部分，没有返回null
     * @param path
     * @return
     */
    public boolean checkPath(List<Integer> path,int target){

        int size = path.size();

        int num = 0;
        boolean check = false;
        for (int i = 0; i <size; i++) {

            num = num + path.get(i);
        }


        if(num == target){
            check = true;
        }
        if(check){
            return true;
        }else{
            return false;
        }

    }
}