二叉树的路径问题

1.二叉树的所有路径

二叉树的所有路径

递归+回溯

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        if(root==null) return null;
        List<String> ans = new ArrayList<>();//输出结果
        List<Integer> path = new ArrayList<>();//路劲存放
        //统计根节点到叶子节点的路径
        pathTravel(root,path,ans);
        return ans;
    }

    public void pathTravel(TreeNode root,List<Integer> path,List<String> ans){
        path.add(root.val);
        //叶子节点，输出(完成拼接)
        if(root.left==null&&root.right==null){
            StringBuilder sb = new StringBuilder();
            //由于箭头原因，最后元素特殊处理
            for(int i=0;i<path.size()-1;i++){
                
                sb.append(path.get(i)).append("->");
            }
            sb.append(path.get(path.size()-1));//拼接最后一个
            ans.add(sb.toString());//更新ans,且将SB类型转换为string
            return;//退出
        }

        if(root.left!=null) {
             pathTravel(root.left,path,ans);
            path.remove(path.size()-1);//回溯
        }

        if(root.right!=null) {
             pathTravel(root.right,path,ans);
            path.remove(path.size()-1);//回溯
        }

    }
}

2.路径总和

路径总和

单层逻辑使用递减，不断调用自身函数。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        //确定退出条件
        if(root==null) return false;
        //单层逻辑
        targetSum-=root.val;
        //找到叶子节点
        if(root.left==null&&root.right==null){
            return targetSum==0;
        }
        //没找到叶子结点，继续遍历
        if(root.left!=null){
            if(hasPathSum(root.left,targetSum)) return true;
            
        }
        
        if(root.right!=null){
            if(hasPathSum(root.right,targetSum)) return true;
            
        }
        return false;
        
    }    
}

3.路径总和 II

路径总和 II

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> ans = new ArrayList<>();//结果集
        List<Integer> path = new LinkedList<>();//路径
        if(root==null) return ans;
        //root不为空
        pathRes(root,targetSum,path,ans);
        return ans;

    }

    public void pathRes(TreeNode root,int targetSum,List<Integer> path,List<List<Integer>> ans){
        path.add(root.val);
        
        //找到叶子节点,输出
        if(root.left==null&&root.right==null){
            if(targetSum-root.val==0){
                ans.add(new ArrayList<>(path));//输出
            }
            return;//否则返回
        }

        if(root.left!=null){
            pathRes(root.left,targetSum-root.val,path,ans);//注意此时节点已经时root.val,targetSum-root.val
            path.remove(path.size()-1);//回溯
        }

        if(root.right!=null){
            pathRes(root.right,targetSum-root.val,path,ans);
            path.remove(path.size()-1);//回溯
        }
    }
}