二叉树05

找树左下角的值

思路：递归找到深一层的最左边元素

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) findLeftValue(root.left,deep+1);
        if(root.right != null) findLeftValue(root.right,deep+1);
    }
}

 路径总和  

题目链接：112. 路径总和 - 力扣（LeetCode）

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 - 力扣（LeetCode）

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        List<Integer> path = new ArrayList<>();
        preorderdfs(root,targetSum,res,path);
        return res;

    }

    private void preorderdfs(TreeNode root,int targetSum, List<List<Integer>> res, List<Integer> path){
        path.add(root.val);
        if(root.left == null && root.right == null){
            if(targetSum - root.val == 0){
                res.add(new ArrayList<>(path));
                return;
            }
        }

        if(root.left != null){
            preorderdfs(root.left,targetSum-root.val,res,path);
            path.remove(path.size()-1);
        }

        if(root.right != null){
            preorderdfs(root.right,targetSum-root.val,res,path);
            path.remove(path.size()-1);
        }
        return;

    }
}

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

题目链接：106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

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;
    }
}

题目链接：105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）、

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.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;
    }
}