找树左下角的值 路径总和 从中序与后序遍历序列构造二叉树
找树左下角的值 路径总和 从中序与后序遍历序列构造二叉树
513.找树左下角的值
力扣题目链接(opens new window)
给定一个二叉树，在树的最后一行找到最左边的值。
示例 1:
示例 2:
思路
递归
迭代法就用层序遍历，很简单，这里就用递归来实现
这道题我一开始的思路，跟二叉树所有路径这道题目一样。
找到所有的路径中最长的，最长的路径中排在最左边，然后取出路径最后一个结点值即可
看了下题解，发现题解在我的基础上做了优化
题解会定义一个depth 来表示当前的层数。就是代替二叉树所有路径的path。
在递归的过程中遍历到叶子结点。加以判断如果depth大于保存的最大深度值，那么更新最大深度
需要注意：递归中要先对结点的左子树递归，然后对右子树递归，这样可以保证先遇到左叶子结点
递归三要素
1.入参返回值 ： TreeNode node ，int depth
2.终止条件 ： 遍历到叶子结点 判断当前结点深度和之前记录的最大节点深度
3.核心逻辑 ：后序遍历 回溯
代码如下
// 时间复杂度o(n)
// 空间复杂度o(n)
int Depth = -1;
int Value = -1;
public int findBottomLeftValue(TreeNode root) {
if (root == null) {
return -1;
}
int depth = 1;
postOrder(root, depth);
return Value;
}
public void postOrder(TreeNode node, int depth) {
if (node.left == null && node.right == null) {
if (depth > Depth) {
Depth = depth;
Value = node.val;
}
return;
}
if (node.left != null) {
postOrder(node.left, ++depth);
depth--;
}
if (node.right != null) {
postOrder(node.right, ++depth);
depth--;
}
}
112. 路径总和 113.路径总和ii
112. 路径总和
力扣题目链接(opens new window)
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
说明: 叶子节点是指没有子节点的节点。
示例: 给定如下二叉树，以及目标和 sum = 22，
返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
思路
递归算法
该题要判断根节点到叶子结点的路径值 是否等于 targetSum
首先找到根节点到叶子结点的路径
那么【二叉树的所有路径】这道题满足找到路径的方法
在该算法找到叶子结点同时，判断路径的值是否等于targetSum 如果不等于，那么继续遍历
如果等于，定义的全局变量result==true，最后返回
递归三要素
入参和返回值 TreeNode node List path 返回值为void
终止条件 当遍历到叶子结点时，中止. 当已经遍历到符合条件的路径时，也就是result = true时，中止
核心逻辑 前序遍历
总的来说这道题就是在【二叉树的所有路径】上有一些改动
代码如下
// 时间复杂度o(n)
// 空间复杂度o(n)
int TargetSum = 0;
boolean result = false;
public boolean hasPathSum(TreeNode root, int targetSum) {
TargetSum = targetSum;
if(root == null)
return result;
List<Integer> path = new ArrayList<>();
findPath(root,path);
return result;
}
public void findPath(TreeNode node, List<Integer> path) {
path.add(node.val);
if(result){
return;
}
if (node.left == null && node.right == null) {
int sum = 0;
for (int i = 0; i < path.size(); i++) {
sum = sum + path.get(i);
}
if(sum ==TargetSum){
result = true;
}
return;
}
if(node.left != null){
findPath(node.left,path);
path.remove(path.size()-1);
}
if(node.right != null){
findPath(node.right,path);
path.remove(path.size()-1);
}
return;
}
问题
问题
当遍历到符合的路径时，我想让程序尽快的退出，不再继续递归
因此加了一个终止条件。但会导致原本加入PATH里的结点没有加入，提前结束递归
if(result){
return;
}
path.add(node.val);
解决方式 该中止条件和path.add(node.val);换位置,让结点正常接入path，就不会出现数组越界
path.add(node.val);
if(result){
return;
}
113.路径总和ii
力扣题目链接(opens new window)
给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
说明: 叶子节点是指没有子节点的节点。
示例: 给定如下二叉树，以及目标和 sum = 22，
思路
思路：递归法
该题思路和二叉树的所有路径十分类似
不同的是递归的中止条件需要加以判断，把合适的路径保存下，而不是保存所有的路径
递归法三要素
1.方法入参和返回值 TreeNode node List path Listresult 无返回值
2.中止条件 遍历到叶子结点
3.核心逻辑 先序遍历。因为需要先访问根节点，然后访问一层层访问到叶子结点，先序遍历满足条件
代码如下
// 时间复杂度o(n)
// 空间复杂度o(n)
int TargetSum;
public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
List<List<Integer>> result = new ArrayList<>();
if (root == null)
return result;
TargetSum = targetSum;
List<Integer> path = new ArrayList<>();
travel(root, path, result);
return result;
}
public void travel(TreeNode node, List<Integer> path, List<List<Integer>> result) {
path.add(node.val);
if (node.right == null && node.left == null) {
int sum = 0;
for (int i = 0; i < path.size(); i++) {
sum = sum + path.get(i);
}
if (sum == TargetSum) {
result.add(new ArrayList<>(path));
}
return;
}
if (node.left != null) {
travel(node.left, path, result);
path.remove(path.size() - 1);
}
if (node.right != null) {
travel(node.right, path, result);
path.remove(path.size() - 1);
}
return;
}
问题
我在最终的结果里加入符合条件路径时，忽略了引用传递
这样导致result里保存的path会随着程序的运行而变化
错误代码
if (sum == TargetSum) {
result.add(path);
}
正确代码:new 一个list 来接受path,避免引用传递
if (sum == TargetSum) {
result.add(new ArrayList<>(path));
}
106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树
106.从中序与后序遍历序列构造二叉树
力扣题目链接(opens new window)
根据一棵树的中序遍历与后序遍历构造二叉树。
注意: 你可以假设树中没有重复的元素。
例如，给出
- 中序遍历 inorder = [9,3,15,20,7]
- 后序遍历 postorder = [9,15,7,20,3] 返回如下的二叉树：
思路
递归法
后序遍历和中序遍历可以唯一确认一个二叉树
递归法三要素
方法的入参和返回值 int[] inorder int[] postorder 返回值TreeNode root
中止条件 后序数组不存在元素 postorder为空，返回null
核心逻辑
1.获取后序数组的最后一个元素
2.遍历中序数组，找到元素，并记录下标
3.分割中序数组，分为左中序数组，右中序数组
4.用左中序数组的size去分割后序数组，得到左后序数组。然后用右中序数组的size去分割后序数组，得到右后序数组
5.递归
代码如下
// 时间复杂度o(n)
// 空间复杂度o(n)
public static TreeNode buildTree(int[] inorder, int[] postorder) {
if (postorder.length == 0) {// 后序数组不存在元素 postorder为空，返回null
return null;
}
return travel(inorder, postorder);
}
public static TreeNode travel(int[] inorder, int[] postorder) {
if (postorder.length == 0) {// 后序数组不存在元素 postorder为空，返回null
return null;
}
int rootVal = postorder[postorder.length - 1];// 获取后序数组的最后一个元素
int index;
for (index = 0; index < inorder.length; index++) {// 遍历中序数组，找到元素，并记录下标
if (inorder[index] == rootVal) {
break;
}
}
int[] leftMidOrder = new int[index];// 分割中序数组，分为左中序数组，右中序数组
int[] rightMidOrder = new int[inorder.length - index - 1];
for (int i = 0; i < index; i++) {
leftMidOrder[i] = inorder[i];
}
for (int i = index + 1; i < inorder.length; i++) {
rightMidOrder[i-index-1] = inorder[i];
}
int[] leftPostOrder = new int[index];// 分割后序数组，分为左中序数组，右中序数组
int[] rightPostOrder = new int[inorder.length - index - 1];
for (int i = 0; i < leftMidOrder.length; i++) {
leftPostOrder[i] = postorder[i];
}
for (int i = leftMidOrder.length; i < postorder.length - 1; i++) {
rightPostOrder[i-leftMidOrder.length] = postorder[i];
}
TreeNode root = new TreeNode(rootVal, null, null);// 递归
root.left = travel(leftMidOrder, leftPostOrder);
root.right = travel(rightMidOrder, rightPostOrder);
return root;
}
105.从前序与中序遍历序列构造二叉树
力扣题目链接(opens new window)
根据一棵树的前序遍历与中序遍历构造二叉树。
注意: 你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树：
思路
递归法
先序遍历
先序遍历和中序遍历可以唯一确认一颗二叉树
递归法三要素
1.方法入参和返回值 int[] preorder, int[] inorder 返回值TreeNode node
2.中止条件 先序数组为空
3.核心逻辑
1.取出先序数组第一个元素
2.遍历中序数组，找到该元素，记录下标
3.分割中序数组。分为左中序数组，右中序数组
4.根据左中序数组size,分割左前序数组。根据右中序数组size,分割右前序数组。
5.递归
代码如下
// 时间复杂度o(n)
// 空间复杂度o(n)
public TreeNode buildTree(int[] preorder, int[] inorder) {
if (preorder.length == 0) {
return null;
}
return travel(preorder, inorder);
}
public TreeNode travel(int[] preorder, int[] inorder) {
if (preorder.length == 0) {// 中止条件 先序数组为空
return null;
}
int rootVal = preorder[0];// 取出先序数组第一个元素
int index = 0;
for (int i = 0; i < inorder.length; i++) {// 遍历中序数组，找到该元素，记录下标
if (inorder[i] == rootVal) {
index = i;
}
}
int[] leftMidNum = new int[index];// 分割中序数组。分为左中序数组，右中序数组
int[] rightMidNum = new int[preorder.length - 1 - index];
for (int i = 0; i < index; i++) {
leftMidNum[i] = inorder[i];
}
for (int i = index + 1; i < inorder.length; i++) {
rightMidNum[i - 1 - index] = inorder[i];
}
// 根据左中序数组size,分割左前序数组。根据右中序数组size,分割右前序数组。
int[] leftPreNum = new int[index];
int[] rightPreNum = new int[preorder.length - 1 - index];
for (int i = 0; i < index; i++) {
leftPreNum[i] = preorder[i + 1];
}
for (int i = index + 1; i < preorder.length; i++) {
rightPreNum[i - index - 1] = preorder[i];
}
TreeNode root = new TreeNode(rootVal, null, null);
root.left = travel(leftPreNum, leftMidNum);
root.right = travel(rightPreNum, rightMidNum);
return root;
}