day018 第六章 二叉树 part05
一、513.找树左下角的值
这个题目的主要思路是使用广度优先搜索（BFS）遍历整棵树，最后返回最后一层的最左边的节点的值。具体的实现可以使用队列来存储每一层的节点，并且在遍历每一层节点时，不断更新最左边的节点的值。时间复杂度为O(n)，其中n是节点的个数。
二、112.路径总和
这个题目的主要思路是使用深度优先搜索（DFS）遍历整棵树，同时记录到达每个节点时的路径和，如果到达叶子节点时路径和等于给定的目标和，则返回true。具体的实现可以使用递归来实现DFS，同时在每个节点处更新路径和，并且在到达叶子节点时判断路径和是否等于目标和。时间复杂度为O(n)，其中n是节点的个数。
三、113.路径总和ii
这个题目的主要思路和112题类似，也是使用DFS遍历整棵树，同时记录到达每个节点时的路径和，并且在到达叶子节点时判断路径和是否等于给定的目标和。不同的是，这个题目需要返回所有满足条件的路径，而不仅仅是返回true或false。具体的实现可以在DFS的过程中使用一个数组来存储当前的路径，并且在到达叶子节点时，如果路径和等于目标和，则将整个路径加入结果列表中。时间复杂度为O(n^2)，其中n是节点的个数，主要是因为每次需要复制一份路径数组。
四、106.从中序与后序遍历序列构造二叉树
这个题目的主要思路是使用递归来构建整棵树。具体的实现可以先找到后序遍历序列中的最后一个节点作为根节点，然后在中序遍历序列中找到根节点的位置，从而确定左子树和右子树的范围。然后递归的构建左子树和右子树即可。时间复杂度为O(n)，其中n是节点的个数。
五、105.从前序与中序遍历序列构造二叉树
这个题目的主要思路和106题类似，也是使用递归来构建整棵树。具体的实现可以先找到前序遍历序列中的第一个节点作为根节点，然后在中序遍历序列中找到根节点的位置，从而确定左子树和右子树的范围。然后递归的构建左子树和右子树即可。时间复杂度为O(n)，其中n是节点的个数。
一、513.找树左下角的值
public int findBottomLeftValue(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
int res = root.val;
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;
}
二、112.路径总和
public boolean hasPathSum(TreeNode root, int sum) {
if (root == null) {
return false;
}
if (root.left == null && root.right == null) {
return sum == root.val;
}
return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
}
三、113.路径总和ii
public List<List<Integer>> pathSum(TreeNode root, int sum) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
dfs(root, sum, path, res);
return res;
}
private void dfs(TreeNode root, int sum, List<Integer> path, List<List<Integer>> res) {
if (root == null) {
return;
}
path.add(root.val);
if (root.left == null && root.right == null && sum == root.val) {
res.add(new ArrayList<>(path));
}
dfs(root.left, sum - root.val, path, res);
dfs(root.right, sum - root.val, path, res);
path.remove(path.size() - 1);
}
四、106.从中序与后序遍历序列构造二叉树
public TreeNode buildTree(int[] inorder, int[] postorder) {
if (inorder == null || postorder == null || inorder.length != postorder.length) {
return null;
}
int n = inorder.length;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
map.put(inorder[i], i);
}
return buildTree(inorder, 0, n - 1, postorder, 0, n - 1, map);
}
private TreeNode buildTree(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd, Map<Integer, Integer> map) {
if (inStart > inEnd || postStart > postEnd) {
return null;
}
int rootVal = postorder[postEnd];
TreeNode root = new TreeNode(rootVal);
int index = map.get(rootVal);
int leftSize = index - inStart;
root.left = buildTree(inorder, inStart, index - 1, postorder, postStart, postStart + leftSize - 1, map);
root.right = buildTree(inorder, index + 1, inEnd, postorder, postStart + leftSize, postEnd - 1, map);
return root;
}
五、105.从前序与中序遍历序列构造二叉树
public TreeNode buildTree(int[] preorder, int[] inorder) {
if (preorder == null || inorder == null || preorder.length != inorder.length) {
return null;
}
int n = preorder.length;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
map.put(inorder[i], i);
}
return buildTree(preorder, 0, n - 1, inorder, 0, n - 1, map);
}
private TreeNode buildTree(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd, Map<Integer, Integer> map) {
if (preStart > preEnd || inStart > inEnd) {
return null;
}
int rootVal = preorder[preStart];
TreeNode root = new TreeNode(rootVal);
int index = map.get(rootVal);
int leftSize = index - inStart;
root.left = buildTree(preorder, preStart + 1, preStart + leftSize, inorder, inStart, index - 1, map);
root.right = buildTree(preorder, preStart + leftSize + 1, preEnd, inorder, index + 1, inEnd, map);
return root;
}