代码练习第十八天|113. 路径总和 II、112. 路径总和、513. 找树左下角的值、105. 从前序与中序遍历序列构造二叉树、106. 从中序与后序遍历序列构造二叉树

113. 路径总和 II

/**
 * 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 List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        List<Integer> element = new ArrayList<>();
        pathSum(root,targetSum,res,element);
        return res;
    }
    public void pathSum(TreeNode root, int targetSum,
        List<List<Integer>> res,List<Integer> element){
        
        element.add(root.val);
        if(root.left == null && root.right==null){
            if(targetSum - root.val == 0) res.add(new ArrayList(element));
            return;
        }

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

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

    }
}

112. 路径总和

/**
 * 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) {
        if(root == null) return false;
        targetSum -= root.val;
        if(root.left == null && root.right==null ) return targetSum ==0;
        if(root.left == null && root.right==null && targetSum !=0) return false;

        if(root.left != null ) {
            if( hasPathSum(root.left,targetSum)) return true;

        }
        if(root.right != null ) {
            if( hasPathSum(root.right,targetSum)) return true;

        }
        return false;
    }


}

513. 找树左下角的值

/**
 * 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 {
    int tmpDeep = 0;
    int value = 0;
    public int findBottomLeftValue(TreeNode root) {
        value = root.val;
        findLeftValue(root,0);
        return value;
    }
    public void findLeftValue(TreeNode root,int deep){
        if(root.left == null && root.right == null && deep > tmpDeep){
            value = root.val;
            tmpDeep = deep;
        }
        if(root.left != null) findLeftValue(root.left,deep + 1);
        if(root.right != null) findLeftValue(root.right,deep + 1);
    }
}

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

/**
 * 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<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        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;

    }

}

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

/**
 * 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<>();
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        for(int i = 0;i<inorder.length;i++){
            map.put(inorder[i],i);  
        }

        return createNode(inorder,0,inorder.length,postorder,0,postorder.length);
    }

    public TreeNode createNode(int[] inorder,int inbegain,int inEnd,
                                int[] postorder,int postBegain,int postEnd){
        if(inbegain >= inEnd || postBegain >= postEnd){
            return null;
        }

        int rootIndex = map.get(postorder[postEnd -1]);
        TreeNode root = new TreeNode(inorder[rootIndex]);
        int length = rootIndex - inbegain;
        root.left = createNode(inorder,inbegain,rootIndex,postorder,postBegain,postBegain+length);
        root.right = createNode(inorder,rootIndex + 1,inEnd,postorder,postBegain+length,postEnd-1);
        return root;
        
    }
}