231007刷题记录

231007刷题记录
参考代码代码随想录来刷的

关键词：二叉树、回溯、先序中序&中序后序序列构造二叉树

1 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 left;
        }
        if (root.right != null) {
            boolean right = hasPathSum(root.right, targetSum);
            if (right)
                return right;
        }
        return false;
    }
}

2 113. 路径总和 II

力扣题目链接
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
该题类似
[257. 二叉树的所有路径]，使用了回溯的思想。(https://leetcode.cn/problems/binary-tree-paths/)

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        if (root == null)
            return Collections.emptyList();
        List<Integer> path = new ArrayList<>();
        List<List<Integer>> result = new ArrayList<>();
        traversal(root, path, result, targetSum);
        return result;
    }
    private void traversal(TreeNode root, List<Integer> path, List<List<Integer>> result, int targetSum) {
        path.add(root.val);
        if (root.left == null && root.right == null) {
            if (targetSum - root.val == 0)
                result.add(new ArrayList<>(path));
            return;
        }
        if (root.left != null) {
            traversal(root.left, path, result, targetSum - root.val);
            path.remove(path.size() - 1);
        }
        if (root.right != null) {
            traversal(root.right, path, result, targetSum - root.val);
            path.remove(path.size() - 1);
        }
    }
}

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

力扣题目链接
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

class Solution {
        private 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 build(inorder, 0, inorder.length, postorder, 0, postorder.length);
    }

    // 左闭右开
    private TreeNode build(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd) {
        if (inStart >= inEnd)
            return null;
        int rootVal = postorder[postEnd - 1];
        Integer index = map.get(rootVal);
        TreeNode left = build(inorder, inStart, index, postorder, postStart, postStart + index - inStart);
        TreeNode right = build(inorder, index + 1, inEnd, postorder, postEnd - inEnd + index, postEnd - 1);
        TreeNode root = new TreeNode(rootVal, left, right);
        return root;
    }
}

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

力扣题目链接

class Solution {
    private Map<Integer, Integer> map;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        map = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i], i);
        }
        return build(preorder, 0, preorder.length, inorder, 0, inorder.length);
    }
    private TreeNode build(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd) {
        if (preBegin >= preEnd)
            return null;
        int rootVal = preorder[preBegin];
        Integer rootIndex = map.get(rootVal);
        TreeNode left = build(preorder, preBegin + 1, preBegin + 1 + rootIndex - inBegin, 
                inorder, inBegin, rootIndex);
        TreeNode right = build(preorder, preEnd - inEnd + rootIndex + 1, preEnd,
                inorder, rootIndex + 1, inEnd);
        return new TreeNode(rootVal, left, right);
    }
}