二叉树中路径相关问题

1.二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径。

• 当前节点不是叶子节点就在路径尾加它，并遍历它的左右孩子
• 当前节点是叶子节点就得到一个路径

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res=new ArrayList<>();
        if(root==null){return res;}
        solve(root,res,"");
        return res;
    }
    public void solve(TreeNode root,List<String> res,String path){
        if(root!=null){
            path+=Integer.toString(root.val);
            if(root.left==null && root.right==null){res.add(path);}  //叶子节点直接把路径加入结果集
        else{   //继续递归
            solve(root.left,res,path+"->");  //记录的格式
            solve(root.right,res,path+"->");
            }
        }
    }
}

2.路径总和(判断路径值总和是否等于目标值）

112.给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root==null){return false;}
        //从目标值中不断减去节点值
        sum-=root.val;
        //到叶子节点了，判断目标值是否为0
        if(root.left==null&&root.right==null&& sum==0){return true;}
        return hasPathSum(root.left,sum) || hasPathSum(root.right,sum);
    }
}

3.二叉树中和为输入整数的所有路径。（路径值总和等于目标值的所有路径）

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

• 递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<List<Integer>> res=new ArrayList<>();
    List<Integer> list=new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        path(root,sum);
        return res;
    }
    public void path(TreeNode root,int cursum){
        if(root==null){return;}
        //采用先序遍历
        list.add(root.val);
        cursum-=root.val;  //目标值要不断更新
        //list在时刻变化，用new ArrayList<>(list)相当于复制list
        if(cursum==0 && root.left==null && root.right==null){res.add(new ArrayList<>(list));}
        else{
        	path(root.left,cursum);
       		path(root.right,cursum);
       	}
        list.remove(list.size()-1);
    }
}

• 迭代

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<List<Integer>> res=new ArrayList<>();
    List<Integer> list=new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        if(root==null){return res;}
        list.add(root.val);
        sum-=root.val;
        if(sum==0 && root.left==null && root.right==null){res.add(new ArrayList<Integer>(list));}
        pathSum(root.left,sum);
        pathSum(root.right,sum);
        //不论路径值是否等于目标值，都回退，用remove移除路径上最后一节点
        list.remove(list.size()-1);
        return res;
    }
}

4.根到叶路径上的不足节点（删除路径值和小于给定limit的路径）

1080.给定一棵二叉树的根 root，考虑它所有从根到任何叶的路径。删除所有不足节点，并返回生成的二叉树的根。
假如通过节点 node 的每种可能的 “根-叶” 路径上值的总和全都小于给定的 limit，则该节点被称之为「不足节点」，需要被删除。

• 递归终止条件：路劲值总和大于等于limit，保留，否则删除
• 分治

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    //递归终止条件：路劲值总和大于等于limit，保留
    public TreeNode sufficientSubset(TreeNode root, int limit) {
        if(root==null){return null;}
        if(root.left==null && root.right==null){  //根节点
            if(limit>root.val){return null;}   //路径值总和小于给定值，删除
            else{return root;}
        }
        root.left=sufficientSubset(root.left,limit-root.val);
        root.right=sufficientSubset(root.right,limit-root.val);
        //左右子树都没有了，父节点也就被删除
        //左右节点有一个没有被删除，父节点就不会被删除
        if(root.left==null && root.right==null){return null;}
        return root;
    }
}

5.二叉树中的最大路径和

124.给定一个非空二叉树，返回其最大路径和。
本题中:

• 路径被定义为一条从树中任意节点出发，达到任意节点的序列。
• 该路径至少包含一个节点，且不一定经过根节点。
• 可选任意节点为起始节点，但只能选择一个
• 所有的路径均是从一个起始节点出发
• 路径上点不能重复使用

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
 //路径不一定经过根节点，路径最大值可能在局部子树中产生
class Solution {
    int max=Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        if(root==null){return 0;}
        dfs(root);
        return max;
    }
    //求当前子树的最大路径和
    public int dfs(TreeNode root){
        if(root==null){return 0;}
        //左子树（或右子树）路径和小于0，就让它等于0，（遇到负数反而使最大值变小，就让它为0）
        int left=Math.max(dfs(root.left),0);
        int right=Math.max(dfs(root.right),0);
        //根据左右子树提供的最大值，求出当前局部子树产生的最大路径和
        max=Math.max(max,root.val+left+right);//不断更新全局变量（比它大就去更新）
        //返回向父节点提供的最大路径和
        // return Math.max(0,root.val+Math.max(left,right));
        return root.val+Math.max(0,Math.max(left,right));
    }
}

6.路径值总和等于目标值的路径总数(任意节点为起始节点）

437.给定一个二叉树，它的每个结点都存放着一个整数值。找出路径和等于给定数值的路径总数。
路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。

• 递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    //路径不需从根节点开始，则：以当前节点为起始节点的路径数+以当前节点左孩子为起始节点的路径数+以当前节点右孩子为起始节点的路径数
    public int pathSum(TreeNode root, int sum) {
        if(root==null){return 0;}
        //这里以当前节点的左右孩子作为起始节点找路径，所以是pathSum(root.left,sum)
        return path(root,sum)+pathSum(root.left,sum)+pathSum(root.right,sum);
    }
    public int path(TreeNode root,int sum){
        if(root==null){return 0;}
        sum-=root.val;
        //sum为0则找到一条满足条件的路径
        return (sum==0?1:0)+path(root.left,sum)+path(root.right,sum);
    }
}

与上面类似的解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int res;  //记录路径总数
    public int pathSum(TreeNode root, int sum) {
        if(root==null){return 0;}
        path(root,sum);
        pathSum(root.left,sum);
        pathSum(root.right,sum);
        return res;
    }
    public void path(TreeNode root,int sum){
        if(root==null){return;}
        //sum为0则找到一条满足条件的路径
        if(sum-root.val==0){res++;}
        path(root.left,sum-root.val);
        path(root.right,sum-root.val);
    }
}

（参考大神的）另外一种解法

• Map.getOrDefault(Object key, V defaultValue)方法的作用是：
• 当Map集合中有这个key时，就使用这个key值；
• 如果没有就使用默认值defaultValue。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int pathSum(TreeNode root, int sum) {
        //key:到当前节点的路径上之前所有元素和       value:key出现的次数
        Map<Integer,Integer> map=new HashMap<>();
        //从根往任一节点的路径上，有且仅有一条路径
        //key为0的一条路径
        map.put(0,1);
        return path(root,sum,map,0);
    }
    public int path(TreeNode root,int sum,Map<Integer,Integer> map,int cursum){
        if(root==null){return 0;}  //递归终止条件
        cursum+=root.val;  //当前路径和
        int res=0;  //结果数
        //找路径起点
        res += map.getOrDefault(cursum-sum,0);
        //更新路径上当前节点key的个数
        //若之前路径和值为cursum的路径就取出其个数加上当前的一个
        map.put(cursum,map.getOrDefault(cursum,0)+1);
        //递归下一层
        res+=path(root.left,sum,map,cursum);
        res+=path(root.right,sum,map,cursum);
        //遍历完后，回到当前层，要把当前节点添加的key去除
        //遍历左节点时把左节点的路径记录了，再遍历右节点时，根节点到之前遍历的左节点的路径不满足上面要求，把对应的记录删掉
        //左节点回溯完就要往右一步，要把map中到左节点的cursum删掉，再往右计算
        map.put(cursum,map.get(cursum)-1);
        return res;
    }
}

7.二叉树中的伪回文路径(返回伪回文数）

1457.给你一棵二叉树，每个节点的值为 1 到 9 。我们称二叉树中的一条路径是 「伪回文」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
返回从根到叶子节点的所有路径中 伪回文 路径的数目。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/pseudo-palindromic-paths-in-a-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * 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 {
    int res=0;
    public int pseudoPalindromicPaths (TreeNode root) {
        if(root==null){return 0;}
        check(root,0);
        return res;
    }
    public void check(TreeNode root,int n){
        //异或：同为0，不同为1
        n^=(1<<root.val);
        if(root.left==null && root.right==null){  //到达叶子节点
        //异或后，回文串有两种情况：要么为0要么个数为奇数（最多有一个字符是奇数个--放在最中间，其它字符都是偶数个）
        //有偶数个元素，若是伪回文，则n==0
            if(n==0 || (n&(n-1))==0){res++;}
        }
        if(root.left!=null){check(root.left,n);}
        if(root.right!=null){check(root.right,n);}
        return;
    }
}

8.二叉树中的最长交错路径

1372.给一棵以 root 为根的二叉树，二叉树中的交错路径定义如下：
选择二叉树中 任意 节点和一个方向（左或者右）。
如果前进方向为右，那么移动到当前节点的的右子节点，否则移动到它的左子节点。
改变前进方向：左变右或者右变左。
重复第二步和第三步，直到你在树中无法继续移动。
交错路径的长度定义为：访问过的节点数目 - 1（单个节点的路径长度为 0 ）。
返回给定树中最长 交错路径 的长度。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-zigzag-path-in-a-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

往下走的条件：方向不同（左右左右……），方向相同就不往下走

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int res=0;  //记录结果--最长交错路径长度
    public int longestZigZag(TreeNode root) {
        dfs(root.left,0,1);  //左节点
        dfs(root.right,1,1); //右节点
        return res;
    }
    //令flag=1代表右孩子，flag=0代表左孩子
    public void dfs(TreeNode root,int flag,int len){
        if(root==null){return;}  //空节点
        res=Math.max(res,len);  //更新最大值
        if(flag==1){   //当前节点为其父节点的右孩子
            dfs(root.left,0,len+1);  //递归它左孩子时，满足条件，长度加1
            dfs(root.right,1,1);   //递归它右孩子时，不满足条件，长度置为1
        }else{   //当前节点为其父节点的左孩子
            dfs(root.left,0,1);    //递归它左孩子，不满足条件，长度置为1
            dfs(root.right,1,len+1);   //递归它右孩子，满足条件，长度加1
        }
    }
}

9.最长同值路径

687.给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。 这条路径可以经过也可以不经过根节点。
注意：两个节点之间的路径长度由它们之间的边数表示。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int longestUnivaluePath(TreeNode root) {
        int res=0;
        solve(root,res);
        return res;
    }
    //对于子树，经过其最长路径=左最长同值路径节点数+右最长同值路径节点数
    public int solve(TreeNode root,int res){
        if(root==null){return 0;}  //递归出口
        int left=solve(root.left,res);  //左边路径长度
        int right=solve(root.right,res);  //右边路径长度
        //若当前节点与其左右节点均不相等，则深度为0，否则就是左（或右）+1
        left=(root.left!=null && root.left.val==root.val)?left+1:0;
        right=(root.right!=null && root.right.val==root.val)?right+1:0;
        res=Math.max(res,left+right);  //更新长度
        return Math.max(left,right);  //返回一个最长路径到上层
    }
}