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

Leetcode 513.找树左下角的值

题目链接

方法一：迭代法

思路：层序遍历，最后一层的第一个元素即为二叉树左下角的值
代码：

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

方法二：递归法

思路：找二叉树左下角的值等价于找递归深度最大的第一个遍历的值
代码：

    class Solution {
        private int result;
        private int maxDepth = Integer.MIN_VALUE;

        public int findBottomLeftValue(TreeNode root) {
            // 递归法
            traversal(root, 0);
            return result;
        }

        private void traversal(TreeNode root, int depth) {
            if (root == null) {
                return;
            }
            // 叶子节点
            if (root.left == null && root.right == null) {
                if (depth > maxDepth) {
                    maxDepth = depth;
                    result = root.val;
                }
            }
            // 左
            if (root.left != null) {
                depth++;
                traversal(root.left, depth);
                // 回溯
                depth--;
            }
            // 右
            if (root.right != null) {
                depth++;
                traversal(root.right, depth);
                // 回溯
                depth--;
            }
        }
    }

Leetcode 112. 路径总和

题目链接
思路：递归遍历二叉树
代码：

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return false;
        }
        return traversal(root, targetSum - root.val);
    }

    private boolean traversal(TreeNode node, int sum) {
        if (node.left == null && node.right == null && sum == 0) {
            return true;
        }
        if (node.left == null && node.right == null && sum != 0) {
            return false;
        }
        // 左
        if (node.left != null) {
            sum -= node.left.val;
            if (traversal(node.left, sum)) {
                return true;
            }
            // 回溯
            sum += node.left.val;
        }
        // 右
        if (node.right != null) {
            sum -= node.right.val;
            if (traversal(node.right, sum)) {
                return true;
            }
            // 回溯
            sum += node.right.val;
        }
        return false;
    }
}

Leetcode 113.路径总和ii

题目链接
思路：递归遍历，回溯
代码：

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

    private void traversal(TreeNode node, int targetSum, List<List<Integer>> result, List<Integer> path) {
        path.add(node.val);
        // 遇到叶子节点
        if (node.left == null && node.right == null) {
            // 找到和为targetSum的路径
            if (targetSum - node.val == 0) {
                result.add(new ArrayList<>(path));
            }
            // 如果和不为targetSum，返回
            return;
        }
        // 递归左子树
        if (node.left != null) {
            traversal(node.left, targetSum - node.val, result, path);
            // 回溯
            path.remove(path.size() - 1);
        }
        // 递归右子树
        if (node.right != null) {
            traversal(node.right, targetSum - node.val, result, path);
            // 回溯
            path.remove(path.size() - 1);
        }
    }
}

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

题目链接
思路：先从后序数组中找到根节点，然后再在中序数值中找到根节点的位置，对中序数值和后序数组进行切割
代码：

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

    private TreeNode traversal(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 = traversal(inorder, inBegin, rootIndex, postorder, postBegin, postBegin + lenOfLeft);
        root.right = traversal(inorder, rootIndex + 1, inEnd, postorder, postBegin + lenOfLeft, postEnd - 1);

        return root;
    }
}

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

题目链接
思路：根据前序数组第一个值找到该值在中序数组中的位置，根据这个位置对中序数组和前序数组进行切割
代码：

class Solution {
        // 定义一个map，用来保存中序数组的元素和所在位置
    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 traversal(preorder, 0, preorder.length, inorder, 0, inorder.length);
    }

    private TreeNode traversal(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 = traversal(preorder, preBegin + 1, preBegin + lenOfLeft + 1, inorder, inBegin, rootIndex);
        root.right = traversal(preorder, preBegin + lenOfLeft + 1, preEnd, inorder, rootIndex + 1, inEnd);

        return root;
    }
}