Day16 | 二叉树part04

513. 找树左下角的值 - 力扣（LeetCode）

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        TreeNode node = root;
        Queue<TreeNode> q = new ArrayDeque<>();
        q.add(root);
        while (!q.isEmpty()) {
            node = q.poll();
            if (node.right != null) {
                q.add(node.right);
            }
            if (node.left != null)
                q.add(node.left);
        }
        return node.val;
    }
}

112. 路径总和 - 力扣（LeetCode）

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

目标值递归减少来判断，比遍历所有路径得到每一条路径总和值方法时间、空间复杂度要低，可读性更高。

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

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        int n = postorder.length;
        if (n == 0) {
            return null;
        }
        int leftSize = indexOf(inorder, postorder[n - 1]);// 左子树
        int[] in1 = Arrays.copyOfRange(inorder, 0, leftSize);
        int[] in2 = Arrays.copyOfRange(inorder, leftSize + 1, n);
        int[] post1 = Arrays.copyOfRange(postorder, 0, leftSize);
        int[] post2 = Arrays.copyOfRange(postorder, leftSize, n - 1);
        TreeNode left = buildTree(in1, post1);
        TreeNode right = buildTree(in2, post2);
        return new TreeNode(postorder[n - 1], left, right);
    }

    // 返回x在a中的下标，保证x一定在a中
    private int indexOf(int[] a, int x) {
        for (int i = 0;; i++) {
            if (a[i] == x) {
                return i;
            }
        }
    }
}

这个题用使用Map避免数组复制。

import java.util.HashMap;
import java.util.Map;

public class Solution {
   private Map<Integer, Integer> indexMap;

   public TreeNode buildTree(int[] inorder, int[] postorder) {
       indexMap = new HashMap<>();
       for (int i = 0; i < inorder.length; i++) {
           indexMap.put(inorder[i], i);
       }
       return buildTree(postorder, 0, postorder.length - 1, 0, inorder.length - 1);
   }

   private TreeNode buildTree(int[] postorder, int postStart, int postEnd, int inStart, int inEnd) {
       if (postStart > postEnd || inStart > inEnd) {
           return null;
       }
       int rootVal = postorder[postEnd];
       TreeNode root = new TreeNode(rootVal);
       int inRootIndex = indexMap.get(rootVal);
       int leftSize = inRootIndex - inStart;
       root.left = buildTree(postorder, postStart, postStart + leftSize - 1, inStart, inRootIndex - 1);
       root.right = buildTree(postorder, postStart + leftSize, postEnd - 1, inRootIndex + 1, inEnd);
       return root;
   }
}