算法-二叉树路径问题

二叉树的路径问题一般可以用DFS搜索来解决，递归的思想一定要理解(注重最后一步和终止条件)

1、判断二叉树中是不是有给定和的路径

	//
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root==null){
            return false;
        }
        sum-=root.val;
        if(sum==0&&root.left==null&&root.right==null){//终止条件
            return true;
        }
        //找一下左右子树
        return hasPathSum(root.left,sum)||hasPathSum(root.right,sum);
    }

2、找出二叉树中给定和的所有路径

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> list=new ArrayList<>();
        dfs(list,new ArrayList<>(),root,sum);
        return list;
    }

    public void dfs(List<List<Integer>> list,List<Integer> path,TreeNode root,int sum){
        if(root==null){
            return;
        }
        sum-=root.val;
        path.add(root.val);
        //终止条件
        if(sum==0&&root.left==null&&root.right==null){
            list.add(new ArrayList<>(path));
        }else{
        	//搜索左右子树
            dfs(list,path,root.left,sum);
            dfs(list,path,root.right,sum);
        }
        path.remove(path.size()-1);
        
    }

3、二叉树中的所有路径

    public List<String> binaryTreePaths(TreeNode root) {
        List<String> list=new ArrayList<>();
        dfs(list,"",root);
        return list;
    }

    public void dfs(List<String> list,String path,TreeNode node){
        if(node==null){
            return;
        }
        String temp="";
        if(path.length()==0){
            temp=""+node.val;
        }else{
            temp=path+"->"+node.val;
        }
        if(node.left==null&&node.right==null){
            list.add(temp);
        }else{
            dfs(list,temp,node.left);
            dfs(list,temp,node.right);
        }
    }

4、二叉树中最大路径和

124. 二叉树中的最大路径和 Hard难度。

给定一个非空二叉树，返回其最大路径和。

本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。

示例 1:

输入: [1,2,3]

       1
      / \
     2   3

输出: 6
示例 2:

输入: [-10,9,20,null,null,15,7]

   -10
   / \
  9  20
    /  \
   15   7

输出: 42

本例中需要注意的就是有可能不经过根节点，但我们知道，这条路径必然会经过一个节点

所以我们在经过每个节点的时候计算最大路径值，更新现有的最大路径值

max=Math.max(max,leftSum+rightSum+node.val);//经过当前节点的最大路径和

然后返回经过本节点的一个较大分支

return node.val+Math.max(leftSum,rightSum);//经过该节点的一支较大的路径

左子树最大路径和为

int leftSum=Math.max(0,helper(node.left));

    public int maxPathSum(TreeNode root) {
        helper(root);
        return max;
    }
    private int max=Integer.MIN_VALUE;
    private int helper(TreeNode node){
        if(node==null){
            return 0;
        }
        int leftSum=Math.max(0,helper(node.left));
        int rightSum=Math.max(0,helper(node.right));
        max=Math.max(max,leftSum+rightSum+node.val);//经过当前节点的最大路径和
        return node.val+Math.max(leftSum,rightSum);//经过该节点的一支较大的路径
    }

5、二叉树的最大直径

543. 二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

示例 :
给定二叉树

          1
         / \
        2   3
       / \     
      4   5    
返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。
注意：两结点之间的路径长度是以它们之间边的数目表示。

这个题其实也很容易理解，就是某个节点的左子树深度+右子树深度，就是他的直径。
明白了这一点，我们再想一想我们是如何求二叉树深度的？

public int getDepth(TreeNode node){
	if(node==null){
		return 0;
	}
	return 1+Math.max(getDepth(node.left),getDepth(node.right));
}

现在我们对其改造一下,改造的点就是我们对每个点的左右子树进行判断，而不仅仅是根节点的左右子树。左右子树的高度和就是直径

    int max=0;
    public int getDepth(TreeNode root) {
        depth(root);
        return max;
    }
    public int depth(TreeNode node){
        if(node==null){
            return 0;
        }
        int leftDepth=depth(node.left);
        int rightDepth=depth(node.right);
        int temp=leftDepth+rightDepth;
        max=Math.max(max,temp);
        return Math.max(leftDepth,rightDepth)+1;
    }
}

6、二叉树的最小深度

和最大深度很相似，不过要分左子树和右子树中有一个为null的情况。

    public int minDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        if((root.left==null&&root.right!=null)||(root.left!=null&&root.right==null)){
            return root.left==null?1+minDepth(root.right):1+minDepth(root.left);
        }
        return 1+Math.min(minDepth(root.left),minDepth(root.right));
    }