文章介绍了如何通过层次遍历、递归方法解决二叉树问题，包括找树左下角值、路径总和判断及中/后/前序遍历构造二叉树。展示了两种不同思路的解题过程和代码实现。
第十八天 二叉树part05
513.找树左下角的值
题目
给定一个二叉树，在树的最后一行找到最左边的值。
示例 1:
示例 2:
解答
方法一（笨方法，使用层次遍历迭代）
class Solution {
public int findBottomLeftValue(TreeNode root) {
int result = 0;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()){
int len = queue.size();
result = queue.peek().val;//永远是最左边先入队
while (len-- > 0){
TreeNode temp = queue.poll();
if (temp.left != null)
queue.offer(temp.left);
if (temp.right != null)
queue.offer(temp.right);
}
}
return result;
}
}
方法二（递归）
所谓的回溯也就是深度不能变，在遍历左子树时，深度+了就要再-回来，不然再进入其右子树时深度就不对了
下面的两种方式等价，第一种直接对dept操作，第二中并没有更新当前的结点的dept，而是对传入的参数进行修改+1
-
if (root->left) { depth++; traversal(root->left, depth); depth--; // 回溯 } -
if (root->left) { traversal(root->left, depth + 1); // 隐藏着回溯 }
class Solution {
int result = 0;
int maxDept = Integer.MIN_VALUE;//最大的深度，如果当前深度>最大深度并且为叶子，更新最大深度并且更新result
public int findBottomLeftValue(TreeNode root) {
travel(root,0);
return result;
}
private void travel(TreeNode root, int dept){
//因为假设二叉树中至少有一个节点，所以不必判断root是否为空
if (root.left == null && root.right == null){
//为叶子结点
if (dept > maxDept){
maxDept = dept;
result = root.val;
}
}
if (root.left != null){
travel(root.left,dept + 1);
//等价于
// dept++;
// travel(root.left,dept);
// dept--;
}
if (root.right != null)
travel(root.right,dept + 1);
}
}
注意
if (root.left != null)
travel(root.left,dept + 1);
if (root.right != null)
travel(root.right,dept + 1);
对于这部分的代码，必须先左再右，因为要找的是最左侧的结点，也就是会先找到左侧，这样再找到右侧时只要在同一层也不会更新
112. 路径总和
题目
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
说明: 叶子节点是指没有子节点的节点。
示例: 给定如下二叉树，以及目标和 sum = 22，
返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
解答
其实就是看递归的条件，每次递归-去当前结点的值，如果达到叶子结点值为0就返回true，否则继续找，在判断左右子树时，只有最后都找完均不满足才能返回false
class Solution {
public boolean hasPathSum(TreeNode root, int targetSum) {
if (root == null)
return false;
return travel(root,targetSum);
}
private boolean travel(TreeNode root, int count){
if (root.left == null && root.right == null){//碰到叶子结点
if (count - root.val == 0)
return true;
else
return false;
}
if (root.left != null){
if (travel(root.left,count - root.val))
return true;//找到了，返回true
}
if (root.right != null){
if (travel(root.right,count - root.val))
return true;//找到了，返回true
}
//只有左右子树都没找到，才返回false
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
输出：[]
提示：
- 树中节点总数在范围
[0, 5000]内 -1000 <= Node.val <= 1000-1000 <= targetSum <= 1000
解答
class Solution {
public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
if (root == null)
return result;
travel(root,targetSum,result,path);
return result;
}
private void travel(TreeNode root, int count, List<List<Integer>> result, List<Integer> path){
path.add(root.val);
if (root.left == null && root.right == null){
if (count - root.val == 0)
result.add(new ArrayList<>(path));//result.add(path);
return;
}
if (root.left != null){
travel(root.left, count - root.val, result, path);
path.remove(path.size() - 1);
}
if (root.right != null){
travel(root.right, count - root.val, result, path);
path.remove(path.size() - 1);
}
}
}
特别注意
- 第二个函数中的
result.add(new ArrayList<>(path))，只能这么写，不能写成result.add(path)，因为直接将path添加到result中会导致result中的path对象发生变化，也就是说之后对path的修改会导致result也发生变化 - 注意回溯
path.remove(path.size() - 1);，只有到叶子结点后才会逐层进行删除，每次删除一个，达到回溯的效果
106.从中序与后序遍历序列构造二叉树
题目
根据一棵树的中序遍历与后序遍历构造二叉树。
注意: 你可以假设树中没有重复的元素。
例如，给出
- 中序遍历 inorder = [9,3,15,20,7]
- 后序遍历 postorder = [9,15,7,20,3] 返回如下的二叉树：
解答
class Solution {
public TreeNode buildTree(int[] inorder, int[] postorder) {
//post找根，in分左右
if (postorder.length == 0)
return null;
int root_val = postorder[postorder.length - 1];
int index = -1;
for (int i = 0; i < inorder.length; i++) {
if (inorder[i] == root_val){
index = i;
break;
}
}
TreeNode root = new TreeNode(root_val);//找到了中序的根
if (postorder.length == 1)//此时是叶子结点
return root;
int[] leftInOrder = Arrays.copyOfRange(inorder, 0, index);
int[] rightInOrder = Arrays.copyOfRange(inorder, index + 1, inorder.length);
int[] leftPostOrder = Arrays.copyOfRange(postorder, 0, leftInOrder.length);
int[] rightPostOrder = Arrays.copyOfRange(postorder, leftInOrder.length, postorder.length - 1);
root.left = buildTree(leftInOrder,leftPostOrder);
root.right = buildTree(rightInOrder,rightPostOrder);
return root;
}
}
Arrays.copyOfRange(inorder,0,index);截取的是inorder数组的索引为0到index-1的数据，左闭右开
105.从前序与中序遍历序列构造二叉树
题目
根据一棵树的前序遍历与中序遍历构造二叉树。
注意: 你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树：
解答
class Solution {
public TreeNode buildTree(int[] preorder, int[] inorder) {
if (preorder.length == 0)
return null;
int root_val = preorder[0];
TreeNode root = new TreeNode(root_val);
if (preorder.length == 1)//为叶子结点
return root;
int index = -1;
for (int i = 0; i < inorder.length; i++) {
if (inorder[i] == root_val){
index = i;
break;
}
}
int[] leftInOrder = Arrays.copyOfRange(inorder,0,index);
int[] rightInOrder = Arrays.copyOfRange(inorder,index + 1,inorder.length);
int[] leftPreOrder = Arrays.copyOfRange(preorder,1,leftInOrder.length + 1);
int[] rightPreOrder = Arrays.copyOfRange(preorder,leftInOrder.length + 1,preorder.length);
root.left = buildTree(leftPreOrder,leftInOrder);
root.right = buildTree(rightPreOrder,rightInOrder);
return root;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
