代码随想录刷题记录day17之寻找树左下角的值+求路径总和+构造二叉树
代码随想录刷题记录day17之寻找树左下角的值+求路径总和+构造二叉树
513. 找树左下角的值
思想
用两个变量，maxHeight，res
其中maxHeight维护最大深度，res维护结果
本题不涉及 对中间节点的操作，所以前中后序遍历都可以，只要左在前就i好了。
即使处于同一层，会先遍历左节点，所以res记录的是最左边的值。
代码
class Solution {
private int maxHeight=Integer.MIN_VALUE;//用来记录深度
private int res;
public int findBottomLeftValue(TreeNode root) {
//需要确定是不是最底层的
//前序遍历
leftValue(root,1);
return res;
}
public void leftValue(TreeNode node,int deepth){
if(node.left==null && node.right==null) {
if(deepth>maxHeight){
//因为都是左节点先操作 如果在同一层 这里的代码不会被执行 deepth=maxHeight
maxHeight=deepth;
res=node.val;
}
return;
}
//判断是不是左节点 通过父节点来判断
if(node.left!=null){
deepth++;
leftValue(node.left,deepth);
deepth--;
}
if(node.right!=null){
deepth++;
leftValue(node.right,deepth);
deepth--;
}
}
}
112. 路径总和
思想
需要回溯、且递归函数有返回值
-
递归终止条件是叶节点，将当前的叶节点的值+sum，判断是否和目标值相等 。
-
单层递归逻辑：
当前的值的左节点不为空，判断左方向是否有符合条件的，向上返回
右节点同理
代码
class Solution {
public boolean hasPathSum(TreeNode root, int targetSum) {
if(root==null) return false;
return path(root,targetSum,0);
}
public boolean path(TreeNode node,int targetSum,int sum){
//递归终止条件
if(node.left==null && node.right==null){
sum+=node.val;
//找到了目标值
if(sum==targetSum){
return true;
}else{
return false;
}
}
if(node.left!=null){
sum+=node.val;
if(path(node.left,targetSum,sum)) return true;//判断左方向是否有符合条件的，需要向上去返回
sum-=node.val;
}
if(node.right!=null){
sum+=node.val;
if(path(node.right,targetSum,sum)) return true; //函数有返回值，相当于告诉我们右子树 或者右方向的 是否有符合条件的
sum-=node.val;
}
return false;
}
}
113. 路径总和 II
思想
和上一题思路差不多，只不过多维护了一个集合来记录路径 ，也得回溯
代码
class Solution {
private List<List<Integer>> res=new ArrayList<>();
public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
List<Integer> path=new ArrayList<>();
if(root==null){
return res;
}
traversal(root,targetSum,0,path);
return res;
}
public void traversal(TreeNode node,int targetSum,int sum,List<Integer> path){
//递归终止条件
//System.out.println(sum);
if(node.left==null && node.right==null){
//递归到了叶子节点了 判断是否与目标值相等
sum+=node.val;
path.add(node.val);
if(sum==targetSum){
res.add(new ArrayList<>(path));//结果中添加一个数组
}
sum-=node.val;
path.remove(path.size()-1);
return;
}
//单层内的递归逻辑
if(node.left!=null){
sum+=node.val;
path.add(node.val);
traversal(node.left,targetSum,sum,path);
path.remove(path.size()-1);
sum-=node.val;
}
if(node.right!=null){
sum+=node.val;
path.add(node.val);
traversal(node.right,targetSum,sum,path);
path.remove(path.size()-1);
sum-=node.val;
}
}
}
106. 从中序与后序遍历序列构造二叉树
思想：
1.后序遍历的最后一个元素确定根节点的位置
2.根据根节点去中序中切分中序数组，为左中序数组和右中序数组
3.根据左中序数组和右中序数组 的大小，再去切分后序遍历的数组，得到左后序数组和右后序数组
3.递归调用
需要注意下标的区间问题，打印日志调试。
犯了一个错误，以为得到左中序数组和右中序数组了，左后序数组和右后序数组的顺序会与之相同，结果显然不是。
代码
class Solution {
public TreeNode buildTree(int[] inorder, int[] postorder) {
return tree(inorder,postorder);
}
public TreeNode tree(int[] inorder, int[] postorder){
//递归终止条件:后序中的长度为0
if(postorder.length==0){
return null;
}
int rootValue=postorder[postorder.length-1];//后序遍历中的最后一个元素就是根节点
//System.out.println("根节点值："+rootValue);
TreeNode root=new TreeNode(rootValue);
int index=0;
for(int i=0;i<inorder.length;i++){
//根据根节点去切割中序遍历 左闭右开
if(inorder[i]==rootValue){
index=i;
break;
}
}
//System.out.println("根节点下标："+index);
//构造左中序列
int[] leftIn=Arrays.copyOfRange(inorder,0,index);
//System.out.println("左中序"+Arrays.toString(leftIn));
int[] rightIn=Arrays.copyOfRange(inorder,index+1,inorder.length);//右中序列
//System.out.println("右中序"+Arrays.toString(rightIn));
//根据左中序数组 去构建左后序数组
int[] leftPost=new int[leftIn.length];
int[] rightPost=new int[rightIn.length];
for(int i=0;i<leftIn.length;i++){
leftPost[i]=postorder[i];
}
//System.out.println("左后序"+Arrays.toString(leftPost));
for(int i=0;i<rightIn.length;i++){
rightPost[i]=postorder[index+i];
}
// System.out.println("右后序"+Arrays.toString(rightPost));
root.left=tree(leftIn,leftPost);
root.right=tree(rightIn,rightPost);
return root;
}
}
105. 从前序与中序遍历序列构造二叉树
思想
和106题类似
代码
class Solution {
public TreeNode buildTree(int[] preorder, int[] inorder) {
return tree(preorder,inorder);
}
public TreeNode tree(int[] preorder,int[] inorder){
if(preorder.length==0) return null;
int rootValue=preorder[0];//前序遍历的第一个元素就是根节点
TreeNode root=new TreeNode(rootValue);
//根据根节点去中序中切分
int index=0;
for(int i=0;i<inorder.length;i++){
if(inorder[i]==root.val){
index=i;
break;
//找到了 下标 即第一轮 3的位置 下标为1
}
}
//根据下标去切分左中序 和右中序
int [] leftIn=Arrays.copyOfRange(inorder,0,index);
//System.out.println("左中序"+Arrays.toString(leftIn));
int [] rightIn=Arrays.copyOfRange(inorder,index+1,inorder.length);
//System.out.println("右中序"+Arrays.toString(rightIn));
//根据左中序 和右中序 去切分前序数组
int [] leftPre=new int[leftIn.length];
int [] rightPre=new int[rightIn.length];
for(int i=0;i<leftIn.length;i++){
leftPre[i]=preorder[i+1];
}
//System.out.println("左前序"+Arrays.toString(leftPre));
for(int i=0;i<rightIn.length;i++){
rightPre[i]=preorder[leftIn.length+1+i];
}
//System.out.println("右前序"+Arrays.toString(rightPre));
root.left=tree(leftPre,leftIn);
root.right=tree(rightPre,rightIn);
return root;
}
}