算法训练第十八天 | LeetCode 513、112、113、106、105

LeetCode 513找树左下角的值

题目简析：

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点

思路分析：这题其实跟找最底层（深度）是一样的，但是注意逻辑

发现叶子结点后再考虑替换

    int deep = Integer.MIN_VALUE;
    int tar = 0;
    public int findBottomLeftValue(TreeNode root) {
        dfs(root,0);
        return tar;
    }
    public void dfs(TreeNode root,int nowDeep){
        if(root == null){
            return;
        }
        if(root.left==null && root.right==null) {
            if (nowDeep > deep) {
                deep = nowDeep;
                tar = root.val;
            }
        }
        if(root.left!=null)dfs(root.left,nowDeep + 1);
        if(root.right!=null)dfs(root.right,nowDeep + 1);
    }

---

LeetCode 112路径之和

题目简析：求结点和为指定值的路径

思路分析：也是常规二叉树的回溯/dfs，比较值得注意的思路就是通过targetSum-节点值来找到最终的路径

    public boolean hasPathSum(TreeNode root, int targetSum) {
        return dfs(root,targetSum);
    }
    public boolean dfs(TreeNode root,int targetSum){
        if(root == null){
            return false;
        }
        if(root.left == null && root.right == null){
            return root.val == targetSum;
        }
        return dfs(root.left,targetSum - root.val) ||
                dfs(root.right,targetSum - root.val);
    }

---

LeetCode 113路径总和II

题目简析：求结点和为指定值的路径

思路分析：也是常规二叉树的回溯/dfs，比较值得注意的思路就是通过targetSum-节点值来找到最终的路径

    List<List<Integer>> ans = new ArrayList<>();
    LinkedList<Integer> arr = new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        dfs(root, targetSum);
        return ans;
    }
    public void dfs(TreeNode root, int targetSum) {
        if (root == null) {
            return;
        }
        //每次进入就填入集合
        arr.add(root.val);
        //通过不断的减当前值，最终为0就能加入ans
        targetSum -= root.val;
        if (root.left == null && root.right == null && targetSum == 0) {
            ans.add(new LinkedList<>(arr));
        }
        //左右开始找
        dfs(root.left,targetSum);
        dfs(root.right,targetSum);
        //跟112类似的，如果使用LinkedList直接使用removeLast
        //使用List就用remove(arr.size()-1)
        arr.removeLast();
    }

---

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

class Solution {
    Map<Integer, Integer> map;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        map = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
            map.put(inorder[i], i);
        }

        return findNode(preorder, 0, preorder.length, inorder,  0, inorder.length);  // 前闭后开
    }

    public TreeNode findNode(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd) {
        // 参数里的范围都是前闭后开
        if (preBegin >= preEnd || inBegin >= inEnd) {  // 不满足左闭右开，说明没有元素，返回空树
            return null;
        }
        int rootIndex = map.get(preorder[preBegin]);  // 找到前序遍历的第一个元素在中序遍历中的位置
        TreeNode root = new TreeNode(inorder[rootIndex]);  // 构造结点
        int lenOfLeft = rootIndex - inBegin;  // 保存中序左子树个数，用来确定前序数列的个数
        root.left = findNode(preorder, preBegin + 1, preBegin + lenOfLeft + 1,  
                            inorder, inBegin, rootIndex);
        root.right = findNode(preorder, preBegin + lenOfLeft + 1, preEnd,
                            inorder, rootIndex + 1, inEnd);

        return root;
    }
}

LeetCode 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保存中序序列的数值对应位置
            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;
    }
}