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

LeetCode 513.找树左下角的值

使用层序遍历会比较简单，找到最底层 最左边（即最后一层第一个叶子结点）代码如下：

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        int result = root.val;
        queue.offer(root);
        while(!queue.isEmpty()) {
            int len = queue.size();
            for(int i=0; i<len; i++) {
                TreeNode node = queue.poll();
                if(i == 0) result = node.val;
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
        }
        return result;
    }
}

LeetCode 112. 路径总和

需要搜索某一条符合条件的路径，所以递归需要返回值，通过每次减去遍历路径上节点的值来统计路径和，最后判断count == 0是否满足即可，递归终止条件是判断是否为叶子结点，所以空节点不入栈，代码如下：

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root == null) return false;
        return pathSum(root, targetSum - root.val);
    }
    public boolean pathSum(TreeNode node, int count) {
        if(count == 0 && node.left == null && node.right == null) return true;
        if(node.left == null && node.right == null) return false;
        if(node.left != null) {
            if(pathSum(node.left, count-node.left.val)) return true;
        }
        if(node.right != null) {
            if(pathSum(node.right, count-node.right.val)) return true;
        }
        return false;
    }
}

LeetCode 113.路径总和ii

需要搜索整棵树，但不需要对返回值进行处理，所以递归不需要返回值。代码如下：

class Solution {
    List<List<Integer>> result = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        transval(root, targetSum);
        return result;
    }
    public void transval(TreeNode node, int count) {
        if(node == null) return;
        path.add(node.val);
        count -= node.val;
        if(node.left == null && node.right == null && count == 0) {
            result.add(new LinkedList(path));
        }
        transval(node.left, count);
        transval(node.right, count);
        path.remove(path.size() - 1);
    }
}

注意，result.add(new LinkedList(path))时，一定要重新new一个LinkedList，不然add进去的是[]，对java的这种机制不是很了解，就当是踩了一个小坑。

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

如何根据后序和中序构造一个唯一的二叉树：以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素是节点元素。注意，中序数组大小一定和后序数组的大小相同。代码如下：

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        TreeNode root = tranversal(inorder,0, inorder.length, postorder, 0, postorder.length);
        return  root;
    }
    public TreeNode tranversal(int[] inorder, int inorderBegin, int inorderEnd, int[] post, int postBegin, int postEnd) {
        if(postEnd == postBegin) return null;
        int val = post[postEnd - 1];
        TreeNode root = new TreeNode(val);
        if(postEnd - postBegin == 1) return root;
        int valIndex = -1;
        for(int i=inorderBegin; i< inorderEnd; i++) {
            if(val == inorder[i]){
                valIndex = i;
                break;
            }
        }
        // 切割中序数组（左闭右开）
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = valIndex;
        int rightInorderBegin = valIndex + 1;
        int rightInorderEnd = inorderEnd;
        // 切割后序数组（左闭右开）
        int leftPostBegin = postBegin;
        int leftPostEnd = postBegin + (leftInorderEnd - leftInorderBegin);
        int rightPostBegin = leftPostEnd;
        int rightPostEnd = postEnd - 1;
        root.left = tranversal(inorder, leftInorderBegin, leftInorderEnd, post, leftPostBegin, leftPostEnd);
        root.right = tranversal(inorder, rightInorderBegin, rightInorderEnd, post, rightPostBegin, rightPostEnd);
        return root;
    }
}

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

思路和上面的106一致，代码如下：

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        TreeNode root = transerval(preorder,0, preorder.length, inorder, 0, inorder.length);
        return root;
    }
    public TreeNode transerval(int[] preorder, int preorderBegin, int preorderEnd, int[] inorder, int inorderBegin, int inorderEnd) {
        if(preorderBegin == preorderEnd) return null;
        int val = preorder[preorderBegin];
        TreeNode root = new TreeNode(val);
        if(preorderEnd - preorderBegin == 1) return root;
        int valIndex = -1;
        for(int i=inorderBegin; i<inorderEnd; i++){
            if(val == inorder[i]) valIndex = i;
        }
        // 切中序数组（左闭右开）
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = valIndex;
        int rightInorderBegin = valIndex + 1;
        int rightInorderEnd = inorderEnd;
        // 切前序数组（左闭右开）
        int leftPreorderBegin = preorderBegin + 1;
        int leftPreorderEnd = leftPreorderBegin + leftInorderEnd - leftInorderBegin;
        int rightPreorderBegin = leftPreorderEnd;
        int rightPreorderEnd = preorderEnd;
        root.left = transerval(preorder, leftPreorderBegin, leftPreorderEnd, inorder, leftInorderBegin, leftInorderEnd);
        root.right = transerval(preorder, rightPreorderBegin, rightPreorderEnd, inorder, rightInorderBegin, rightInorderEnd);
        return root;
    }
}