力扣算法
513.找树左下角的值
112. 路径总和
113. 路径总和 II
106. 从中序与后序遍历序列构造二叉树
105.从前序与中序遍历序列构造二叉树
具体内容
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
做题思路
用前序遍历,要注意题目只是找左下角,而不是左子树。可通过得出该二叉树的深度是多少,深度最大且最左边则是我们要求的值,且由于设计回溯的过程,具体可看下图,加深理解
![回溯](https://img-blog.csdnimg.cn/dc29a4fc9f994aecb03ad0f98c68ca16.png
解题
递归
class Solution {
//深度
int Deep = -1;
//返回的结果
int result = 0;
public int findBottomLeftValue(TreeNode root) {
if(root == null){return 0;}
findLeft(root,0);
return result;
}
public void findLeft(TreeNode root,int deep){
//递归终止条件
//遍历到叶子节点
if(root.left == null && root.right == null){
//再判断他的深度
if(deep > Deep){
Deep = deep;
//获取该节点的值
result = root.val;
}
}
if(root.left != null){
deep++;
findLeft(root.left,deep);
//回溯
deep--;
}
if(root.right != null){
deep++;
findLeft(root.right,deep);
//回溯
deep--;
}
}
}
112. 路径总和
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径,这条路径上所有节点值相加等于目标和 targetSum 。如果存在,返回 true ;否则,返回 false 。
叶子节点 是指没有子节点的节点。
示例 1:
输入:root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出:true 解释:等于目标和的根节点到叶节点路径如上图所示。
做题思路
由于知道了目标值是多少,因此可用相减的方式,判断最后结果是否为0
解题
class Solution {
public boolean hasPathSum(TreeNode root, int targetSum) {
if (root == null) return false;
//由于递归函数中没有减去根节点,因此这里需要减去
return traversal(root,targetSum-root.val);
}
//递归
public boolean traversal(TreeNode node,int count){
//终止条件
if(node.left == null && node.right == null && count == 0){
return true;
}
if(node.left == null && node.right == null){
return false;
}
//递归
if(node.left != null){
count -= node.left.val;
if(traversal(node.left,count)){
return true;
}
//回溯
count += node.left.val;
}
if(node.right != null){
count -= node.right.val;
if(traversal(node.right,count)){
return true;
}
//回溯
count += node.right.val;
}
return false;
}
}
解答代码存在的疑问
什么时候需要返回值什么时候不需要?
不需要遍历全部,一旦遍历到满足条件的值要返回就需要返回值
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 输出:[]
做题思路
与上题思路一致,且由于是遍历所有,因此不需要返回值
解题
递归
class Solution {
public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
List<List<Integer>> list = new ArrayList<>();
if(root == null){return list;}
List<Integer> list1 = new ArrayList<>();
traversal(root,targetSum,list,list1);
return list;
}
public void traversal(TreeNode node,int count,List<List<Integer>> list,List<Integer> list2){
list2.add(node.val);
if(node.left == null && node.right == null){
if(count - node.val == 0){
list.add(new ArrayList<>(list2));
}
return;
}
if(node.left != null){
traversal(node.left,count - node.val,list,list2);
//回溯
list2.remove(list2.size()-1);
}
if(node.right != null){
traversal(node.right,count - node.val,list,list2);
//回溯
list2.remove(list2.size()-1);
}
}
}
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 保证是树的后序遍历
做题思路
由中序遍历可得,最后一个数是根节点;之后得出了根节点,而中序遍历,根节点的左边是左子树,右边是右子树
解题
递归
class Solution {
Map<Integer, Integer> map; // 方便根据数值查找位置
public TreeNode buildTree(int[] inorder, int[] postorder) {
map = new HashMap<>();
//将中序遍历的值依次添加进map里面
for(int i = 0;i < inorder.length;i++){
map.put(inorder[i],i);
}
return findNode(inorder, 0, inorder.length, postorder,0, postorder.length);
}
//由于要遍历所有,所以不用返回值
//切割数组方法
public TreeNode findNode(int[] inorder, int inBegin, int inEnd, int[] postorder, int postBegin, int postEnd) {
if(inBegin >= inEnd){
return null;
}
//先用后序遍历获取根节点,再通过map获取该节点在中序遍历的位置
//得出了在中序遍历中 根节点的位置 也就是该位置的左边是左子树 右边是右子树
int i = map.get(postorder[postoedr-1]);
//构造出该节点
TreeNode node = new TreeNode(inorder[i]);
//求出左子树的数量
int leftNum = i - inBegin;
//postBegin+leftNum代表左子树长度,在后序遍历只能通过长度来获得
node.left = findNode(inorder,inBegin,i,postorder,postBegin,postBegin+leftNum);
//最后要减1,因为最后元素为根节点
node.right = findNode(inorder,i+1,inEnd,postorder,postBegin+leftNum,postEnd-1);
return node;
}
}
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 保证 为二叉树的中序遍历序列
做题思路
与上题思路一致
解题
递归
class Solution {
Map<Integer> map;
public TreeNode buildTree(int[] preorder, int[] inorder) {
map = new HashMap<>();
for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
map.put(inorder[i], i);
}
return findNode(preorder, 0, preorder.length, inorder, 0, inorder.length); // 前闭后开
}
public TreeNode findNode(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd) {
// 参数里的范围都是前闭后开
if (preBegin >= preEnd || inBegin >= inEnd) { // 不满足左闭右开,说明没有元素,返回空树
return null;
}
int rootIndex = map.get(preorder[preBegin]); // 找到前序遍历的第一个元素在中序遍历中的位置
TreeNode root = new TreeNode(inorder[rootIndex]); // 构造结点
int lenOfLeft = rootIndex - inBegin; // 保存中序左子树个数,用来确定前序数列的个数
root.left = findNode(preorder, preBegin + 1, preBegin + lenOfLeft + 1,
inorder, inBegin, rootIndex);
root.right = findNode(preorder, preBegin + lenOfLeft + 1, preEnd,
inorder, rootIndex + 1, inEnd);
return root;
}
}