1. LeetCode 513.找树左下角的值
题目链接：https://leetcode.cn/problems/find-bottom-left-tree-value/description/
文章链接：https://programmercarl.com/0513.找树左下角的值.html
视频链接：https://www.bilibili.com/video/BV1424y1Z7pn
思路：
使用递归或迭代都可以。
由于是找最底层最左边的节点的值，即寻找最大深度的最左边叶子节点的值。
使用递归方法时，每次记录当前深度，并尝试与最大深度进行比较。当是叶子节点，且深度大于最大深度时，更新最大深度，并将当前节点的值作为当前层的最左边的值。
值得注意的是，当前层的其他叶子节点由于无法大于更新后的最大深度，就不能更新值。第一个更新最大深度的叶子节点也就是最左边的叶子节点。
使用迭代法时，只需在每层i==0时更新值就可以。
解法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
int res = 0;
int maxDepth = 0;
public int findBottomLeftValue(TreeNode root) {
//find(root,0);
find2(root);
return res;
}
// 前序遍历
public void find(TreeNode cur,int depth) {
if (cur == null) return;
depth++;
// 中
// 判断是否是叶子节点
if (cur.left == null && cur.right == null) {
if (depth > maxDepth) {
maxDepth = depth;
res = cur.val;
}
}
// 左
find(cur.left,depth);
// 右
find(cur.right,depth);
}
// 迭代法 //层序遍历
public void find2(TreeNode root) {
Deque<TreeNode> deque = new ArrayDeque<>();
deque.offer(root);
while (!deque.isEmpty()) {
int len = deque.size();
for (int i = 0; i<len; i++) { // 对每一层分别进行分析
TreeNode cur = deque.poll();
if (i == 0) {
res = cur.val;
}
if (cur.left != null) {
deque.offer(cur.left);
}
if (cur.right != null) {
deque.offer(cur.right);
}
}
}
}
}
2. 路径总和
1️⃣112. 路径总和
思路：
使用递归方法。尽量不要通过获取路径上的所有值来求和的方式进行判断，可以使用目标数值与节点数值相减的方式，当节点为叶子节点，且最终的差值是叶子节点的值时，表示存在路径上所有值相加上目标值，否则不存在。
解法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
// public boolean hasPathSum(TreeNode root, int targetSum) {
// if (root == null) return false;
// List<Integer> path = new ArrayList<>();
// return find(root,targetSum,path);
// }
// // 递归
// public boolean find(TreeNode cur, int targetSum, List<Integer> path) {
// // 中
// path.add(cur.val);
// // 叶子节点
// if (cur.left==null && cur.right==null) {
// int sum = 0;
// for (int i = 0;i<path.size();i++){
// sum += path.get(i);// 路径值求和
// }
// if (sum==targetSum) {
// return true;
// }
// return false;
// }
// boolean left = false;
// boolean right = false;
// // 左
// if (cur.left != null) {
// left = find(cur.left,targetSum,path);
// path.remove(path.size() - 1);// 回溯
// }
// // 右
// if (cur.right != null) {
// right = find(cur.right,targetSum,path);
// path.remove(path.size() - 1);//回溯
// }
// return left || right;
// }
public boolean hasPathSum(TreeNode root, int targetSum) {
if (root == null) return false;
// 中
if (root.left == null && root.right == null ) {
return targetSum == root.val;
}
// 左
if (hasPathSum(root.left,targetSum-root.val)) {
return true;
}
// 右
if (hasPathSum(root.right,targetSum-root.val)) {
return true;
}
return false;
}
}
2️⃣113. 路径总和ii
思路：
与112相同的判断是否路径和等于目标和。但要注意的是，题目需要返回路径，而若方法中使用了引用对象表示路径，不能直接将最终的路径引用对象添加到结果集合中，需要创建新的对象。这是因为引用对象在递归中指向的是同一个对象，即便加入了集合中也是，若回溯该引用对象中的值，则集合中添加的引用对象也会进行修改，因此需要创建新的对象添加到结果集合中。
解法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
List<List<Integer>> res = new ArrayList<>();
public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
List<Integer> path = new ArrayList<>();
find(root,targetSum,path);
return res;
}
public void find(TreeNode cur,int targetSum,List<Integer> curPath) {
if (cur == null) return;
curPath.add(cur.val);
// 判断是否是叶子节点
if (cur.left == null && cur.right == null) {
if (targetSum == cur.val) {
res.add(new ArrayList<>(curPath));//需要创建新的对象，否则，随着回溯会不断的更新同一个对象
}
return;
}
// 左
if (cur.left != null) {
find(cur.left,targetSum-cur.val,curPath);
curPath.remove(curPath.size()-1);//回溯
}
// 右
if (cur.right != null) {
find(cur.right,targetSum-cur.val,curPath);
curPath.remove(curPath.size()-1);//回溯
}
}
}
3. LeetCode 106.从中序与后序遍历序列构造二叉树
题目链接：https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/
文章链接：https://programmercarl.com/0106.从中序与后序遍历序列构造二叉树.html#相关题目推荐
视频链接：https://www.bilibili.com/video/BV1vW4y1i7dn
思路：使用递归
如下步骤：
第一步：如果数组大小为零的话，说明是空节点了。
第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
第五步：切割后序数组，切成后序左数组和后序右数组
第六步：递归处理左区间和右区间。
如何切割中序和后序数组？
1️⃣首先要切割中序数组，为什么先切割中序数组呢？
切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组。
2️⃣接下来就要切割后序数组了。
首先后序数组的最后一个元素指定不能要了，这是切割点， 也是当前二叉树中间节点的元素，已经用了。
中序数组大小一定是和后序数组的大小相同的。因此，中序数组切成了左中序数组和右中序数组了，那么后序数组就可以按照左中序数组的大小来切割，切成左后序数组和右后序数组。
值得注意的是，中序数组的左右子树大小和后序数组的左右子树大小一致，也就是说，若将中序数组切割成左右两个中序数组，由于后序数组顺序是左右中，则左中序数组的大小就是后序数组左后序数组的大小，右中序数组的大小就是后序数组右后序数组的大小。这样就可以根据中序数组左右数组的大小将后序数组切割成两个后序数组。
注意：递归中始终遵守左闭右开切割的方式。
解法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode buildTree(int[] inorder, int[] postorder) {
if (inorder == null || postorder == null) {
return null;
}
return find(inorder,0,inorder.length,postorder,0,postorder.length);
}
public TreeNode find(int[] inorder,int inStart,int inEnd,int[] postorder,int postStart,int postEnd) {
if (postStart == postEnd) {
return null;
}
// 中
int interNum = postorder[postEnd - 1]; // 当前节点的值
TreeNode root = new TreeNode(interNum);// 创建当前节点
int interIndex=0;
// 确定当前节点在中序遍历的位置
for (;interIndex < inorder.length;interIndex++) {
if (inorder[interIndex] == interNum) {
break;
}
}
// 切割中序遍历
int leftInStart = inStart;
int leftInEnd = interIndex;
int rightInStart = interIndex + 1;
int rightInEnd = inEnd;
// 切割后序遍历
int leftPostStart = postStart;
int leftPostEnd = postStart + interIndex - inStart;
int rightPostStart = leftPostEnd;
int rightPostEnd = postEnd - 1;
// 左
root.left = find(inorder,leftInStart,leftInEnd,postorder,leftPostStart,leftPostEnd);
// 右
root.right = find(inorder,rightInStart,rightInEnd,postorder,rightPostStart,rightPostEnd);
return root;
}
}
4. LeetCode 105.从前序与中序遍历序列构造二叉树
题目链接：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
思路：和106相似，只是将后序变为前序。切割前序遍历时，需要排除前序数组第一个元素。
解法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode buildTree(int[] preorder, int[] inorder) {
if (inorder == null || preorder == null) {
return null;
}
return find(inorder,0,inorder.length,preorder,0,preorder.length);
}
public TreeNode find(int[] inorder,int inStart,int inEnd,int[] preorder,int preStart,int preEnd) {
if (preStart == preEnd) {
return null;
}
// 中
int interNum = preorder[preStart]; // 当前节点的值
TreeNode root = new TreeNode(interNum);// 创建当前节点
int interIndex=0;
// 确定当前节点在中序遍历的位置
for (;interIndex < inorder.length;interIndex++) {
if (inorder[interIndex] == interNum) {
break;
}
}
// 切割中序遍历
int leftInStart = inStart;
int leftInEnd = interIndex;
int rightInStart = interIndex + 1;
int rightInEnd = inEnd;
// 切割前序遍历
int leftPreStart = preStart+1;
int leftPreEnd = leftPreStart + interIndex - inStart;
int rightPreStart = leftPreEnd;
int rightPreEnd = preEnd;
// 左
root.left = find(inorder,leftInStart,leftInEnd,preorder,leftPreStart,leftPreEnd);
// 右
root.right = find(inorder,rightInStart,rightInEnd,preorder,rightPreStart,rightPreEnd);
return root;
}
}
124
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
