【二叉树专题】—— 二叉树的最小深度、路径总和

LeetCode 111：二叉树的最小深度

⭕️ 解题思路：

分情况讨论，还是利用通过递归函数返回的过程来完成最小深度的计算

❌ 代码部分:

/**
 * 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 int minDepth(TreeNode root) {
        //当二叉树为空时，树的最小深度为零
        if(root == null){
            return 0;
        }

        //如果二叉树只有根结点，那么最小深度为一
        if(root.right == null && root.left == null){
            return 1;
        }

        int leftMinDepth = minDepth(root.left);
        int rightMinDepth = minDepth(root.right);

        //只有左子树或只有右子树
        if(root.right == null){
            return leftMinDepth + 1;
        }
        if(root.left == null){
            return rightMinDepth + 1;
        }

        //左右子树都不为空时
        return Math.min(leftMinDepth, rightMinDepth) + 1;
    }
}

---

LeetCode 112: 路径总和

⭕️ 解题思路：

（1）如果结点为空，直接返回false
（2）如果当前结点为叶子结点，并且元素值为当前目标数值，那么返回true
（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) {
        /**
            遍历整个二叉树，如果当前分支和满足条件那么就退出循环返回true，
            否则返回false
         */

        //空树
        if(root == null){
            return false;
        }

        //当前叶子结点满足条件
        if(root.left == null && root.right == null && root.val == targetSum){
            return true;
        }

        //将目标值减去走过的路径和再与当前结点叶子结点比较是否相同
        boolean leftSum = hasPathSum(root.left, targetSum - root.val);
        boolean rightSum = hasPathSum(root.right, targetSum - root.val);

        return leftSum || rightSum;


    }
}