代码随想录算法训练营第十六天|513找树左下角.的值 112. 路径总和，和 113. 路径总和ii 106.从中序与后序遍历序列构造二叉树，105.从前序与中序遍历序列构造二叉树

今日任务

513.找树左下角的值 
112. 路径总和，
106.从中序与后序遍历序列构造二叉树
105.从前序与中序遍历序列构造二叉树

513.找树左下角的值 

题目连接 . - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        /**
        * 层序
        *
        * */
        Queue<TreeNode> queue = new LinkedList<>();
        int res = Integer.MIN_VALUE;
        if (root == null) {return res;}
        queue.add(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode tmpNode = queue.poll();
                if (i == 0) {
                    res = tmpNode.val;
                }
                if (tmpNode.left != null) {queue.add(tmpNode.left);}
                if (tmpNode.right != null) {queue.add(tmpNode.right);}
            }
        }
        return res;
    }
}

112. 路径总和

  
题目连接  . - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        Stack<Object> stack = new Stack<Object>();
        if (root == null) {return false;}
        stack.add(root);
        stack.add(root.val);
        while (!stack.isEmpty()) {
            int val = (int)stack.pop();
            TreeNode node = (TreeNode)stack.pop();
            if (node.left == null && node.right == null) {
                if (val == targetSum){ return true;}
            }
            if (node.right != null) {
                stack.add(node.right);
                stack.add(val + node.right.val);
            }
            if (node.left != null) {
                stack.add(node.left);
                stack.add(val + node.left.val);
            }
        }
        return false;
    }
}

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

题目连接  . - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if (inorder.length == 0 || postorder.length == 0) {return null;}
        return buildHelper(inorder, 0, inorder.length,postorder,0,postorder.length);
    }

     private TreeNode buildHelper(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd){
        if (postStart == postEnd) {return null;}
        int rootVal = postorder[postEnd - 1];
        TreeNode root = new TreeNode(rootVal);
        int index = 0;
        for (int i = inStart; i < inEnd; i++) {
            if (inorder[i] == rootVal) {
                index = i;
                break;
            }
        }

        /* 中序拆分 */
        int leftInorderStart = inStart;
        int leftInorderEnd = index;
        int rightInorderStart = index + 1;
        int rightInorderEnd = inEnd;

        /* 后续拆分 */
        int leftpostorderStart = postStart;
        int leftpostorderEnd = postStart + (index - inStart);
        int rightpostorderStart = leftpostorderEnd;
        int rightpostorderEnd = postEnd - 1;

        root.left = buildHelper(inorder, leftInorderStart, leftInorderEnd, postorder, leftpostorderStart, leftpostorderEnd);
        root.right = buildHelper(inorder,rightInorderStart, rightInorderEnd, postorder, rightpostorderStart, rightpostorderEnd);

        return root;
    }
}

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

题目连接  . - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder.length == 0 || inorder.length == 0){return null;}
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i], i);
        }
        return builder(preorder, 0, preorder.length,inorder,0, inorder.length);
    }

    private TreeNode builder(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd){
        if (preStart == preEnd){return null;}
        int rootVal = preorder[preStart];
        TreeNode root = new TreeNode(rootVal);
        int middleIndex = map.get(rootVal);

        int lenofleft = middleIndex - inStart;

        root.left = builder(preorder, preStart + 1,preStart + lenofleft + 1, inorder, inStart, middleIndex);
        root.right = builder(preorder, preStart + lenofleft + 1, preEnd, inorder, middleIndex + 1, inEnd);
        return root;

    }    
}