leetcode二叉树3

404.左叶子之和

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：
输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24
示例 2:
输入: root = [1]
输出: 0
提示:

节点数在 [1, 1000] 范围内
-1000 <= Node.val <= 1000

解题思路

通过递归遍历二叉树，识别并累加所有左叶子节点的值。使用一个标志变量 flag 区分当前节点是否为其父节点的左子节点，只有当节点是叶子节点且是左子节点时，才将其值加到全局变量 sum 中。主函数从根节点开始递归，特殊处理单节点树（根节点不算左叶子），最终返回总和。

代码

class Solution {int sum = 0; // 定义全局变量，用于累加所有左叶子节点的值// 辅助函数：递归遍历二叉树，计算左叶子之和// root: 当前处理的节点// flag: 标记当前节点是左子节点(1)还是右子节点(0)public void fun1(TreeNode root, int flag) {// 如果当前节点是叶子节点（无左子节点且无右子节点）if (root.left == null && root.right == null) { // 检查是否是左叶子节点，只有 flag 为 1 时才累加if (flag == 1) {sum += root.val; // 将左叶子节点的值加到 sum 中}} else { // 如果不是叶子节点，继续递归处理子节点// 如果存在左子节点，递归调用并标记为左子节点 (flag=1)if (root.left != null) fun1(root.left, 1);// 如果存在右子节点，递归调用并标记为右子节点 (flag=0)if (root.right != null) fun1(root.right, 0);}}// 主函数：返回二叉树所有左叶子之和public int sumOfLeftLeaves(TreeNode root) {// 特殊情况：如果树只有一个节点（根节点是叶子），返回 0if (root.left == null && root.right == null) {return 0; // 根节点本身不算左叶子}fun1(root, 0); // 从根节点开始递归，根节点初始标记为 0（非左子节点）return sum; // 返回累加的结果}
}

513.找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:
输入: root = [2,1,3]
输出: 1
示例 2:
输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7
提示:

二叉树的节点个数的范围是 [1,104]
-231 <= Node.val <= 231 - 1

解题思路

通过层次遍历（BFS，广度优先搜索）找到二叉树的最底层，并记录每一层的最左节点值。由于层次遍历从左到右访问节点，每层的第一个节点即为最左节点，而最后一层的第一个节点即为最底层的最左节点。使用队列存储每层节点，遍历完所有层后，ans 保存的就是目标值。

代码

class Solution {public int findBottomLeftValue(TreeNode root) {int ans = root.val; // 初始化答案为根节点的值，作为最底层最左节点的候选Queue<TreeNode> queue = new ArrayDeque<>(); // 创建队列，用于层次遍历queue.offer(root); // 将根节点加入队列，开始遍历// 当队列不为空时，继续层次遍历while (!queue.isEmpty()) {boolean flag = true; // 标志位，用于标记每层的最左节点int size = queue.size(); // 获取当前层的节点数// 遍历当前层的所有节点while (size-- > 0) {TreeNode node = new TreeNode(); // 创建一个临时节点对象（稍显冗余）node = queue.poll(); // 从队列中取出当前节点，覆盖临时对象if (flag) ans = node.val; // 如果是该层第一个节点，更新答案为当前节点值flag = false; // 标志位置为 false，确保只记录最左节点// 将左子节点加入队列（如果存在）if (node.left != null) queue.offer(node.left);// 将右子节点加入队列（如果存在）if (node.right != null) queue.offer(node.right);}}return ans; // 返回最底层最左节点的值}
}

112.路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。
示例 2：
输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。
示例 3：
输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。
提示：

树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

解题思路

通过深度优先搜索（DFS）递归遍历二叉树，从根节点到每个叶子节点计算路径和。每次递归时累加当前节点值，并在到达叶子节点时检查路径和是否等于目标值 targetSum。如果存在至少一条路径满足条件，则返回 true，否则返回 false。主函数处理空树情况，并启动递归过程。

代码

class Solution {// 辅助函数：递归检查是否存在从当前节点到叶子节点的路径和等于目标值// root: 当前处理的节点// sum: 从根节点到当前节点的路径和// targetSum: 目标和public boolean fun1(TreeNode root, int sum, int targetSum) {// 如果当前节点为空，返回 false（空路径不满足条件）if (root == null) {return false;}// 将当前节点值加到路径和中sum += root.val;// 如果当前节点是叶子节点（无左子节点且无右子节点）if (root.left == null && root.right == null) {// 检查路径和是否等于目标和，若相等返回 trueif (sum == targetSum) return true;}// 递归检查左子树或右子树是否存在满足条件的路径// 使用 || 表示只要有一条路径满足条件即返回 truereturn fun1(root.left, sum, targetSum) || fun1(root.right, sum, targetSum);}// 主函数：判断是否存在从根节点到叶子节点的路径和等于目标值public boolean hasPathSum(TreeNode root, int targetSum) {// 特殊情况：如果树为空，返回 falseif (root == null) {return false;}// 调用辅助函数，从根节点开始，初始路径和为 0return fun1(root, 0, targetSum);}
}

113.路径总和II

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]
示例 2：
输入：root = [1,2,3], targetSum = 5
输出：[]
示例 3：
输入：root = [1,2], targetSum = 0
输出：[]
提示：

树中节点总数在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

解题思路

通过深度优先搜索（DFS）递归遍历二叉树，从根节点到每个叶子节点，记录路径并计算路径和。使用一个临时列表 list 保存当前路径，在到达叶子节点时检查路径和是否等于目标值 targetSum，若满足则将路径副本加入结果集 ans。通过回溯（移除当前节点值）确保路径记录的正确性，最终返回所有满足条件的路径。

代码

class Solution {// 定义全局变量，用于存储所有满足条件的路径List<List<Integer>> ans = new ArrayList<>();// 辅助函数：递归遍历二叉树，寻找从根到叶子路径和等于目标值的路径// root: 当前处理的节点// sum: 从根节点到当前节点的路径和// targetSum: 目标和// list: 当前路径的临时记录public void fun1(TreeNode root, int sum, int targetSum, ArrayList list) {// 如果当前节点为空，直接返回（空路径不处理）if (root == null) {return;}// 将当前节点值加入临时路径list.add(root.val);// 更新路径和sum += root.val;// 如果当前节点是叶子节点（无左子节点且无右子节点）if (root.left == null && root.right == null) {// 检查路径和是否等于目标和if (sum == targetSum) {// 如果满足条件，将当前路径的副本加入结果集ans.add(new ArrayList<>(list));}} else {// 如果不是叶子节点，继续递归遍历左子树fun1(root.left, sum, targetSum, list);// 递归遍历右子树fun1(root.right, sum, targetSum, list);}// 回溯：移除当前节点值，以便尝试其他路径list.remove(list.size() - 1);}// 主函数：返回所有从根到叶子路径和等于目标值的路径public List<List<Integer>> pathSum(TreeNode root, int targetSum) {// 创建临时列表，用于记录当前路径ArrayList<Integer> list = new ArrayList<>();// 调用辅助函数开始递归fun1(root, 0, targetSum, list);// 返回结果集return ans;}
}

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

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:
输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]
示例 2:
输入：inorder = [-1], postorder = [-1]
输出：[-1]
提示:

1 <= inorder.length <= 3000
postorder.length == inorder.length
-3000 <= inorder[i], postorder[i] <= 3000
inorder 和 postorder 都由不同的值组成
postorder 中每一个值都在 inorder 中
inorder 保证是树的中序遍历
postorder 保证是树的后序遍历

解题思路

利用后序遍历的最后一个元素作为根节点，通过中序遍历找到根节点的左右子树范围，递归构建二叉树。为了避免每次线性查找根节点在中序遍历中的位置，使用哈希表预先存储值到索引的映射，从而将查找时间从 O(n) 优化到 O(1)。通过递归划分数组范围，最终构造出完整的二叉树。

代码

class Solution {// 定义哈希表，用于快速查找中序遍历中值的索引private HashMap<Integer, Integer> inorderMap;// 辅助函数：根据中序和后序遍历递归构建二叉树// inorder: 中序遍历数组// postorder: 后序遍历数组// inStart, inEnd: 中序遍历的当前范围// postStart, postEnd: 后序遍历的当前范围private TreeNode buildTreeHelper(int[] inorder, int[] postorder, int inStart, int inEnd, int postStart, int postEnd) {// 如果当前范围无效，返回 null（无子树）if (inStart > inEnd) {return null;}// 后序遍历的最后一个元素是当前子树的根节点int rootVal = postorder[postEnd];TreeNode root = new TreeNode(rootVal);// 在中序遍历中找到根节点的索引int rootIndex = inorderMap.get(rootVal);// 计算左子树的节点数int leftSize = rootIndex - inStart;// 递归构建左子树root.left = buildTreeHelper(inorder, postorder, inStart, rootIndex - 1, postStart, postStart + leftSize - 1);// 递归构建右子树root.right = buildTreeHelper(inorder, postorder, rootIndex + 1, inEnd, postStart + leftSize, postEnd - 1);return root;}// 主函数：根据中序和后序遍历构造二叉树public TreeNode buildTree(int[] inorder, int[] postorder) {// 初始化哈希表，存储中序遍历值到索引的映射inorderMap = new HashMap<>();for (int i = 0; i < inorder.length; i++) {inorderMap.put(inorder[i], i);}// 调用辅助函数，初始范围为整个数组return buildTreeHelper(inorder, postorder, 0, inorder.length - 1, 0, postorder.length - 1);}
}// TreeNode 定义（假设已提供）
class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int val) {this.val = val;}
}

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

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:
输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]
示例 2:
输入: preorder = [-1], inorder = [-1]
输出: [-1]
提示:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均 无重复 元素
inorder 均出现在 preorder
preorder 保证为二叉树的前序遍历序列
inorder 保证为二叉树的中序遍历序列

解题思路

利用前序遍历的第一个元素作为根节点，通过中序遍历找到根节点的左右子树范围，递归构建二叉树。为了避免每次线性查找根节点在中序遍历中的位置，使用哈希表预先存储值到索引的映射，从而将查找时间从 O(n) 优化到 O(1)。通过递归划分数组范围，最终构造出完整的二叉树。

代码

class Solution {// 定义哈希表，用于快速查找中序遍历中值的索引private HashMap<Integer, Integer> inorderMap;// 辅助函数：根据前序和中序遍历递归构建二叉树// inorder: 中序遍历数组// preorder: 前序遍历数组// inStart, inEnd: 中序遍历的当前范围// preStart, preEnd: 前序遍历的当前范围public TreeNode fun1(int[] inorder, int[] preorder, int inStart, int inEnd, int preStart, int preEnd) {// 如果当前范围无效（中序或前序范围不合法），返回 nullif (inEnd < inStart || preStart > preEnd) return null;// 前序遍历的第一个元素是当前子树的根节点TreeNode root = new TreeNode(preorder[preStart]);// 在中序遍历中找到根节点的索引（使用哈希表快速查找）int mid = inorderMap.get(root.val);// 计算左子树的节点数int leftSize = mid - inStart;// 递归构建左子树// 左子树的中序范围: [inStart, mid - 1]// 左子树的前序范围: [preStart + 1, preStart + leftSize]root.left = fun1(inorder, preorder, inStart, mid - 1, preStart + 1, preStart + leftSize);// 递归构建右子树// 右子树的中序范围: [mid + 1, inEnd]// 右子树的前序范围: [preStart + leftSize + 1, preEnd]root.right = fun1(inorder, preorder, mid + 1, inEnd, preStart + leftSize + 1, preEnd);// 返回当前子树的根节点return root;}// 主函数：根据前序和中序遍历构造二叉树public TreeNode buildTree(int[] preorder, int[] inorder) {// 如果输入数组为空或长度为 0，返回 nullif (inorder == null || inorder.length == 0) return null;// 初始化哈希表，存储中序遍历值到索引的映射inorderMap = new HashMap<>();for (int i = 0; i < inorder.length; i++) {inorderMap.put(inorder[i], i);}// 调用辅助函数，初始范围为整个数组return fun1(inorder, preorder, 0, inorder.length - 1, 0, preorder.length - 1);}
}// TreeNode 定义（假设已提供）
class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int val) {this.val = val;}
}

654.最大二叉树

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的 子数组前缀上 构建左子树。
递归地在最大值右边的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

示例 1：
输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：
- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。- [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。- 空数组，无子节点。- [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。- 空数组，无子节点。- 只有一个元素，所以子节点是一个值为 1 的节点。- [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。- 只有一个元素，所以子节点是一个值为 0 的节点。- 空数组，无子节点。
示例 2：
输入：nums = [3,2,1]
输出：[3,null,2,null,1]
提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数 互不相同

解题思路

通过递归分治的方式构建最大二叉树。每次在当前子数组范围内找到最大值作为根节点，然后将数组分为左子数组和右子数组，分别递归构建左子树和右子树。使用索引范围控制递归，确保正确划分子树，最终返回构造好的二叉树根节点。

代码

class Solution {// 辅助函数：递归构建最大二叉树// nums: 输入的整数数组// start: 当前子数组的起始索引// end: 当前子数组的结束索引public TreeNode fun1(int[] nums, int start, int end) {// 如果当前范围无效（起始索引大于结束索引），返回 nullif (start > end) return null;// 创建当前子树的根节点TreeNode root = new TreeNode();int max = 0;    // 记录当前范围内的最大值int index = 0;  // 记录最大值的索引// 遍历当前范围，找到最大值及其索引for (int i = start; i <= end; i++) {if (max <= nums[i]) { // 使用 <= 确保更新到最后一个最大值index = i;        // 更新最大值索引max = nums[i];    // 更新最大值}}// 设置根节点值为最大值root.val = max;// 递归构建左子树（最大值左边的子数组）root.left = fun1(nums, start, index - 1);// 递归构建右子树（最大值右边的子数组）root.right = fun1(nums, index + 1, end);// 返回当前子树的根节点return root;}// 主函数：根据数组构造最大二叉树public TreeNode constructMaximumBinaryTree(int[] nums) {// 特殊情况：如果数组长度为 1，直接返回单节点树if (nums.length == 1) return new TreeNode(nums[0]);// 调用辅助函数，初始范围为整个数组return fun1(nums, 0, nums.length - 1);}
}