13. 找树左下角的值
题目链接：513. 找树左下角的值 - 力扣（LeetCode）
被题目搞晕了：左下角的值并不是值左叶子节点！！！！
思路：
深度优先搜索：按照先左后右的顺序遍历子树，最先搜索到的最深的结点即所求的结点（更新深度判断即可）
class Solution {
int res = 0;
int max_h = 0;
public int findBottomLeftValue(TreeNode root) {
dfs(root, 1);
return res;
}
public void dfs(TreeNode root, int depth){
if(root == null){
return ;
}
// 遍历的第一个最深的叶子节点肯定就是最底层的最左节点（前序遍历嘛）
if(root.left == null && root.right == null){
// 证明是当前深度的最左边叶子节点，因为先递归左子树
if(depth > max_h){
res = root.val;
max_h = depth;
}
if(root.left != null)
dfs(root.left, depth + 1);
if(root.right != null)
dfs(root.right, depth + 1);
}
}
}
14. 路径总和I
思路：dfs从根节点遍历到叶子节点，判断这条路径是否符合要求即可。
Code
class Solution {
public boolean hasPathSum(TreeNode root, int targetSum) {
return dfs(root, targetSum);
}
public boolean dfs(TreeNode root, int targetSum){
if(root == null){
return false;
}
// 到达叶子节点，判断这条路径是否符合要求
if(root.left == null && root.right == null){
return targetSum - root.val == 0;
}
return dfs(root.left, targetSum - root.val) || dfs(root.right, targetSum - root.val);
}
}
15. 路径总和II
题目链接：113. 路径总和 II - 力扣（LeetCode）
DFS：爆搜版，每一条完整的路径都要新建一个tmp_list来记录，最终（叶子节点且满足条件）在存入res————不用回溯
缺点：时间费在大量创建tmp_list上！
Code
class Solution {
List<List<Integer>> result = new ArrayList<>();
public List<List<Integer>> pathSum(TreeNode root, int sum) {
dfs(root, sum, new ArrayList<>());
return result;
}
public void dfs(TreeNode root, int sum, List<Integer> list) {
//如果节点为空直接返回
if (root == null){
return;
}
sum -= root.val;
//因为list是引用传递，为了防止递归的时候分支污染，我们要在每个路径
//每一条完整的路径对应一个tmp
//中都要新建一个(subList)tmp（在上一次tmp的基础上）
List<Integer> tmp = new ArrayList(list);
tmp.add(root.val);
if (root.left == null && root.right == null && sum == 0) {
result.add(tmp);
return;
}
dfs(root.left, sum, tmp);
dfs(root.right, sum, tmp);
}
}
回溯版：这里之所以要回溯，那是因为我们始终在用一个list集合在记录res，当到达满足条件的叶子节点时，将本次路径重新new 出来加入res而已，为此就要回溯（弹出本次选中的末尾元素），为下一个路径做好准备！
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> list = new ArrayList<>();
public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
dfs(root, targetSum);
return res;
}
public void dfs(TreeNode root, int sum){
if(root == null){
return ;
}
sum -= root.val;// 选值
// 到达叶子节点
if(root.left == null && root.right == null && sum == 0){
list.add(root.val);
res.add(new ArrayList(list));
list.remove(list.size() - 1);// 要是在递归出口中加入叶子节点，最后一定要弹出（回溯！！！）
return ;
}
// 左 右
list.add(root.val);
dfs(root.left, sum);
dfs(root.right, sum);
list.remove(list.size() - 1);// 回溯
}
}
16. 路径总和III
题目链接：437. 路径总和 III - 力扣（LeetCode）
双重DFS：我们遍历每一个节点，从这个节点开始计算它的子树满足要求的路径。
我们访问每一个节点 node，检测以node 为起始节点（头节点）且向下延深的路径有多少种（第二次dfs判断左右子树是否右满足的情况）。我们递归遍历每一个节点的所有可能的路径，然后将这些路径数目加起来即为返回结果。
Code
class Solution {
int res = 0;
public int pathSum(TreeNode root, int targetSum) {
if(root == null){
return 0;
}
long longTargetSum = targetSum;
dfs(root, longTargetSum);// 每一个根节点都要dfs判断
// 为下一次dfs做好准备
pathSum(root.left, targetSum);
pathSum(root.right, targetSum);
return res;
}
public void dfs(TreeNode root, long sum){
if(root == null){
return ;
}
sum -= root.val;
if(sum == 0){
rse ++;
// 这里不能return !! 下面可能还要答案集
}
dfs(root.left, sum);
dfs(root.right, sum);
}
}
17. 从中序与后序遍历序列构造二叉树
题目链接：106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）
具体思路回顾之前的博客：二叉树的遍历_塔塔开!!!的博客-CSDN博客_二叉树遍历
Code
class Solution {
// 将中序的值对应位置记下，方便后面找到中序跟所在位置
Map<Integer, Integer> pos = new HashMap<>();
int hou[];
public TreeNode buildTree(int[] inorder, int[] postorder) {
int n = inorder.length;
hou = postorder;
for(int i = 0; i < n; i ++) pos.put(inorder[i], i);
TreeNode root = build(0, n - 1, 0, n - 1);
return root;
}
/**
由中和后序构造二叉树
build：返回二叉树的根节点
*/
public TreeNode build(int il, int ir, int pl, int pr){
if(il > ir || pl > pr) return null;
int root = hou[pr];
int k = pos.get(root);
int x = k - 1 - il + pl;
// 递归创建左右子树
TreeNode node = new TreeNode(root);
node.left = build(il, k - 1, pl, x);
node.right = build(k + 1, ir, x + 1, pr - 1);
return node;
}
}
18. 从前序与中序遍历序列构造二叉树
题目链接：105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）
思路：看上一题即可
Code
class Solution {
Map<Integer, Integer> mp = new HashMap<Integer, Integer>();
int[] qian;
public TreeNode buildTree(int[] pre, int[] in) {
int n = pre.length;
qian = pre;
for(int i = 0; i < n; i ++) mp.put(in[i], i);
return build(0, n - 1, 0, n - 1);
}
public TreeNode build(int pl, int pr, int il, int ir){
if(pl > pr || il > ir) return null;
int root = qian[pl];
int k = mp.get(root);
TreeNode node = new TreeNode(root);
int x = k - 1 - il + pl + 1;
node.left = build(pl + 1, x, il, k - 1);
node.right = build(x + 1, pr, k + 1, ir);
return node;
}
}