代码随想录第18天|513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树

513.找树左下角的值

• 力扣链接：https://leetcode.cn/problems/find-bottom-left-tree-value/description/

• 代码随想录视频讲解链接：https://www.bilibili.com/video/BV1424y1Z7pn

/**
513. 找树左下角的值
给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。
假设二叉树中至少有一个节点。
 */
class Solution {
    private int deep = -1;
    private int val = 0;
    public int findBottomLeftValue(TreeNode root) {
        //首先必是最底部，并且是叶子节点，遇到的第一个叶子节点
        findLeftValue(root, 0);
        return val;     
    }

    private void findLeftValue(TreeNode root, int depth){
        if(root == null){
            return;
        }
        if(root.left == null && root.right == null){
            if(depth > deep){
                val = root.val;
                deep = depth;
            }
        }
        if(root.left != null){
            findLeftValue(root.left, depth + 1);
        }
        if(root.right != null){
            findLeftValue(root.right, depth + 1);
        }
    }
}

112. 路径总和

• 力扣链接：https://leetcode.cn/problems/path-sum/description/

• 代码随想录视频讲解链接：https://www.bilibili.com/video/BV19t4y1L7CR

/**
112. 路径总和
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。
 */
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){
            boolean left = hasPathSum(root.left, targetSum);
            if(left){
                return true;
            }
        }
        if(root.right != null){
            boolean right = hasPathSum(root.right, targetSum);
            if(right){
                return true;
            }
        }
        return false;
    }
}

113.路径总和ii

• 力扣链接：

• 代码随想录视频讲解链接：

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

• 力扣链接：https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

• 代码随想录视频讲解链接：https://www.bilibili.com/video/BV1vW4y1i7dn

/**
106. 从中序与后序遍历序列构造二叉树
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

length:数组的属性
length():数组的方法
size():集合的方法
 */
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if(postorder.length == 0){
            return null;
        }
        if(postorder.length == 1){
            return new TreeNode(postorder[0]);
        }
        // 左闭右开
        return buildHelper(inorder, 0, inorder.length, postorder, 0, postorder.length);
    }

    private TreeNode buildHelper(int[] inorder, int inorderStart, int inorderEnd, int[] postorder, int postorderStart, int postorderEnd){
        if(postorderStart == postorderEnd){
            return null;
        }
        int rootval = postorder[postorderEnd - 1];
        TreeNode root = new TreeNode(rootval);
        int index;
        for(index = inorderStart; index < inorderEnd; index++){
            if(inorder[index] == rootval){
                break;
            }
        }

        // 左中序和右中序
        int leftInorderStart = inorderStart;
        int leftInorderEnd = index;
        int rightInorderStart = index + 1;
        int rightInorderEnd = inorderEnd;
        // 左后序和右后序
        int leftPostorderStart = postorderStart;
        int leftPostorderEnd = postorderStart + (index - inorderStart);
        int rightPostorderStart = leftPostorderEnd;
        int rightPostorderEnd = postorderEnd - 1;

        root.left = buildHelper(inorder, leftInorderStart, leftInorderEnd, postorder, leftPostorderStart, leftPostorderEnd);
        root.right = buildHelper(inorder,rightInorderStart, rightInorderEnd, postorder, rightPostorderStart, rightPostorderEnd);

        return root;
    }
}

105.从前序与中序遍历序列构造二叉树

• 力扣链接：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

• 代码随想录视频讲解链接：https://www.bilibili.com/video/BV1vW4y1i7dn

/**
105. 从前序与中序遍历序列构造二叉树
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length == 0){
            return null;
        }
        if(preorder.length == 1){
            return new TreeNode(preorder[0]);
        }
        return buildHelper(preorder, 0, preorder.length, inorder, 0, inorder.length);
    }

    private TreeNode buildHelper(int[] preorder, int preorderStart, int preorderEnd, int[] inorder, int inorderStart, int inorderEnd){
        if(preorderStart == preorderEnd){
            return null;
        }
        int rootval = preorder[preorderStart];
        TreeNode root = new TreeNode(rootval);
        int index;
        for(index = inorderStart; index < inorderEnd; index++){
            if(inorder[index] == rootval){
                break;
            }
        }
        //左中序和右中序
        int leftInorderStart = inorderStart;
        int leftInorderEnd = index;
        int rightInorderStart = index + 1;
        int rightInorderEnd = inorderEnd;
        //左前序和右前序
        int leftPreorderStart = preorderStart + 1;
        int leftPreorderEnd = leftPreorderStart + (index - inorderStart);
        int rightPreorderStart = leftPreorderEnd;
        int rightPreorderEnd = preorderEnd;

        root.left = buildHelper(preorder, leftPreorderStart, leftPreorderEnd, inorder, leftInorderStart, leftInorderEnd);
        root.right = buildHelper(preorder, rightPreorderStart, rightPreorderEnd, inorder, rightInorderStart, rightInorderEnd);
        return root;
    }
}