学习目标：
60天训练营打卡计划！
树的高度（Height）：
树的高度是从树根到最远叶子节点的最长路径的边数。
也就是说，高度是从根节点到树的最深处的距离。
高度用于衡量树的整体大小，以及在搜索、插入和删除等操作中的性能。
节点的深度（Depth）：
节点的深度是从树根到该节点的唯一路径的边数。
对于根节点来说，深度为1；对于其他节点，深度为其父节点的深度加1。
深度用于衡量特定节点在树中的位置。
学习内容：
515. 在每个树行中找最大值
- java中的正无穷的定义 ： Integer.MAX_VALUE;
- 层序遍历
class Solution {
public List<Integer> largestValues(TreeNode root) {
Queue<TreeNode> que = new LinkedList<>();
List<Integer> res = new ArrayList<>();
int size = -1;
if(root == null) return res;
que.add(root);
while(!que.isEmpty()){
size = que.size();
int max = -Integer.MAX_VALUE - 1;
while(size-- > 0){
TreeNode node = que.remove();
max = Math.max(max, node.val);
if(node.left != null) que.add(node.left);
if(node.right != null) que.add(node.right);
}
res.add(max);
}
return res;
}
}
110. 平衡二叉树
- 在平衡二叉树中，通常会要求树的左右子树的高度差不超过1，以确保树的平衡性。
- 因为是求树的高度，所以使用后序遍历法。
- 新建一个函数去求当前树的左右节点的最大高度，若在此过程中，左右子树的高度差大于1，则是不平衡的二叉树。
class Solution {
private int getHeight(TreeNode node){
if(node == null) return 0;
// 如果底层的二叉树非平衡，则直接递归。
int leftHigh = getHeight(node.left);
if(leftHigh == -1) return -1;
int rightHigh = getHeight(node.right);
if(rightHigh == -1) return -1;
// 判断当前的二叉树是否平衡。
if(Math.abs(leftHigh - rightHigh) > 1)
return -1;
else
// 否则返回左右子树的最大高度。（从下向上加）
return 1 + Math.max(leftHigh, rightHigh);
}
public boolean isBalanced(TreeNode root) {
return getHeight(root) == -1 ? false : true;
}
}
257. 二叉树的所有路径
- 使用前序遍历法（其实本题的逻辑 类似于 前序遍历打印所有的节点）
- 因为在前序遍历的过程中也是涉及到回溯的！
- 有递归的地方一定会有回溯。
- 递归负责追着目标探索新路，回溯负责找到回家的路。
- 学习了StringBuilder()方法
-
- StringBuilder 与 String 比较：
可变性：
String 对象是不可变的，一旦创建就不能被修改。每次对字符串进行修改都会创建一个新的字符串对象，这可能导致性能开销，尤其是在进行大量字符串拼接的情况下。StringBuilder 是可变的（所以在该题中被用于创建可变的字符串），它允许对字符串进行动态的修改，而不必创建新的对象。这使得它更适合在需要频繁修改字符串的情况下使用，例如在循环中进行字符串拼接。
- StringBuilder 与 String 比较：
class Solution {
private void traversal(TreeNode node ,List<Integer> paths ,List<String> res){
// 不需要判断node是否为空，因为主函数判断过！
paths.add(node.val);
if(node.left == null && node.right == null){
// 按照需要的结果拼接路径，并return
StringBuilder stb = new StringBuilder();
for(int i = 0; i < paths.size() - 1; i++){
stb.append(paths.get(i)).append("->");
}
stb.append(paths.get(paths.size() - 1));
res.add(stb.toString());
return;
}
if(node.left != null){
traversal(node.left, paths, res);
// 把递归时加入的节点弹出去
// 递归和回溯一定是相伴相生的
paths.remove(paths.size() - 1);
}
if(node.right != null){
traversal(node.right, paths, res);
// 把递归时加入的节点弹出去
// 递归和回溯一定是相伴相生的
paths.remove(paths.size() - 1);
}
}
public List<String> binaryTreePaths(TreeNode root) {
List<String> res = new ArrayList<>();
if(root == null)
return res;
List<Integer> path = new ArrayList<>();
traversal(root, path, res);
return res;
}
}
404.左叶子之和
- 注意：求的是左侧叶子结点的和（左侧叶子节点指：其不为空，其左右子节点都为空！）
- 使用后序遍历，一定要确定单层递归的逻辑。
- （当该节点是左子树节点，且其的左右子节点都为null，则将该点的值加到sum中）
- 还可以使用层序遍历！
- 很好想，但一定要明确题目的要求。
class Solution {
public int sumOfLeftLeaves(TreeNode root) {
if(root == null) return 0;
if(root.left == null && root.right == null) return 0;
int leftNum = sumOfLeftLeaves(root.left);
// 符合条件时最小递归的操作
if(root.left != null && root.left.left == null && root.left.right == null)
leftNum = leftNum + root.left.val;
int rightNum = sumOfLeftLeaves(root.right);
// 中
int sum = leftNum + rightNum;
return sum;
}
}
class Solution {
public int sumOfLeftLeaves(TreeNode root) {
Queue<TreeNode> que = newQ LinkedList<>();
int res = 0;
int size = -1;
if(root == null) return res;
que.add(root);
while(!que.isEmpty()){
size = que.size();
while(size-- > 0){
TreeNode node = que.remove();
if(node.left != null){
que.add(node.left);
if(node.left.left == null && node.left.right == null)
res += node.left.val;
}
if(node.right != null) que.add(node.right);
}
}
return res;
}
}
116. 填充每个节点的下一个右侧节点指针
- 完美二叉树！！
- 层序遍历法，yyds
- 对于size不为0的节点，队首存的是下一个本层节点的节点。故node.right.next = que.peek().left;
class Solution {
public Node connect(Node root) {
Queue<Node> que = new LinkedList<>();
int size = -1;
if(root == null) return root;
que.add(root);
while(!que.isEmpty()){
size = que.size();
while(size-- > 0){
Node node = que.remove();
if(node.left != null){
que.add(node.left);
node.left.next = node.right;
}
if(node.right != null){
que.add(node.right);
if(size == 0) node.right.next = null;
else node.right.next = que.peek().left;
}
}
}
return root;
}
}
117. 填充每个节点的下一个右侧节点指针 II
- 普通二叉树！！叶子节点不一定在同一层！
- 本题的难点：没法很快的找到本层的头节点，因为叶子节点的位置不确定。
- 解决方案：构造一个新的队列存放每层的节点，单独进行指针的指向。（tmp队列）
- 层序遍历法，yyds！
class Solution {
public Node connect(Node root) {
Queue<Node> que = new LinkedList<>();
// 专门用来做指向的队列
Queue<Node> tmp = new LinkedList<>();
int size = -1;
if(root == null) return root;
que.add(root);
while(!que.isEmpty()){
size = que.size();
while(size-- > 0){
Node node = que.remove();
if(node.left != null){
que.add(node.left);
}
if(node.right != null){
que.add(node.right);
}
tmp.add(node);
}
// 非常巧妙地设计，每一层分别单独做指向
while(!tmp.isEmpty()){
Node n = tmp.remove();
n.next = tmp.peek();
}
}
return root;
}
}
学习时间：
- 上午半小时，下午两个半小时，整理文档半小时。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
