代码随想录算法训练营Day18

513.找树左下角的值

// 递归法
class Solution {
    private int Deep = -1;  // 记录当前最大深度
    private int value = 0;  // 记录最底层最左边节点的值

    public int findBottomLeftValue(TreeNode root) {
        value = root.val;  // 先初始化值为根节点的值
        findLeftValue(root, 0);  // 开始递归查找
        return value;
    }

    private void findLeftValue(TreeNode root, int deep) {
        if (root == null) { // 如果当前节点为空，直接返回
            return;
        }
        if (root.left == null && root.right == null) {  // 如果是叶子节点
            if (deep > Deep) {  // 如果当前深度大于记录的最大深度
                value = root.val;  // 更新最底层最左边节点的值
                Deep = deep;  // 更新最大深度
            }
        }
        if (root.left!= null) {  // 如果有左子节点，递归左子节点，深度加 1
            findLeftValue(root.left, deep + 1);
        }
        if (root.right!= null) {  // 如果有右子节点，递归右子节点，深度加 1
            findLeftValue(root.right, deep + 1);
        }
    }
}

112. 路径总和

class Solution {

    public boolean hasPathSum(TreeNode root, int targetSum) {

        if (root == null) { // 如果根节点为空，直接返回 false
            return false;
        }

        // 如果是叶子节点并且当前节点值等于目标和
        if (root.left == null && root.right == null) {
            return root.val == targetSum;
        }

        // 递归在左子树中判断是否存在满足目标和的路径（目标和减去当前节点值）
        boolean leftHasPath = hasPathSum(root.left, targetSum - root.val);
        // 递归在右子树中判断是否存在满足目标和的路径（目标和减去当前节点值）
        boolean rightHasPath = hasPathSum(root.right, targetSum - root.val);

        // 只要左右子树中有一个存在满足的路径，就返回 true
        return leftHasPath || rightHasPath;
    }
}

106. 从中序与后序遍历序列构造二叉树

class Solution {
    Map<Integer, Integer> map;  // 定义一个映射，用于方便根据数值查找位置

    public TreeNode buildTree(int[] inorder, int[] postorder) {
        map = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) {  // 遍历中序序列，将每个数值及其位置存入映射
            map.put(inorder[i], i);
        }

        // 调用方法构建二叉树，范围是前闭后开
        return findNode(inorder, 0, inorder.length, postorder, 0, postorder.length);  
        
    }

    public TreeNode findNode(int[] inorder, int inBegin, int inEnd, int[] postorder, int postBegin, int postEnd) {
        // 参数里的范围都是前闭后开
        if (inBegin >= inEnd || postBegin >= postEnd) {  // 如果范围不合法，说明没有元素了，返回空树
            return null;
        }
        int rootIndex = map.get(postorder[postEnd - 1]);  // 通过映射找到后序遍历最后一个元素在中序遍历中的位置
        TreeNode root = new TreeNode(inorder[rootIndex]);  // 创建对应的节点
        int lenOfLeft = rootIndex - inBegin;  // 计算中序遍历中左子树的元素个数，用于确定后序遍历中左子树的范围
        root.left = findNode(inorder, inBegin, rootIndex,  // 递归构建左子树
                            postorder, postBegin, postBegin + lenOfLeft);
        root.right = findNode(inorder, rootIndex + 1, inEnd,  // 递归构建右子树
                            postorder, postBegin + lenOfLeft, postEnd - 1);

        return root;
    }
}